@vibeframe/cli 0.27.0

package/src/agent/tools/ai-editing.ts

@@ -0,0 +1,845 @@
+/**
+ * @module ai-editing
+ * @description Agent tools for post-production editing (text overlay, review,
+ * silence cut, jump cut, captions, noise reduction, fade, thumbnail,
+ * SRT translation). FFmpeg-based and AI-assisted editing tools for agent use.
+ * Most tools work without API keys (FFmpeg-only), some use Gemini or OpenAI.
+ *
+ * ## Tools: edit_text_overlay, analyze_review, edit_silence_cut, edit_jump_cut, edit_caption,
+ *          edit_noise_reduce, edit_fade, generate_thumbnail, edit_translate_srt
+ * ## Dependencies: FFmpeg, Gemini (optional), OpenAI/Whisper (optional)
+ * @see MODELS.md for the Single Source of Truth (SSOT) on supported providers/models
+ */
+
+import { resolve } from "node:path";
+import type { ToolRegistry, ToolHandler } from "./index.js";
+import type { ToolDefinition, ToolResult } from "../types.js";
+import {
+  executeTextOverlay,
+  executeSilenceCut,
+  executeJumpCut,
+  executeCaption,
+  executeNoiseReduce,
+  executeFade,
+  executeTranslateSrt,
+  type TextOverlayStyle,
+  type CaptionStyle,
+} from "../../commands/ai-edit.js";
+import { executeReview } from "../../commands/ai-review.js";
+import { executeThumbnailBestFrame } from "../../commands/ai-image.js";
+import { sanitizeAIResult } from "../../commands/sanitize.js";
+
+// ============================================================================
+// Tool Definitions
+// ============================================================================
+
+const textOverlayDef: ToolDefinition = {
+  name: "edit_text_overlay",
+  description: "Apply text overlays to a video using FFmpeg drawtext. Supports 4 style presets: lower-third, center-bold, subtitle, minimal. Auto-detects font and scales based on video resolution.",
+  parameters: {
+    type: "object",
+    properties: {
+      videoPath: {
+        type: "string",
+        description: "Path to input video file",
+      },
+      texts: {
+        type: "array",
+        items: { type: "string", description: "Text line to overlay" },
+        description: "Text lines to overlay (multiple lines stack vertically)",
+      },
+      outputPath: {
+        type: "string",
+        description: "Output video file path",
+      },
+      style: {
+        type: "string",
+        description: "Overlay style preset",
+        enum: ["lower-third", "center-bold", "subtitle", "minimal"],
+      },
+      fontSize: {
+        type: "number",
+        description: "Font size in pixels (auto-calculated if omitted)",
+      },
+      fontColor: {
+        type: "string",
+        description: "Font color (default: white)",
+      },
+      fadeDuration: {
+        type: "number",
+        description: "Fade in/out duration in seconds (default: 0.3)",
+      },
+      startTime: {
+        type: "number",
+        description: "Start time for overlay in seconds (default: 0)",
+      },
+      endTime: {
+        type: "number",
+        description: "End time for overlay in seconds (default: video duration)",
+      },
+    },
+    required: ["videoPath", "texts", "outputPath"],
+  },
+};
+
+const reviewDef: ToolDefinition = {
+  name: "analyze_review",
+  description: "Review video quality using Gemini AI. Analyzes pacing, color, text readability, audio-visual sync, and composition. Can auto-apply fixable corrections (color grading). Returns structured feedback with scores and recommendations.",
+  parameters: {
+    type: "object",
+    properties: {
+      videoPath: {
+        type: "string",
+        description: "Path to video file to review",
+      },
+      storyboardPath: {
+        type: "string",
+        description: "Optional path to storyboard JSON for context",
+      },
+      autoApply: {
+        type: "boolean",
+        description: "Automatically apply fixable corrections (default: false)",
+      },
+      verify: {
+        type: "boolean",
+        description: "Run verification pass after applying fixes (default: false)",
+      },
+      model: {
+        type: "string",
+        description: "Gemini model: flash (default), flash-2.5, pro",
+        enum: ["flash", "flash-2.5", "pro"],
+      },
+      outputPath: {
+        type: "string",
+        description: "Output path for corrected video (when autoApply is true)",
+      },
+    },
+    required: ["videoPath"],
+  },
+};
+
+const silenceCutDef: ToolDefinition = {
+  name: "edit_silence_cut",
+  description: "Remove silent segments from a video. Default uses FFmpeg silencedetect (free, no API key). Use useGemini=true for smart context-aware detection via Gemini Video Understanding — distinguishes dead air from intentional pauses using visual+audio analysis.",
+  parameters: {
+    type: "object",
+    properties: {
+      videoPath: {
+        type: "string",
+        description: "Path to input video file",
+      },
+      outputPath: {
+        type: "string",
+        description: "Output file path (default: <name>-cut.<ext>)",
+      },
+      noiseThreshold: {
+        type: "number",
+        description: "Silence threshold in dB (default: -30). Lower = more sensitive. FFmpeg mode only.",
+      },
+      minDuration: {
+        type: "number",
+        description: "Minimum silence duration in seconds to cut (default: 0.5)",
+      },
+      padding: {
+        type: "number",
+        description: "Padding around non-silent segments in seconds (default: 0.1)",
+      },
+      analyzeOnly: {
+        type: "boolean",
+        description: "Only detect silence without cutting (default: false)",
+      },
+      useGemini: {
+        type: "boolean",
+        description: "Use Gemini Video Understanding for context-aware silence detection (default: false). Requires GOOGLE_API_KEY.",
+      },
+      model: {
+        type: "string",
+        description: "Gemini model to use (default: flash). Options: flash, flash-2.5, pro",
+      },
+      lowRes: {
+        type: "boolean",
+        description: "Low resolution mode for longer videos (Gemini only)",
+      },
+    },
+    required: ["videoPath"],
+  },
+};
+
+const jumpCutDef: ToolDefinition = {
+  name: "edit_jump_cut",
+  description: "Remove filler words (um, uh, like, etc.) from video using Whisper word-level timestamps + FFmpeg concat. Requires OpenAI API key. Detects filler words, cuts them out, and stitches remaining segments with stream copy (fast, no re-encode).",
+  parameters: {
+    type: "object",
+    properties: {
+      videoPath: {
+        type: "string",
+        description: "Path to input video file",
+      },
+      outputPath: {
+        type: "string",
+        description: "Output file path (default: <name>-jumpcut.<ext>)",
+      },
+      fillers: {
+        type: "array",
+        items: { type: "string", description: "A filler word to detect" },
+        description: "Custom filler words to detect (default: um, uh, like, you know, etc.)",
+      },
+      padding: {
+        type: "number",
+        description: "Padding around cuts in seconds (default: 0.05)",
+      },
+      language: {
+        type: "string",
+        description: "Language code for transcription (e.g., en, ko)",
+      },
+      analyzeOnly: {
+        type: "boolean",
+        description: "Only detect fillers without cutting (default: false)",
+      },
+    },
+    required: ["videoPath"],
+  },
+};
+
+const captionDef: ToolDefinition = {
+  name: "edit_caption",
+  description: "Transcribe video with Whisper and burn styled captions using FFmpeg. Requires OpenAI API key. 4 style presets: minimal, bold (default), outline, karaoke. Auto-sizes font based on video resolution.",
+  parameters: {
+    type: "object",
+    properties: {
+      videoPath: {
+        type: "string",
+        description: "Path to input video file",
+      },
+      outputPath: {
+        type: "string",
+        description: "Output file path (default: <name>-captioned.<ext>)",
+      },
+      style: {
+        type: "string",
+        description: "Caption style preset",
+        enum: ["minimal", "bold", "outline", "karaoke"],
+      },
+      fontSize: {
+        type: "number",
+        description: "Font size in pixels (auto-calculated based on resolution if omitted)",
+      },
+      fontColor: {
+        type: "string",
+        description: "Font color (default: white)",
+      },
+      language: {
+        type: "string",
+        description: "Language code for transcription (e.g., en, ko)",
+      },
+      position: {
+        type: "string",
+        description: "Caption position",
+        enum: ["top", "center", "bottom"],
+      },
+    },
+    required: ["videoPath"],
+  },
+};
+
+const noiseReduceDef: ToolDefinition = {
+  name: "edit_noise_reduce",
+  description: "Remove background noise from audio/video using FFmpeg afftdn filter. No API key needed. Three strength presets: low, medium (default), high. High adds bandpass filtering.",
+  parameters: {
+    type: "object",
+    properties: {
+      inputPath: {
+        type: "string",
+        description: "Path to input audio or video file",
+      },
+      outputPath: {
+        type: "string",
+        description: "Output file path (default: <name>-denoised.<ext>)",
+      },
+      strength: {
+        type: "string",
+        description: "Noise reduction strength",
+        enum: ["low", "medium", "high"],
+      },
+      noiseFloor: {
+        type: "number",
+        description: "Custom noise floor in dB (overrides strength preset)",
+      },
+    },
+    required: ["inputPath"],
+  },
+};
+
+const fadeDef: ToolDefinition = {
+  name: "edit_fade",
+  description: "Apply fade in/out effects to video using FFmpeg. No API key needed. Supports video-only, audio-only, or both. Configurable fade durations.",
+  parameters: {
+    type: "object",
+    properties: {
+      videoPath: {
+        type: "string",
+        description: "Path to input video file",
+      },
+      outputPath: {
+        type: "string",
+        description: "Output file path (default: <name>-faded.<ext>)",
+      },
+      fadeIn: {
+        type: "number",
+        description: "Fade-in duration in seconds (default: 1)",
+      },
+      fadeOut: {
+        type: "number",
+        description: "Fade-out duration in seconds (default: 1)",
+      },
+      audioOnly: {
+        type: "boolean",
+        description: "Apply fade to audio only (default: false)",
+      },
+      videoOnly: {
+        type: "boolean",
+        description: "Apply fade to video only (default: false)",
+      },
+    },
+    required: ["videoPath"],
+  },
+};
+
+const thumbnailBestFrameDef: ToolDefinition = {
+  name: "generate_thumbnail",
+  description: "Extract the best thumbnail frame from a video using Gemini AI analysis + FFmpeg frame extraction. Requires GOOGLE_API_KEY. Finds visually striking, well-composed frames.",
+  parameters: {
+    type: "object",
+    properties: {
+      videoPath: {
+        type: "string",
+        description: "Path to input video file",
+      },
+      outputPath: {
+        type: "string",
+        description: "Output image path (default: <name>-thumbnail.png)",
+      },
+      prompt: {
+        type: "string",
+        description: "Custom prompt for frame selection analysis",
+      },
+      model: {
+        type: "string",
+        description: "Gemini model to use",
+        enum: ["flash", "flash-2.5", "pro"],
+      },
+    },
+    required: ["videoPath"],
+  },
+};
+
+const translateSrtDef: ToolDefinition = {
+  name: "edit_translate_srt",
+  description: "Translate SRT subtitle file to another language using Claude or OpenAI. Preserves timestamps. Batches segments for efficiency.",
+  parameters: {
+    type: "object",
+    properties: {
+      srtPath: {
+        type: "string",
+        description: "Path to input SRT file",
+      },
+      outputPath: {
+        type: "string",
+        description: "Output file path (default: <name>-<target>.srt)",
+      },
+      targetLanguage: {
+        type: "string",
+        description: "Target language (e.g., ko, es, fr, ja, zh)",
+      },
+      provider: {
+        type: "string",
+        description: "Translation provider",
+        enum: ["claude", "openai"],
+      },
+      sourceLanguage: {
+        type: "string",
+        description: "Source language (auto-detected if omitted)",
+      },
+    },
+    required: ["srtPath", "targetLanguage"],
+  },
+};
+
+// ============================================================================
+// Tool Handlers
+// ============================================================================
+
+const textOverlayHandler: ToolHandler = async (args) => {
+  const { videoPath, texts, outputPath, style, fontSize, fontColor, fadeDuration, startTime, endTime } = args as {
+    videoPath: string;
+    texts: string[];
+    outputPath: string;
+    style?: TextOverlayStyle;
+    fontSize?: number;
+    fontColor?: string;
+    fadeDuration?: number;
+    startTime?: number;
+    endTime?: number;
+  };
+
+  if (!videoPath || !texts || texts.length === 0 || !outputPath) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: "videoPath, texts (non-empty array), and outputPath are required",
+    };
+  }
+
+  const result = await executeTextOverlay({
+    videoPath,
+    texts,
+    outputPath,
+    style,
+    fontSize,
+    fontColor,
+    fadeDuration,
+    startTime,
+    endTime,
+  });
+
+  if (!result.success) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: result.error || "Text overlay failed",
+    };
+  }
+
+  return {
+    toolCallId: "",
+    success: true,
+    output: `Text overlay applied: ${result.outputPath}`,
+  };
+};
+
+const reviewHandler: ToolHandler = async (args) => {
+  const { videoPath, storyboardPath, autoApply, verify, model, outputPath } = args as {
+    videoPath: string;
+    storyboardPath?: string;
+    autoApply?: boolean;
+    verify?: boolean;
+    model?: "flash" | "flash-2.5" | "pro";
+    outputPath?: string;
+  };
+
+  if (!videoPath) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: "videoPath is required",
+    };
+  }
+
+  const result = await executeReview({
+    videoPath,
+    storyboardPath,
+    autoApply,
+    verify,
+    model,
+    outputPath,
+  });
+
+  if (!result.success) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: result.error || "Video review failed",
+    };
+  }
+
+  const fb = sanitizeAIResult(result.feedback!);
+  let output = `Video Review: ${fb.overallScore}/10\n`;
+  output += `Pacing: ${fb.categories.pacing.score}/10, Color: ${fb.categories.color.score}/10, `;
+  output += `Text: ${fb.categories.textReadability.score}/10, AV Sync: ${fb.categories.audioVisualSync.score}/10, `;
+  output += `Composition: ${fb.categories.composition.score}/10\n`;
+
+  if (result.appliedFixes && result.appliedFixes.length > 0) {
+    output += `Applied fixes: ${sanitizeAIResult(result.appliedFixes).join("; ")}\n`;
+  }
+  if (result.verificationScore !== undefined) {
+    output += `Verification score: ${result.verificationScore}/10\n`;
+  }
+  if (fb.recommendations.length > 0) {
+    output += `Recommendations: ${fb.recommendations.join("; ")}`;
+  }
+
+  return {
+    toolCallId: "",
+    success: true,
+    output,
+  };
+};
+
+const silenceCutHandler: ToolHandler = async (args, context): Promise<ToolResult> => {
+  const videoPath = resolve(context.workingDirectory, args.videoPath as string);
+  const ext = videoPath.split(".").pop() || "mp4";
+  const name = videoPath.replace(/\.[^.]+$/, "");
+  const outputPath = args.outputPath
+    ? resolve(context.workingDirectory, args.outputPath as string)
+    : `${name}-cut.${ext}`;
+
+  try {
+    const result = await executeSilenceCut({
+      videoPath,
+      outputPath,
+      noiseThreshold: args.noiseThreshold as number | undefined,
+      minDuration: args.minDuration as number | undefined,
+      padding: args.padding as number | undefined,
+      analyzeOnly: args.analyzeOnly as boolean | undefined,
+      useGemini: args.useGemini as boolean | undefined,
+      model: args.model as string | undefined,
+      lowRes: args.lowRes as boolean | undefined,
+    });
+
+    if (!result.success) {
+      return {
+        toolCallId: "",
+        success: false,
+        output: "",
+        error: result.error || "Silence cut failed",
+      };
+    }
+
+    const lines: string[] = [];
+    lines.push(`Detection method: ${result.method === "gemini" ? "Gemini Video Understanding" : "FFmpeg silencedetect"}`);
+    lines.push(`Total duration: ${result.totalDuration!.toFixed(1)}s`);
+    lines.push(`Silent periods: ${result.silentPeriods!.length}`);
+    lines.push(`Silent duration: ${result.silentDuration!.toFixed(1)}s`);
+    lines.push(`Non-silent duration: ${(result.totalDuration! - result.silentDuration!).toFixed(1)}s`);
+
+    if (result.outputPath) {
+      lines.push(`Output: ${result.outputPath}`);
+    }
+
+    return {
+      toolCallId: "",
+      success: true,
+      output: lines.join("\n"),
+    };
+  } catch (error) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: `Silence cut failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+};
+
+const jumpCutHandler: ToolHandler = async (args, context): Promise<ToolResult> => {
+  const videoPath = resolve(context.workingDirectory, args.videoPath as string);
+  const ext = videoPath.split(".").pop() || "mp4";
+  const name = videoPath.replace(/\.[^.]+$/, "");
+  const outputPath = args.outputPath
+    ? resolve(context.workingDirectory, args.outputPath as string)
+    : `${name}-jumpcut.${ext}`;
+
+  try {
+    const result = await executeJumpCut({
+      videoPath,
+      outputPath,
+      fillers: args.fillers as string[] | undefined,
+      padding: args.padding as number | undefined,
+      language: args.language as string | undefined,
+      analyzeOnly: args.analyzeOnly as boolean | undefined,
+    });
+
+    if (!result.success) {
+      return {
+        toolCallId: "",
+        success: false,
+        output: "",
+        error: result.error || "Jump cut failed",
+      };
+    }
+
+    const lines: string[] = [];
+    lines.push(`Total duration: ${result.totalDuration!.toFixed(1)}s`);
+    lines.push(`Filler words found: ${result.fillerCount}`);
+    lines.push(`Filler duration: ${result.fillerDuration!.toFixed(1)}s`);
+    lines.push(`Clean duration: ${(result.totalDuration! - result.fillerDuration!).toFixed(1)}s`);
+
+    if (result.fillers && result.fillers.length > 0) {
+      lines.push("");
+      lines.push("Detected fillers:");
+      for (const filler of result.fillers) {
+        lines.push(`  "${filler.word}" at ${filler.start.toFixed(2)}s - ${filler.end.toFixed(2)}s`);
+      }
+    }
+
+    if (result.outputPath) {
+      lines.push(`Output: ${result.outputPath}`);
+    }
+
+    return {
+      toolCallId: "",
+      success: true,
+      output: lines.join("\n"),
+    };
+  } catch (error) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: `Jump cut failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+};
+
+const captionHandler: ToolHandler = async (args, context): Promise<ToolResult> => {
+  const videoPath = resolve(context.workingDirectory, args.videoPath as string);
+  const ext = videoPath.split(".").pop() || "mp4";
+  const name = videoPath.replace(/\.[^.]+$/, "");
+  const outputPath = args.outputPath
+    ? resolve(context.workingDirectory, args.outputPath as string)
+    : `${name}-captioned.${ext}`;
+
+  try {
+    const result = await executeCaption({
+      videoPath,
+      outputPath,
+      style: args.style as CaptionStyle | undefined,
+      fontSize: args.fontSize as number | undefined,
+      fontColor: args.fontColor as string | undefined,
+      language: args.language as string | undefined,
+      position: args.position as "top" | "center" | "bottom" | undefined,
+    });
+
+    if (!result.success) {
+      return {
+        toolCallId: "",
+        success: false,
+        output: "",
+        error: result.error || "Caption failed",
+      };
+    }
+
+    const lines: string[] = [];
+    lines.push(`Captions applied: ${result.outputPath}`);
+    lines.push(`Segments transcribed: ${result.segmentCount}`);
+    if (result.srtPath) {
+      lines.push(`SRT file: ${result.srtPath}`);
+    }
+
+    return {
+      toolCallId: "",
+      success: true,
+      output: lines.join("\n"),
+    };
+  } catch (error) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: `Caption failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+};
+
+const noiseReduceHandler: ToolHandler = async (args, context): Promise<ToolResult> => {
+  const inputPath = resolve(context.workingDirectory, args.inputPath as string);
+  const ext = inputPath.split(".").pop() || "mp4";
+  const name = inputPath.replace(/\.[^.]+$/, "");
+  const outputPath = args.outputPath
+    ? resolve(context.workingDirectory, args.outputPath as string)
+    : `${name}-denoised.${ext}`;
+
+  try {
+    const result = await executeNoiseReduce({
+      inputPath,
+      outputPath,
+      strength: args.strength as "low" | "medium" | "high" | undefined,
+      noiseFloor: args.noiseFloor as number | undefined,
+    });
+
+    if (!result.success) {
+      return {
+        toolCallId: "",
+        success: false,
+        output: "",
+        error: result.error || "Noise reduction failed",
+      };
+    }
+
+    const lines: string[] = [];
+    lines.push(`Noise reduction applied: ${result.outputPath}`);
+    lines.push(`Input duration: ${result.inputDuration!.toFixed(1)}s`);
+
+    return {
+      toolCallId: "",
+      success: true,
+      output: lines.join("\n"),
+    };
+  } catch (error) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: `Noise reduction failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+};
+
+const fadeHandler: ToolHandler = async (args, context): Promise<ToolResult> => {
+  const videoPath = resolve(context.workingDirectory, args.videoPath as string);
+  const ext = videoPath.split(".").pop() || "mp4";
+  const name = videoPath.replace(/\.[^.]+$/, "");
+  const outputPath = args.outputPath
+    ? resolve(context.workingDirectory, args.outputPath as string)
+    : `${name}-faded.${ext}`;
+
+  try {
+    const result = await executeFade({
+      videoPath,
+      outputPath,
+      fadeIn: args.fadeIn as number | undefined,
+      fadeOut: args.fadeOut as number | undefined,
+      audioOnly: args.audioOnly as boolean | undefined,
+      videoOnly: args.videoOnly as boolean | undefined,
+    });
+
+    if (!result.success) {
+      return {
+        toolCallId: "",
+        success: false,
+        output: "",
+        error: result.error || "Fade failed",
+      };
+    }
+
+    const lines: string[] = [];
+    lines.push(`Fade effects applied: ${result.outputPath}`);
+    lines.push(`Total duration: ${result.totalDuration!.toFixed(1)}s`);
+    if (result.fadeInApplied) lines.push(`Fade-in applied`);
+    if (result.fadeOutApplied) lines.push(`Fade-out applied`);
+
+    return {
+      toolCallId: "",
+      success: true,
+      output: lines.join("\n"),
+    };
+  } catch (error) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: `Fade failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+};
+
+const thumbnailBestFrameHandler: ToolHandler = async (args, context): Promise<ToolResult> => {
+  const videoPath = resolve(context.workingDirectory, args.videoPath as string);
+  const name = videoPath.replace(/\.[^.]+$/, "");
+  const outputPath = args.outputPath
+    ? resolve(context.workingDirectory, args.outputPath as string)
+    : `${name}-thumbnail.png`;
+
+  try {
+    const result = await executeThumbnailBestFrame({
+      videoPath,
+      outputPath,
+      prompt: args.prompt as string | undefined,
+      model: args.model as string | undefined,
+    });
+
+    if (!result.success) {
+      return {
+        toolCallId: "",
+        success: false,
+        output: "",
+        error: result.error || "Best frame extraction failed",
+      };
+    }
+
+    const lines: string[] = [];
+    lines.push(`Best frame extracted: ${result.outputPath}`);
+    lines.push(`Timestamp: ${result.timestamp!.toFixed(2)}s`);
+    if (result.reason) lines.push(`Reason: ${sanitizeAIResult(result.reason)}`);
+
+    return {
+      toolCallId: "",
+      success: true,
+      output: lines.join("\n"),
+    };
+  } catch (error) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: `Best frame extraction failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+};
+
+const translateSrtHandler: ToolHandler = async (args, context): Promise<ToolResult> => {
+  const srtPath = resolve(context.workingDirectory, args.srtPath as string);
+  const target = args.targetLanguage as string;
+  const ext = srtPath.split(".").pop() || "srt";
+  const name = srtPath.replace(/\.[^.]+$/, "");
+  const outputPath = args.outputPath
+    ? resolve(context.workingDirectory, args.outputPath as string)
+    : `${name}-${target}.${ext}`;
+
+  try {
+    const result = await executeTranslateSrt({
+      srtPath,
+      outputPath,
+      targetLanguage: target,
+      provider: args.provider as "claude" | "openai" | undefined,
+      sourceLanguage: args.sourceLanguage as string | undefined,
+    });
+
+    if (!result.success) {
+      return {
+        toolCallId: "",
+        success: false,
+        output: "",
+        error: result.error || "Translation failed",
+      };
+    }
+
+    const lines: string[] = [];
+    lines.push(`Translation complete: ${result.outputPath}`);
+    lines.push(`Segments translated: ${result.segmentCount}`);
+    lines.push(`Target language: ${result.targetLanguage}`);
+
+    return {
+      toolCallId: "",
+      success: true,
+      output: lines.join("\n"),
+    };
+  } catch (error) {
+    return {
+      toolCallId: "",
+      success: false,
+      output: "",
+      error: `Translation failed: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+};
+
+// ============================================================================
+// Registration
+// ============================================================================
+
+export function registerEditingTools(registry: ToolRegistry): void {
+  registry.register(textOverlayDef, textOverlayHandler);
+  registry.register(reviewDef, reviewHandler);
+  registry.register(silenceCutDef, silenceCutHandler);
+  registry.register(jumpCutDef, jumpCutHandler);
+  registry.register(captionDef, captionHandler);
+  registry.register(noiseReduceDef, noiseReduceHandler);
+  registry.register(fadeDef, fadeHandler);
+  registry.register(thumbnailBestFrameDef, thumbnailBestFrameHandler);
+  registry.register(translateSrtDef, translateSrtHandler);
+}