> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/darkzOGx/youtube-automation-agent/llms.txt
> Use this file to discover all available pages before exploring further.

# ProductionManagementAgent

> AI-powered video production and asset management agent

## Overview

The `ProductionManagementAgent` orchestrates the complete video production pipeline, from script processing to final video assembly. It manages assets, generates AI video content, creates audio narration, generates captions, and assembles the final video.

## Constructor

<ParamField path="db" type="Database" required>
  Database instance for production data
</ParamField>

<ParamField path="credentials" type="Credentials" required>
  Credentials manager with API access
</ParamField>

```javascript theme={null}
const { ProductionManagementAgent } = require('./agents/production-management-agent');

const agent = new ProductionManagementAgent(db, credentials);
```

## Properties

<ResponseField name="pipeline" type="Array">
  Production pipeline with all content in various stages
</ResponseField>

<ResponseField name="assets" type="Map">
  Asset management map for tracking production files
</ResponseField>

<ResponseField name="aiVideoGenerator" type="AIVideoGenerator">
  AI video generation service
</ResponseField>

<ResponseField name="logger" type="Logger">
  Logger instance for tracking production
</ResponseField>

## Methods

### initialize()

Initializes the agent, creates directories, and loads pipeline.

<ParamField path="return" type="Promise<boolean>">
  Returns true when initialization is complete
</ParamField>

```javascript theme={null}
await agent.initialize();
// Creates: data/production, data/assets, data/videos, 
//          data/audio, data/scripts, temp/processing
```

### processContent(contentData)

Processes complete content through production pipeline.

<ParamField path="contentData" type="Object" required>
  Content package with strategy, script, thumbnail, and SEO data
</ParamField>

<ParamField path="contentData.strategy" type="Object" required>
  Content strategy from ContentStrategyAgent
</ParamField>

<ParamField path="contentData.script" type="Object" required>
  Video script from ScriptWriterAgent
</ParamField>

<ParamField path="contentData.thumbnail" type="Object" required>
  Thumbnail from ThumbnailDesignerAgent
</ParamField>

<ParamField path="contentData.seo" type="Object" required>
  SEO data from SEOOptimizerAgent
</ParamField>

<ParamField path="return" type="Promise<Object>">
  Production data with all generated assets
</ParamField>

<ResponseField name="production.id" type="string">
  Unique production ID
</ResponseField>

<ResponseField name="production.status" type="string">
  Production status: processing or ready
</ResponseField>

<ResponseField name="production.assets" type="Object">
  All generated assets (script, thumbnail, audio, video, captions, finalVideo)
</ResponseField>

<ResponseField name="production.timeline" type="Object">
  Timestamps for each production milestone
</ResponseField>

<ResponseField name="production.scheduledPublishTime" type="string">
  Calculated publish time
</ResponseField>

<ResponseField name="production.priority" type="number">
  Production priority (0-100)
</ResponseField>

```javascript theme={null}
const contentData = {
  strategy: { /* from ContentStrategyAgent */ },
  script: { /* from ScriptWriterAgent */ },
  thumbnail: { /* from ThumbnailDesignerAgent */ },
  seo: { /* from SEOOptimizerAgent */ }
};

const production = await agent.processContent(contentData);

console.log(production);
// {
//   id: 'prod_1234567890_abc123_xyz789',
//   status: 'ready',
//   assets: {
//     script: { originalPath: '...', ttsPath: '...', duration: '8:30', sections: 5 },
//     thumbnail: { path: '...', dimensions: { width: 1280, height: 720 }, fileSize: 156789 },
//     audio: { path: '...', duration: '8:30', format: 'mp3', generatedWith: 'AI' },
//     video: { visualAssets: [...], duration: '8:30', format: 'mp4', generatedWith: 'AI' },
//     captions: { path: '...', format: 'srt', language: 'en' },
//     finalVideo: { path: '...', fileSize: 45678901, duration: '8:30', resolution: '1920x1080' }
//   },
//   timeline: {
//     created: '2026-03-05T10:00:00.000Z',
//     scriptReady: '2026-03-05T10:00:01.000Z',
//     thumbnailReady: '2026-03-05T10:00:02.000Z',
//     audioGenerated: '2026-03-05T10:01:30.000Z',
//     videoGenerated: '2026-03-05T10:03:00.000Z',
//     captionsGenerated: '2026-03-05T10:03:15.000Z',
//     readyForUpload: '2026-03-05T10:05:00.000Z'
//   },
//   scheduledPublishTime: '2026-03-10T14:00:00.000Z',
//   priority: 75,
//   estimatedDuration: '8:30'
// }
```

### generateVideoContent(productionData)

Generates AI video content using visual prompts from script.

<ParamField path="productionData" type="Object" required>
  Production data object
</ParamField>

<ParamField path="return" type="Promise<Array>">
  Array of generated visual assets
</ParamField>

