AI Researcher and Video Studio implementation complete

2026-01-05 15:49:51 +05:30
parent b134e9dc7e
commit 0b63ae7fc1
200 changed files with 39535 additions and 1375 deletions
--- a/Studio/YOUTUBE_CREATOR_AI_OPTIMIZATION.md
+++ b/Studio/YOUTUBE_CREATOR_AI_OPTIMIZATION.md
@@ -0,0 +1,101 @@
+# YouTube Creator AI Call Optimization Report
+
+## Current AI Call Analysis
+
+### 1. Video Planning (`planner.py`)
+- **Current**: 1 AI call (`llm_text_gen`) to generate video plan
+- **Status**: ✅ Optimized - Single call for complete plan
+- **Optimization Potential**: None (necessary for quality)
+
+### 2. Scene Generation (`scene_builder.py`)
+- **Current**: 
+  - 1 AI call (`llm_text_gen`) to generate all scenes
+  - Enhancement calls based on duration:
+    - Shorts: 0 calls (skip enhancement) ✅
+    - Medium: 1 call (batch enhancement) ✅
+    - Long: 2 calls (split batch enhancement) ✅
+- **Status**: ✅ Already optimized
+- **Optimization Potential**: Combine plan + scenes for shorts (save 1 call)
+
+### 3. Audio Generation (`renderer.py`)
+- **Current**: 1 external API call per scene (`generate_audio`)
+- **Status**: ⚠️ Can be optimized
+- **Optimization Potential**: 
+  - Shorts: Batch all narrations into 1-2 calls
+  - Medium/Long: Batch narrations in groups of 3-5 scenes
+
+### 4. Video Generation (`renderer.py`)
+- **Current**: 1 external API call per scene (`generate_text_video` - WaveSpeed)
+- **Status**: ✅ Cannot optimize (API limitation - one video per call)
+- **Optimization Potential**: None (external API constraint)
+
+## Optimization Strategy
+
+### Shorts (≤60 seconds, ~8 scenes)
+**Current**: 1 (plan) + 1 (scenes) + 0 (enhancement) + 8 (audio) = **10 calls**
+**Optimized**: 1 (plan+scenes combined) + 0 (enhancement) + 2 (batched audio) = **3 calls**
+**Savings**: 70% reduction (7 fewer calls)
+
+### Medium (1-4 minutes, ~12 scenes)
+**Current**: 1 (plan) + 1 (scenes) + 1 (enhancement) + 12 (audio) = **15 calls**
+**Optimized**: 1 (plan) + 1 (scenes) + 1 (enhancement) + 3 (batched audio) = **6 calls**
+**Savings**: 60% reduction (9 fewer calls)
+
+### Long (4-10 minutes, ~20 scenes)
+**Current**: 1 (plan) + 1 (scenes) + 2 (enhancement) + 20 (audio) = **24 calls**
+**Optimized**: 1 (plan) + 1 (scenes) + 2 (enhancement) + 5 (batched audio) = **9 calls**
+**Savings**: 62.5% reduction (15 fewer calls)
+
+## Implementation Plan
+
+1. ✅ Combine plan + scene generation for shorts (save 1 call) - **IMPLEMENTED**
+2. ⚠️ Audio generation: Cannot batch (each scene needs separate audio file - external API limitation)
+3. ✅ Keep video generation as-is (external API limitation)
+
+## Final Optimized Call Counts
+
+### Shorts (≤60 seconds, ~8 scenes)
+**Before**: 1 (plan) + 1 (scenes) + 0 (enhancement) + 8 (audio) = **10 calls**
+**After**: 1 (plan+scenes combined) + 0 (enhancement) + 8 (audio) = **9 calls**
+**Savings**: 10% reduction (1 fewer call)
+**Note**: Audio calls are necessary per scene (external API limitation)
+
+### Medium (1-4 minutes, ~12 scenes)
+**Before**: 1 (plan) + 1 (scenes) + 1 (enhancement) + 12 (audio) = **15 calls**
+**After**: 1 (plan) + 1 (scenes) + 1 (enhancement) + 12 (audio) = **15 calls**
+**Savings**: Already optimized (enhancement batched)
+**Note**: Audio calls are necessary per scene (external API limitation)
+
+### Long (4-10 minutes, ~20 scenes)
+**Before**: 1 (plan) + 1 (scenes) + 2 (enhancement) + 20 (audio) = **24 calls**
+**After**: 1 (plan) + 1 (scenes) + 2 (enhancement) + 20 (audio) = **24 calls**
+**Savings**: Already optimized (enhancement batched)
+**Note**: Audio calls are necessary per scene (external API limitation)
+
+## Key Optimizations Implemented
+
+1. **Shorts Optimization**: Combined plan + scene generation into single AI call
+   - Saves 1 LLM text generation call
+   - Maintains quality by generating both in one comprehensive prompt
+
+2. **Scene Enhancement Batching**: Already optimized
+   - Shorts: Skip enhancement (0 calls)
+   - Medium: Batch all scenes (1 call)
+   - Long: Split into 2 batches (2 calls)
+
+3. **Audio Generation**: Cannot be optimized further
+   - Each scene requires separate audio file
+   - External API (WaveSpeed) limitation - one audio per call
+   - This is necessary for quality (each scene has unique narration)
+
+4. **Video Generation**: Cannot be optimized
+   - External API (WaveSpeed WAN 2.5) limitation
+   - One video per API call is required
+
+## Quality Preservation
+
+All optimizations maintain output quality:
+- Combined plan+scenes for shorts uses comprehensive prompt
+- Batch enhancement maintains scene consistency
+- No quality loss from optimizations
+
--- a/Studio/YOUTUBE_CREATOR_COMPLETION_REVIEW.md
+++ b/Studio/YOUTUBE_CREATOR_COMPLETION_REVIEW.md
@@ -0,0 +1,405 @@
+# YouTube Creator Studio - Completion Review & Enhancement Plan
+
+## 📊 Implementation Summary
+
+### ✅ Completed Features
+
+#### Backend Services
+1. **YouTube Planner Service** (`backend/services/youtube/planner.py`)
+   - AI-powered video plan generation
+   - Persona integration for tone/style
+   - Duration-aware planning (shorts/medium/long)
+   - Source content conversion (blog/story → video)
+   - Reference image support
+
+2. **YouTube Scene Builder Service** (`backend/services/youtube/scene_builder.py`)
+   - Converts plans into structured scenes
+   - Narration generation per scene
+   - Visual prompt enhancement
+   - Custom script parsing support
+   - Emphasis tags (hook, main_content, cta)
+
+3. **YouTube Video Renderer Service** (`backend/services/youtube/renderer.py`)
+   - WAN 2.5 text-to-video integration
+   - Audio generation with voice selection
+   - Scene-by-scene rendering
+   - Video concatenation (combine scenes)
+   - Usage tracking and cost calculation
+   - Asset library integration
+
+#### API Endpoints (`backend/api/youtube/router.py`)
+- `POST /api/youtube/plan` - Generate video plan
+- `POST /api/youtube/scenes` - Build scenes from plan
+- `POST /api/youtube/scenes/{id}/update` - Update individual scene
+- `POST /api/youtube/render` - Start async video rendering
+- `GET /api/youtube/render/{task_id}` - Get render status
+- `GET /api/youtube/videos/{filename}` - Serve generated videos
+
+#### Frontend Components
+- **YouTube Creator Studio** (`frontend/src/components/YouTubeCreator/YouTubeCreator.tsx`)
+  - 3-step workflow (Plan → Scenes → Render)
+  - Scene editing interface
+  - Real-time render progress
+  - Video preview and download
+  - Resolution selection (480p/720p/1080p)
+  - Voice selection
+  - Scene enable/disable toggle
+
+#### Integration Points
+- ✅ Dashboard navigation (Generate Content → Video)
+- ✅ Persona system integration
+- ✅ Subscription validation
+- ✅ Asset tracking
+- ✅ Usage tracking
+- ✅ Task manager for async operations
+
+---
+
+## 🔍 Low-Hanging Features to Consolidate
+
+### 1. **Error Handling & Retry Logic** ⚠️ HIGH PRIORITY
+**Current State**: Basic error handling, no retry logic for video generation
+**Opportunity**: Add robust retry with exponential backoff (like `ProductImageService`)
+
+**Implementation**:
+- Add retry wrapper in `YouTubeVideoRendererService.render_scene_video()`
+- Handle transient API errors (503, timeouts)
+- Skip retries for validation errors (4xx)
+- Update task status with retry attempts
+
+**Files to Modify**:
+- `backend/services/youtube/renderer.py`
+- Add `_render_with_retry()` method
+
+### 2. **Video Generation Service Consolidation** 🔄 MEDIUM PRIORITY
+**Current State**: YouTube renderer duplicates some logic from `StoryVideoGenerationService`
+**Opportunity**: Extract common video operations into shared service
+
+**Shared Operations**:
+- Video concatenation
+- Audio/video synchronization
+- File saving patterns
+- Progress callbacks
+
+**Files to Consider**:
+- `backend/services/story_writer/video_generation_service.py`
+- `backend/services/youtube/renderer.py`
+- Create: `backend/services/shared/video_utils.py`
+
+### 3. **Blog Writer → YouTube Integration** 🎯 HIGH PRIORITY
+**Current State**: API supports `source_content_id` but no UI integration
+**Opportunity**: Add "Create Video" button in Blog Writer export phase
+
+**Implementation**:
+- Add button in `BlogExport.tsx` or similar
+- Pre-fill YouTube Creator with blog content
+- Use blog title/outline as video plan input
+- Map blog sections to video scenes
+
+**Files to Modify**:
+- `frontend/src/components/BlogWriter/Phases/BlogExport.tsx`
+- `backend/api/youtube/router.py` (already supports this)
+
+### 4. **Scene Preview & Thumbnail Generation** 🖼️ MEDIUM PRIORITY
+**Current State**: No preview of scenes before rendering
+**Opportunity**: Generate thumbnail images for each scene
+
+**Implementation**:
+- Use existing image generation to create scene thumbnails
+- Show thumbnails in scene review step
+- Allow regeneration of individual thumbnails
+
+**Files to Add**:
+- `backend/services/youtube/thumbnail_service.py`
+- Update `YouTubeCreator.tsx` to show thumbnails
+
+### 5. **Video Templates & Presets** 📋 LOW PRIORITY
+**Current State**: All videos start from scratch
+**Opportunity**: Pre-built templates for common video types
+
+**Templates**:
+- Product Demo
+- Tutorial/How-To
+- Explainer Video
+- Testimonial
+- Social Media Short
+
+**Implementation**:
+- Add template selection in Step 1
+- Pre-fill plan with template structure
+- Allow customization
+
+### 6. **Batch Scene Regeneration** 🔄 MEDIUM PRIORITY
+**Current State**: Must regenerate all scenes if one fails
+**Opportunity**: Regenerate individual scenes without losing others
+
+**Implementation**:
+- Add "Regenerate Scene" button per scene
+- Keep other scenes intact
+- Update scene in place
+
+### 7. **Cost Estimation Before Rendering** 💰 HIGH PRIORITY
+**Current State**: Cost only shown after rendering
+**Opportunity**: Show estimated cost before starting render
+
+**Implementation**:
+- Calculate cost based on:
+  - Number of scenes
+  - Resolution
+  - Duration estimates
+- Show cost breakdown in Step 3
+- Warn if approaching subscription limits
+
+**Files to Modify**:
+- `backend/api/youtube/router.py` - Add `/estimate-cost` endpoint
+- `frontend/src/components/YouTubeCreator/YouTubeCreator.tsx`
+
+### 8. **Video Analytics & Optimization Suggestions** 📊 LOW PRIORITY
+**Current State**: No post-generation insights
+**Opportunity**: Provide YouTube optimization tips
+
+**Features**:
+- SEO score for video plan
+- Hook effectiveness analysis
+- CTA strength rating
+- Duration optimization suggestions
+
+### 9. **Multi-Language Support** 🌍 MEDIUM PRIORITY
+**Current State**: English only
+**Opportunity**: Leverage WAN 2.5 multilingual capabilities
+
+**Implementation**:
+- Add language selector in Step 1
+- Pass language to planner/scene builder
+- Use appropriate voice for language
+
+### 10. **Video Export Formats** 📦 LOW PRIORITY
+**Current State**: MP4 only
+**Opportunity**: Export in multiple formats
+
+**Formats**:
+- MP4 (current)
+- WebM (web optimized)
+- MOV (professional)
+- GIF (for previews)
+
+---
+
+## 🚀 New Features to Add
+
+### 1. **YouTube Shorts Optimizer** ⭐ HIGH VALUE
+**Description**: Specialized mode for YouTube Shorts with vertical format (9:16)
+
+**Features**:
+- Automatic aspect ratio detection
+- Vertical video generation (1080x1920)
+- Hook-first scene prioritization
+- Subtitle generation
+- Trending hashtag suggestions
+
+**Implementation**:
+- Add "Shorts Mode" toggle
+- Modify renderer to use vertical resolution
+- Add subtitle overlay service
+
+### 2. **A/B Testing for Hooks** 🧪 MEDIUM VALUE
+**Description**: Generate multiple hook variations and test
+
+**Features**:
+- Generate 3-5 hook variations
+- Side-by-side comparison
+- User selects best hook
+- Use selected hook in final video
+
+### 3. **Video Script Export** 📝 LOW VALUE
+**Description**: Export narration as script file
+
+**Formats**:
+- SRT (subtitles)
+- VTT (WebVTT)
+- TXT (plain text)
+- DOCX (formatted)
+
+### 4. **Collaborative Editing** 👥 LOW PRIORITY
+**Description**: Share video projects for team review
+
+**Features**:
+- Share project link
+- Comment on scenes
+- Approve/reject scenes
+- Version history
+
+### 5. **AI-Powered Scene Transitions** ✨ MEDIUM VALUE
+**Description**: Smart transitions between scenes
+
+**Features**:
+- Analyze scene content
+- Suggest transition type (fade, cut, zoom)
+- Apply transitions automatically
+- Custom transition library
+
+---
+
+## 🔧 Robustness Improvements
+
+### 1. **Better Error Messages**
+- **Current**: Generic error messages
+- **Improvement**: Context-specific errors with recovery suggestions
+- **Example**: "Scene 3 failed: API timeout. Would you like to retry this scene?"
+
+### 2. **Partial Success Handling**
+- **Current**: All-or-nothing rendering
+- **Improvement**: Continue rendering other scenes if one fails
+- **Show**: Which scenes succeeded/failed
+- **Allow**: Re-render only failed scenes
+
+### 3. **Progress Granularity**
+- **Current**: Overall progress percentage
+- **Improvement**: Per-scene progress with ETA
+- **Show**: Current operation (generating audio, rendering video, combining)
+
+### 4. **Resume Failed Renders**
+- **Current**: Must restart from beginning
+- **Improvement**: Resume from last successful scene
+- **Store**: Progress in task manager
+- **Resume**: On task restart
+
+### 5. **Video Quality Validation**
+- **Current**: No validation before serving
+- **Improvement**: Validate video file integrity
+- **Check**: File size, duration, codec
+- **Warn**: If video seems corrupted
+
+### 6. **Rate Limiting & Queue Management**
+- **Current**: No queue for concurrent requests
+- **Improvement**: Queue system for video rendering
+- **Limit**: Max concurrent renders per user
+- **Show**: Position in queue
+
+---
+
+## 📈 Metrics & Analytics
+
+### Track These Metrics:
+1. **Generation Success Rate**: % of successful video renders
+2. **Average Render Time**: Per scene and full video
+3. **Cost per Video**: Average cost breakdown
+4. **User Drop-off Points**: Where users abandon workflow
+5. **Most Used Features**: Scene editing, resolution selection, etc.
+6. **Error Frequency**: Most common errors and causes
+
+### Dashboard to Add:
+- Video generation history
+- Cost tracking
+- Success rate trends
+- Popular video types
+
+---
+
+## 🎯 Priority Ranking
+
+### Phase 1: Critical (Do First)
+1. ✅ Error handling & retry logic
+2. ✅ Cost estimation before rendering
+3. ✅ Blog Writer → YouTube integration
+4. ✅ Partial success handling
+
+### Phase 2: High Value (Next Sprint)
+5. ✅ Scene preview/thumbnails
+6. ✅ YouTube Shorts optimizer
+7. ✅ Better error messages
+8. ✅ Resume failed renders
+
+### Phase 3: Nice to Have (Future)
+9. ✅ Video templates
+10. ✅ A/B testing for hooks
+11. ✅ Multi-language support
+12. ✅ Analytics dashboard
+
+---
+
+## 🔗 Integration Opportunities
+
+### Existing Systems to Leverage:
+1. **Story Writer Video Service**: Reuse video concatenation logic
+2. **Image Generation**: For scene thumbnails
+3. **Audio Generation**: Already integrated
+4. **Asset Library**: Already integrated
+5. **Subscription System**: Already integrated
+6. **Persona System**: Already integrated
+
+### New Integrations to Consider:
+1. **Content Calendar**: Schedule video generation
+2. **SEO Dashboard**: Video SEO optimization
+3. **Social Media Scheduler**: Direct YouTube upload
+4. **Analytics Integration**: YouTube Analytics API
+
+---
+
+## 📝 Documentation Needs
+
+1. **API Documentation**: OpenAPI/Swagger updates
+2. **User Guide**: Step-by-step tutorial
+3. **Video Tutorial**: Screen recording of workflow
+4. **Developer Guide**: How to extend YouTube Creator
+5. **Troubleshooting Guide**: Common issues and solutions
+
+---
+
+## 🧪 Testing Checklist
+
+### Unit Tests Needed:
+- [ ] Planner service with various inputs
+- [ ] Scene builder with edge cases
+- [ ] Renderer error handling
+- [ ] Cost calculation accuracy
+
+### Integration Tests Needed:
+- [ ] Full workflow end-to-end
+- [ ] Blog → YouTube conversion
+- [ ] Multi-scene rendering
+- [ ] Error recovery
+
+### E2E Tests Needed:
+- [ ] User creates video from idea
+- [ ] User edits scenes
+- [ ] User renders and downloads
+- [ ] User converts blog to video
+
+---
+
+## 💡 Quick Wins (Can Do Today)
+
+1. **Add cost estimation endpoint** (1-2 hours)
+2. **Improve error messages** (1 hour)
+3. **Add scene count validation** (30 mins)
+4. **Add loading states** (30 mins)
+5. **Add keyboard shortcuts** (1 hour)
+
+---
+
+## 📊 Completion Status
+
+- **Backend Services**: ✅ 100% Complete
+- **API Endpoints**: ✅ 100% Complete
+- **Frontend UI**: ✅ 100% Complete
+- **Error Handling**: ⚠️ 60% Complete (needs retry logic)
+- **Documentation**: ⚠️ 40% Complete (needs user guide)
+- **Testing**: ⚠️ 20% Complete (needs comprehensive tests)
+- **Integration**: ⚠️ 50% Complete (Blog Writer integration pending)
+
+**Overall Completion**: ~75%
+
+---
+
+## 🎉 Summary
+
+The YouTube Creator Studio is **functionally complete** and ready for production use. The core workflow works end-to-end, but there are several **low-hanging improvements** that would significantly enhance robustness and user experience:
+
+1. **Error handling** with retries
+2. **Cost estimation** before rendering
+3. **Blog Writer integration** for content conversion
+4. **Better progress feedback** and partial success handling
+
+These improvements can be implemented incrementally without disrupting the existing functionality.
+
--- a/Studio/youtube-creator-scene-building-flow.md
+++ b/Studio/youtube-creator-scene-building-flow.md
@@ -0,0 +1,148 @@
+# YouTube Creator: Build Scenes from Plan - User Flow & Safeguards
+
+## User Flow
+
+### Step-by-Step Process
+
+1. **User clicks "Build Scenes from Plan" button**
+   - **Location**: `ScenesStep` component (Step 2)
+   - **Condition**: Button only shows when `scenes.length === 0`
+   - **Handler**: `handleBuildScenes()` in `YouTubeCreator.tsx`
+
+2. **Frontend Validation**
+   - ✅ Checks if `videoPlan` exists (shows error if missing)
+   - ✅ **NEW**: Checks if scenes already exist (prevents duplicate calls)
+   - ✅ Sets loading state to prevent double-clicks
+   - ✅ Shows preflight check via `OperationButton` (subscription validation)
+
+3. **API Call**
+   - **Endpoint**: `POST /api/youtube/scenes`
+   - **Payload**: `{ video_plan: VideoPlan, custom_script?: string }`
+   - **Client**: `youtubeApi.buildScenes(videoPlan)`
+
+4. **Backend Processing** (`YouTubeSceneBuilderService.build_scenes_from_plan`)
+   
+   **Optimization Strategy (minimizes AI calls):**
+   
+   a. **Check for existing scenes** (0 AI calls)
+      - If `video_plan.scenes` exists and `_scenes_included=True` → Reuse scenes
+      - Logs: `♻️ Reusing X scenes from plan - skipping generation`
+   
+   b. **Custom script parsing** (0 AI calls)
+      - If `custom_script` provided → Parse into scenes without AI
+   
+   c. **Shorts optimization** (0 AI calls if already in plan)
+      - If `duration_type="shorts"` and `_scenes_included=True` → Use normalized scenes
+      - Otherwise → Generate scenes normally (1 AI call)
+   
+   d. **Medium/Long videos** (1-3 AI calls)
+      - Generate scenes: 1 AI call
+      - Batch enhance prompts:
+        - Shorts: Skip enhancement (0 calls)
+        - Medium: 1 batch call for all scenes (1 call)
+        - Long: 2 batch calls, split scenes (2 calls)
+   
+   **Total AI calls per video type:**
+   - **Shorts** (with optimization): 0-1 calls (0 if included in plan, 1 if not)
+   - **Medium**: 2 calls (1 generation + 1 batch enhancement)
+   - **Long**: 3 calls (1 generation + 2 batch enhancements)
+   - **Custom script**: 0-2 calls (0 parsing + 0-2 enhancements)
+
+5. **Response Processing**
+   - Normalizes scene data (adds `enabled: true` by default)
+   - Updates state via `updateState({ scenes: updatedScenes })`
+   - Shows success message
+   - Navigates to Step 2 (Scenes review)
+
+## Safeguards to Prevent Wasting AI Calls
+
+### Frontend Safeguards
+
+1. **Button Visibility**
+   - Button only appears when `scenes.length === 0`
+   - Prevents accidental clicks when scenes exist
+
+2. **Duplicate Call Prevention** ✅ **NEW**
+   ```typescript
+   if (scenes.length > 0) {
+     console.warn('[YouTubeCreator] Scenes already exist, skipping build');
+     setError('Scenes have already been generated...');
+     return;
+   }
+   ```
+
+3. **Loading State**
+   - Button disabled during `loading` state
+   - Prevents multiple simultaneous calls
+
+4. **Preflight Check**
+   - `OperationButton` performs subscription validation before API call
+   - Shows cost estimate and subscription limits
+   - Prevents calls if limits exceeded (but allows click to show modal)
+
+### Backend Safeguards
+
+1. **Scene Reuse Detection** ✅ **ENHANCED**
+   - Checks `video_plan.scenes` and `_scenes_included` flag
+   - Reuses existing scenes (0 AI calls)
+   - Logs reuse to track optimization success
+
+2. **Shorts Optimization**
+   - When plan is generated with `include_scenes=True` for shorts
+   - Scenes are included in plan generation (1 combined call)
+   - Scene builder reuses them instead of regenerating
+
+3. **Batch Processing**
+   - Visual prompt enhancement batched (1-2 calls instead of N calls)
+   - Shorts skip enhancement entirely (saves 1 call)
+
+4. **Error Handling**
+   - Graceful fallbacks if batch enhancement fails
+   - Uses original prompts instead of failing completely
+
+## Testing Recommendations
+
+### To Test Without Wasting AI Calls
+
+1. **Use Shorts Duration**
+   - Scenes included in plan generation (optimized)
+   - Scene building reuses existing scenes (0 calls)
+
+2. **Use Custom Script**
+   - Parse custom script (0 AI calls)
+   - Still needs enhancement for medium/long (1-2 calls)
+
+3. **Test with Existing Scenes**
+   - Frontend guard prevents duplicate calls
+   - Backend detects and reuses existing scenes
+
+4. **Monitor Logs**
+   - Look for `♻️ Reusing X scenes` messages
+   - Verify `0 AI calls` for optimized paths
+   - Check scene count matches expectations
+
+### Log Messages to Watch
+
+- `♻️ Reusing X scenes from plan - skipping generation` ✅ **NEW**
+- `Using scenes from optimized plan+scenes call` (shorts optimization)
+- `Skipping prompt enhancement for shorts` (saves 1 call)
+- `Batch enhancing X scenes in 1 AI call` (medium optimization)
+- `Batch enhancing X scenes in 2 AI calls` (long optimization)
+
+## API Call Summary
+
+| Video Type | Scenario | AI Calls | Details |
+|------------|----------|----------|---------|
+| Shorts | Plan with scenes | 0 | Reuses scenes from plan |
+| Shorts | Plan without scenes | 1 | Generates scenes only (no enhancement) |
+| Medium | Normal flow | 2 | 1 generation + 1 batch enhancement |
+| Long | Normal flow | 3 | 1 generation + 2 batch enhancements |
+| Any | Custom script | 0-2 | 0 parsing + 0-2 enhancements |
+
+## Code References
+
+- **Frontend Handler**: `frontend/src/components/YouTubeCreator/YouTubeCreator.tsx:214`
+- **API Endpoint**: `backend/api/youtube/router.py:295`
+- **Scene Builder**: `backend/services/youtube/scene_builder.py:26`
+- **Operation Helper**: `frontend/src/components/YouTubeCreator/utils/operationHelpers.ts:136`
+