Parse SRT file content and return structured data

Write SRT data to file format

🚀 CHUNK-BASED TRANSLATION WORKFLOW INSTRUCTIONS 🚀

📋 OVERVIEW: This tool analyzes SRT files and creates intelligent chunks for efficient translation. It returns METADATA ONLY - use get_next_chunk() and translate_srt() for actual content.

🔍 WHAT IT DOES:

• SMART INPUT: Auto-detects file paths vs SRT content

• Creates small chunks (1-3 subtitles each) optimized for AI processing

• Detects languages (Arabic, English, Spanish, French) per chunk

• Identifies speakers and conversation boundaries

• Provides translation priority rankings (high/medium/low)

• Stores chunks in memory to avoid context limits

• Creates individual TODO tasks for tracking progress

📊 WHAT IT RETURNS (SMALL RESPONSE):

• chunkCount: Total number of chunks created

• totalDuration: File duration in milliseconds

• languageDistribution: Language counts (e.g., {"ar": 45, "en": 12})

• previewChunk: Preview of first chunk metadata only

• sessionId: For retrieving chunks later

• message: Instructions for next steps

• todos: Individual tasks for each chunk

🎯 RECOMMENDED WORKFLOW:

1. Call detect_conversations with storeInMemory=true

2. Review metadata to understand file structure (SMALL RESPONSE)

3. Use get_next_chunk to process chunks one by one

4. Use translate_srt() for actual translation

5. Track progress with todo_management

💡 EXAMPLES:

File Path Input: {"content": "/path/to/file.srt", "storeInMemory": true, "createTodos": true}

SRT Content Input: {"content": "1\n00:00:02,000 --> 00:00:07,000\nHello world", "storeInMemory": true}

⚠️ IMPORTANT:

• This returns METADATA ONLY - no actual text content

• Response is SMALL to avoid context overflow

• Use get_next_chunk() to retrieve individual chunks

• Use translate_srt() for actual translation

• Store chunks in memory for large files to avoid context limits

📦 CHUNK RETRIEVAL FOR TRANSLATION WORKFLOW 📦

🎯 PURPOSE: Retrieves the next chunk from memory for sequential processing. Use this after detect_conversations with storeInMemory=true.

🔄 HOW IT WORKS:

• Automatically tracks which chunk to return next

• Returns actual chunk data with subtitle text content

• Advances to next chunk automatically

• Returns null when all chunks processed

📥 PARAMETERS:

• sessionId: Session ID from detect_conversations response

📤 RETURNS:

• chunk: Complete chunk data with subtitle text (or null if done)

• chunkIndex: Current chunk number (0-based)

• totalChunks: Total chunks available

• hasMore: Boolean indicating if more chunks exist

• message: Status message

💡 USAGE PATTERN:

1. Call detect_conversations with storeInMemory=true

2. Get sessionId from response

3. Call get_next_chunk repeatedly until hasMore=false

4. Process each chunk for translation

5. Use translate_srt() on individual chunks

📋 EXAMPLE: {"sessionId": "srt-session-123456789"}

⚠️ NOTE:

• Each call advances to the next chunk automatically

• Store sessionId from detect_conversations response

• Use this for chunk-by-chunk processing of large files

🌍 SRT TRANSLATION HELPER TOOL 🌍

🚨 CRITICAL: THIS IS A HELPER TOOL ONLY - AI DOES THE TRANSLATION! 🚨

🎯 PURPOSE: This tool helps prepare SRT content for AI translation but DOES NOT translate text itself. The AI assistant must perform the actual translation work.

📝 WHAT IT DOES:

• Parses SRT content and extracts subtitle text for AI translation

• Preserves timing and formatting structure

• Returns structured data for AI to translate

• Provides context and metadata for better translation

❌ WHAT IT DOES NOT DO:

• ❌ Does NOT translate text automatically

• ❌ Does NOT return translated content

• ❌ Does NOT perform any AI translation

✅ WHAT IT RETURNS:

• Structured SRT data with original text

• Timing and formatting information

• Translation context and metadata

• Ready-to-translate format for AI

🔄 RECOMMENDED WORKFLOW:

1. Use detect_conversations to analyze file structure

2. Use get_next_chunk to get individual chunks

3. Use translate_srt to prepare chunk for AI translation

4. AI assistant translates the text content

5. AI assistant combines results into final SRT file

💡 USAGE PATTERNS:

Prepare Full File for Translation: {"content": "full SRT content", "targetLanguage": "es", "sourceLanguage": "en"}

Prepare Individual Chunk for Translation: {"content": "chunk SRT content", "targetLanguage": "es", "sourceLanguage": "en"}

⚠️ CRITICAL INSTRUCTIONS:

• This tool ONLY prepares content for AI translation

• AI assistant must do the actual text translation

• Use this to get structured data, then translate with AI

• Return format is ready for AI processing

Manage tasks for SRT processing workflows.

WHAT IT DOES:

• Create, update, and track tasks during SRT processing

• Monitor progress across different processing stages

• Manage task priorities and dependencies

ACTIONS:

• create: Create a new task

• update: Update task status

• complete: Mark task as completed

• list: List all tasks

• get_status: Get overall task status

TASK TYPES:

• srt_parse: Parse and validate SRT file

• conversation_detect: Detect conversation chunks

• chunk_optimize: Optimize chunks for AI processing

• ai_process: Process with AI model

• translate: Translate content

• quality_check: Quality assurance

• output_generate: Generate final output

EXAMPLE USAGE:

1. Create task: {"action": "create", "taskType": "srt_parse", "title": "Parse SRT file", "priority": "high"}

2. Update status: {"action": "update", "taskId": "task-123", "status": "completed"}

3. List tasks: {"action": "list"}

4. Get status: {"action": "get_status"}