```javascript theme={null}
const visualAssets = await agent.generateVideoContent(productionData);
// Generates 3-5 AI images based on script content
// Uses DALL-E or similar service via AIVideoGenerator
```

### generateAudioNarration(productionData)

Generates AI audio narration from script.

<ParamField path="productionData" type="Object" required>
  Production data with script assets
</ParamField>

<ParamField path="return" type="Promise<string>">
  Path to generated audio file
</ParamField>

```javascript theme={null}
const audioPath = await agent.generateAudioNarration(productionData);
// Generates MP3 audio using AI TTS service
// Reads from productionData.assets.script.ttsPath
```

### generateCaptions(productionData)

Generates SRT captions with timestamps.

<ParamField path="productionData" type="Object" required>
  Production data with script
</ParamField>

<ParamField path="return" type="Promise<string>">
  Path to SRT caption file
</ParamField>

```javascript theme={null}
const captionsPath = await agent.generateCaptions(productionData);
// Creates properly formatted SRT file with:
// - 8 words per caption for readability
// - Timestamps synced to script sections
// - Formatted for YouTube upload
```

### assembleVideo(productionData)

Assembles final video from all assets.

<ParamField path="productionData" type="Object" required>
  Production data with all assets
</ParamField>

<ParamField path="return" type="Promise<string>">
  Path to final video file
</ParamField>

```javascript theme={null}
const finalVideo = await agent.assembleVideo(productionData);
// Combines:
// - AI-generated visual assets
// - Audio narration
// - Text overlays and transitions
// Outputs: 1920x1080 MP4 at 30fps
```

### processScript(script)

Processes and formats script for production.

<ParamField path="script" type="Object" required>
  Script from ScriptWriterAgent
</ParamField>

<ParamField path="return" type="Promise<Object>">
  Processed script assets with paths
</ParamField>

```javascript theme={null}
const scriptAsset = await agent.processScript(script);
// {
//   originalPath: 'data/scripts/1234567890_script.json',
//   ttsPath: 'data/scripts/1234567890_script_tts.txt',
//   duration: '8:30',
//   sections: 5
// }
```

### formatScriptForTTS(script)

Formats script into TTS-friendly text.

<ParamField path="script" type="Object" required>
  Complete script object
</ParamField>

<ParamField path="return" type="string">
  Plain text formatted for text-to-speech
</ParamField>

```javascript theme={null}
const ttsText = agent.formatScriptForTTS(script);
// Extracts spoken content:
// - Hook text
// - Introduction narration
// - Main content (filtering visual cues)
// - Conclusion
// - Call to action
// Removes: section markers, timestamps, visual notes
```

### processThumbnail(thumbnail)

Processes thumbnail for production and generates AI variant.

<ParamField path="thumbnail" type="Object" required>
  Thumbnail from ThumbnailDesignerAgent
</ParamField>

<ParamField path="return" type="Promise<Object>">
  Processed thumbnail asset
</ParamField>

```javascript theme={null}
const thumbAsset = await agent.processThumbnail(thumbnail);
// Attempts AI thumbnail generation first, falls back to original
```

### createSRTCaptions(productionData)

Creates properly formatted SRT caption file.

<ParamField path="productionData" type="Object" required>
  Production data with script
</ParamField>

<ParamField path="return" type="Promise<string>">
  SRT formatted caption string
</ParamField>

```javascript theme={null}
const srt = await agent.createSRTCaptions(productionData);
// 1
// 00:00:00,000 --> 00:00:03,500
// Have you ever wondered how JavaScript Promises
//
// 2
// 00:00:03,500 --> 00:00:07,000
// actually works? Let me show you exactly
```

### calculatePublishTime(strategy)

Calculates optimal publish time from strategy.

<ParamField path="strategy" type="Object" required>
  Content strategy
</ParamField>

<ParamField path="return" type="string">
  ISO timestamp for publishing
</ParamField>

```javascript theme={null}
const publishTime = agent.calculatePublishTime(strategy);
// Uses strategy.bestPublishTime or defaults to tomorrow 2 PM
```

### calculatePriority(strategy)

Calculates production priority.

<ParamField path="strategy" type="Object" required>
  Content strategy
</ParamField>

<ParamField path="return" type="number">
  Priority score (0-100)
</ParamField>

```javascript theme={null}
const priority = agent.calculatePriority(strategy);
// Factors:
// - Estimated views (up to +30)
// - Competitor analysis (+10 if available)
// - Time until publish (+20 if <24h, +10 if <48h)
// - Base priority: 50
```

### getPipelineStatus()

Gets status of all items in production pipeline.

<ParamField path="return" type="Promise<Array<Object>>">
  Array of pipeline item summaries
</ParamField>

```javascript theme={null}
const status = await agent.getPipelineStatus();
// [
//   {
//     id: 'prod_123...',
//     title: 'JavaScript Tutorial',
//     status: 'ready',
//     priority: 75,
//     scheduledPublishTime: '2026-03-10T14:00:00.000Z',
//     progress: 100
//   },
//   {
//     id: 'prod_456...',
//     title: 'Python Guide',
//     status: 'processing',
//     priority: 60,
//     scheduledPublishTime: '2026-03-12T14:00:00.000Z',
//     progress: 60
//   }
// ]
```

### calculateProgress(productionData)

Calculates production completion percentage.

<ParamField path="productionData" type="Object" required>
  Production data with timeline
</ParamField>

<ParamField path="return" type="number">
  Progress percentage (0-100)
</ParamField>

```javascript theme={null}
const progress = agent.calculateProgress(productionData);
// Based on milestones:
// - scriptReady
// - thumbnailReady
// - audioGenerated
// - videoGenerated
// - captionsGenerated
// - readyForUpload
```

### getNextReadyContent()

Gets highest priority content ready for publishing.

<ParamField path="return" type="Promise<Object|null>">
  Next production item or null
</ParamField>

```javascript theme={null}
const next = await agent.getNextReadyContent();
if (next) {
  console.log('Ready to publish:', next.script.title);
  console.log('Priority:', next.priority);
}
```

## Production Pipeline Stages

<CodeGroup>
  ```javascript Stage 1: Script Processing theme={null}
  {
    milestone: 'scriptReady',
    tasks: [
      'Save original script JSON',
      'Format script for TTS',
      'Save TTS-formatted text'
    ]
  }
  ```

  ```javascript Stage 2: Thumbnail Processing theme={null}
  {
    milestone: 'thumbnailReady',
    tasks: [
      'Generate AI thumbnail (if available)',
      'Process/optimize thumbnail',
      'Save to production assets'
    ]
  }
  ```

  ```javascript Stage 3: Audio Generation theme={null}
  {
    milestone: 'audioGenerated',
    tasks: [
      'Read TTS script',
      'Generate AI narration',
      'Save MP3 audio file'
    ]
  }
  ```

  ```javascript Stage 4: Video Generation theme={null}
  {
    milestone: 'videoGenerated',
    tasks: [
      'Create visual prompts from script',
      'Generate AI images (3-5)',
      'Save visual assets'
    ]
  }
  ```

  ```javascript Stage 5: Caption Generation theme={null}
  {
    milestone: 'captionsGenerated',
    tasks: [
      'Parse script timing',
      'Generate SRT captions',
      'Save caption file'
    ]
  }
  ```

  ```javascript Stage 6: Final Assembly theme={null}
  {
    milestone: 'readyForUpload',
    tasks: [
      'Combine visual assets',
      'Sync audio narration',
      'Add text overlays',
      'Render final MP4'
    ]
  }
  ```
</CodeGroup>

## Usage Example

```javascript theme={null}
const { ProductionManagementAgent } = require('./agents/production-management-agent');

const agent = new ProductionManagementAgent(db, credentials);
await agent.initialize();

// Process complete content package
const contentData = {
  strategy: await strategyAgent.generateContentStrategy(),
  script: await scriptAgent.generateScript(strategy),
  thumbnail: await thumbnailAgent.generateThumbnail(script),
  seo: await seoAgent.optimize(script, strategy)
};

const production = await agent.processContent(contentData);

console.log('Production ID:', production.id);
console.log('Status:', production.status);
console.log('Priority:', production.priority);
console.log('Scheduled:', production.scheduledPublishTime);

// Check pipeline status
const pipeline = await agent.getPipelineStatus();
console.log('Items in pipeline:', pipeline.length);

// Get next content ready for publishing
const next = await agent.getNextReadyContent();
if (next) {
  console.log('Ready to publish:', next.script.title);
}
```

## Asset Management

The agent manages assets in organized directories:

<Accordion title="data/production">
  Production metadata and state files
</Accordion>

<Accordion title="data/assets">
  Processed thumbnails and visual assets
</Accordion>

<Accordion title="data/videos">
  Final rendered video files
</Accordion>

<Accordion title="data/audio">
  Generated audio narration files
</Accordion>

<Accordion title="data/scripts">
  Original scripts and TTS-formatted versions
</Accordion>

<Accordion title="temp/processing">
  Temporary files during processing
</Accordion>

## Best Practices

<Accordion title="Monitor Pipeline Regularly">
  Check pipeline status to identify bottlenecks and ensure smooth production flow.
</Accordion>

<Accordion title="Prioritize Time-Sensitive Content">
  Content with higher estimated views and closer publish times gets higher priority automatically.
</Accordion>

<Accordion title="Verify AI Generated Assets">
  While AI generation is automatic, review visual assets and audio narration for quality.
</Accordion>

<Accordion title="Manage Storage">
  Archive or clean up old production files periodically to manage disk space.
</Accordion>

<Accordion title="Handle Failures Gracefully">
  The agent includes fallback methods for AI service failures. Monitor logs for simulation vs. actual generation.
</Accordion>