@vibeframe/cli 0.55.0 → 0.55.2

package/dist/commands/ai-edit.js

@@ -1,1060 +0,0 @@
-/**
- * @module ai-edit
- *
- * Video/audio editing execute functions and supporting types.
- *
- * CLI commands: silence-cut, jump-cut, caption, noise-reduce, fade,
- *               translate-srt, text-overlay
- *
- * Execute functions (also used by agent tools via ai.ts re-exports):
- *   executeSilenceCut, executeJumpCut, executeCaption, executeNoiseReduce,
- *   executeFade, executeTranslateSrt, applyTextOverlays, executeTextOverlay
- *
- * CLI command registrations live in ai-edit-cli.ts (registerEditCommands).
- * Extracted from ai.ts as part of modularisation.
- *
- * @dependencies FFmpeg, Whisper (OpenAI), Gemini (Google), Claude/OpenAI (translation)
- */
-import { resolve, dirname, basename, extname, join } from 'node:path';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { GeminiProvider, WhisperProvider, } from '@vibeframe/ai-providers';
-import { getApiKey } from '../utils/api-key.js';
-import { getVideoDuration } from '../utils/audio.js';
-import { formatSRT, parseSRT } from '../utils/subtitle.js';
-import { execSafe, commandExists } from '../utils/exec-safe.js';
-/**
- * Detect silent periods in a media file using FFmpeg silencedetect
- */
-async function detectSilencePeriods(videoPath, noiseThreshold, minDuration) {
-    // Get total duration
-    const totalDuration = await getVideoDuration(videoPath);
-    // Run silence detection
-    const { stdout, stderr } = await execSafe("ffmpeg", [
-        "-i", videoPath,
-        "-af", `silencedetect=noise=${noiseThreshold}dB:d=${minDuration}`,
-        "-f", "null", "-",
-    ], { maxBuffer: 50 * 1024 * 1024 }).catch((err) => {
-        // ffmpeg writes filter output to stderr and exits non-zero with -f null
-        if (err.stdout !== undefined || err.stderr !== undefined) {
-            return { stdout: err.stdout || "", stderr: err.stderr || "" };
-        }
-        throw err;
-    });
-    const silenceOutput = stdout + stderr;
-    const periods = [];
-    const startRegex = /silence_start: (\d+\.?\d*)/g;
-    const endRegex = /silence_end: (\d+\.?\d*) \| silence_duration: (\d+\.?\d*)/g;
-    const starts = [];
-    let match;
-    while ((match = startRegex.exec(silenceOutput)) !== null) {
-        starts.push(parseFloat(match[1]));
-    }
-    let i = 0;
-    while ((match = endRegex.exec(silenceOutput)) !== null) {
-        const end = parseFloat(match[1]);
-        const duration = parseFloat(match[2]);
-        const start = i < starts.length ? starts[i] : end - duration;
-        periods.push({ start, end, duration });
-        i++;
-    }
-    return { periods, totalDuration };
-}
-/**
- * Detect silent/dead segments using Gemini Video Understanding (multimodal analysis)
- */
-async function detectSilencePeriodsWithGemini(videoPath, minDuration, options) {
-    const totalDuration = await getVideoDuration(videoPath);
-    const geminiApiKey = options.apiKey || await getApiKey("GOOGLE_API_KEY", "Google");
-    if (!geminiApiKey) {
-        throw new Error("Google API key required for Gemini Video Understanding. Run 'vibe setup' or set GOOGLE_API_KEY in .env");
-    }
-    const gemini = new GeminiProvider();
-    await gemini.initialize({ apiKey: geminiApiKey });
-    const videoBuffer = await readFile(videoPath);
-    // Map model shorthand to full model ID
-    const modelMap = {
-        flash: "gemini-3-flash-preview",
-        "flash-2.5": "gemini-2.5-flash",
-        pro: "gemini-2.5-pro",
-    };
-    const modelId = options.model ? (modelMap[options.model] || modelMap.flash) : undefined;
-    const prompt = `Analyze this video and identify all silent or dead segments where there is NO meaningful content.
-
-Detect these as silent/dead segments:
-- Complete silence (no audio at all)
-- Dead air / ambient noise with no speech or meaningful sound
-- Long pauses between speakers or topics (${minDuration}+ seconds)
-- Technical silence (e.g., blank screen with no audio)
-- Sections with only background noise and no intentional content
-
-Do NOT mark these as silent (keep them):
-- Intentional dramatic pauses (short, part of storytelling)
-- Music-only sections (background music, intros, outros)
-- Natural breathing pauses within sentences (under ${minDuration} seconds)
-- Applause, laughter, or audience reactions
-- Sound effects or ambient audio that is part of the content
-
-Only include segments that are at least ${minDuration} seconds long.
-The video total duration is ${totalDuration.toFixed(1)} seconds.
-
-IMPORTANT: Respond ONLY with valid JSON in this exact format:
-{
-  "silentSegments": [
-    {
-      "start": 5.2,
-      "end": 8.7,
-      "reason": "Dead air between speakers"
-    }
-  ]
-}
-
-If there are no silent segments, return: { "silentSegments": [] }`;
-    const result = await gemini.analyzeVideo(videoBuffer, prompt, {
-        fps: 1,
-        lowResolution: options.lowRes,
-        ...(modelId ? { model: modelId } : {}),
-    });
-    if (!result.success || !result.response) {
-        throw new Error(`Gemini analysis failed: ${result.error || "No response"}`);
-    }
-    // Parse JSON from Gemini response
-    let jsonStr = result.response;
-    const jsonMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
-    if (jsonMatch)
-        jsonStr = jsonMatch[1];
-    const objectMatch = jsonStr.match(/\{[\s\S]*"silentSegments"[\s\S]*\}/);
-    if (objectMatch)
-        jsonStr = objectMatch[0];
-    const parsed = JSON.parse(jsonStr);
-    const periods = [];
-    if (parsed.silentSegments && Array.isArray(parsed.silentSegments)) {
-        for (const seg of parsed.silentSegments) {
-            const rawStart = Number(seg.start);
-            const rawEnd = Number(seg.end);
-            if (isNaN(rawStart) || isNaN(rawEnd))
-                continue;
-            // Clamp to video duration, then validate
-            const start = Math.max(0, rawStart);
-            const end = Math.min(rawEnd, totalDuration);
-            const duration = end - start;
-            if (duration >= minDuration) {
-                periods.push({ start, end, duration });
-            }
-        }
-    }
-    // Sort by start time
-    periods.sort((a, b) => a.start - b.start);
-    return { periods, totalDuration };
-}
-/**
- * Remove silent segments from a video using FFmpeg or Gemini detection.
- *
- * Detects silence via FFmpeg silencedetect (default) or Gemini multimodal
- * analysis, then trims and concatenates the non-silent segments.
- *
- * @param options - Silence cut configuration
- * @returns Result with output path and detected silent periods
- */
-export async function executeSilenceCut(options) {
-    const { videoPath, outputPath, noiseThreshold = -30, minDuration = 0.5, padding = 0.1, analyzeOnly = false, useGemini = false, } = options;
-    if (!existsSync(videoPath)) {
-        return { success: false, error: `Video not found: ${videoPath}` };
-    }
-    if (!commandExists("ffmpeg")) {
-        return { success: false, error: "FFmpeg not found. Please install FFmpeg." };
-    }
-    const method = useGemini ? "gemini" : "ffmpeg";
-    try {
-        const { periods, totalDuration } = useGemini
-            ? await detectSilencePeriodsWithGemini(videoPath, minDuration, {
-                model: options.model,
-                lowRes: options.lowRes,
-                apiKey: options.apiKey,
-            })
-            : await detectSilencePeriods(videoPath, noiseThreshold, minDuration);
-        const silentDuration = periods.reduce((sum, p) => sum + p.duration, 0);
-        if (analyzeOnly || periods.length === 0) {
-            return {
-                success: true,
-                totalDuration,
-                silentPeriods: periods,
-                silentDuration,
-                method,
-            };
-        }
-        // Compute non-silent segments with padding
-        const segments = [];
-        let cursor = 0;
-        for (const period of periods) {
-            const segEnd = Math.min(period.start + padding, totalDuration);
-            if (segEnd > cursor) {
-                segments.push({ start: Math.max(0, cursor - padding), end: segEnd });
-            }
-            cursor = period.end;
-        }
-        // Add final segment after last silence
-        if (cursor < totalDuration) {
-            segments.push({ start: Math.max(0, cursor - padding), end: totalDuration });
-        }
-        if (segments.length === 0) {
-            return { success: false, error: "No non-silent segments found" };
-        }
-        // Build filter_complex with trim+concat per segment.
-        // aselect is broken on FFmpeg 8.x (audio duration unchanged), so we use
-        // atrim/trim per segment and concat them all.
-        const vParts = [];
-        const aParts = [];
-        const concatInputs = [];
-        for (let i = 0; i < segments.length; i++) {
-            const s = segments[i].start.toFixed(4);
-            const e = segments[i].end.toFixed(4);
-            vParts.push(`[0:v]trim=${s}:${e},setpts=PTS-STARTPTS[v${i}]`);
-            aParts.push(`[0:a]atrim=${s}:${e},asetpts=PTS-STARTPTS[a${i}]`);
-            concatInputs.push(`[v${i}][a${i}]`);
-        }
-        const filterComplex = [
-            ...vParts,
-            ...aParts,
-            `${concatInputs.join("")}concat=n=${segments.length}:v=1:a=1[outv][outa]`,
-        ].join(";");
-        await execSafe("ffmpeg", [
-            "-i", videoPath,
-            "-filter_complex", filterComplex,
-            "-map", "[outv]", "-map", "[outa]",
-            "-c:v", "libx264", "-preset", "fast", "-crf", "18",
-            "-c:a", "aac", "-b:a", "192k",
-            outputPath, "-y",
-        ], { timeout: 600000, maxBuffer: 50 * 1024 * 1024 });
-        return {
-            success: true,
-            outputPath,
-            totalDuration,
-            silentPeriods: periods,
-            silentDuration,
-            method,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Silence cut failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-/** Default set of filler words detected by jump-cut. */
-export const DEFAULT_FILLER_WORDS = [
-    "um", "uh", "uh-huh", "hmm", "like", "you know", "so",
-    "basically", "literally", "right", "okay", "well", "i mean", "actually",
-];
-/**
- * Transcribe audio with word-level timestamps using Whisper API directly.
- * Uses timestamp_granularities[]=word for filler detection.
- */
-export async function transcribeWithWords(audioPath, apiKey, language) {
-    const audioBuffer = await readFile(audioPath);
-    const audioBlob = new Blob([audioBuffer]);
-    const formData = new FormData();
-    formData.append("file", audioBlob, "audio.wav");
-    formData.append("model", "whisper-1");
-    formData.append("response_format", "verbose_json");
-    formData.append("timestamp_granularities[]", "word");
-    if (language) {
-        formData.append("language", language);
-    }
-    const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-        },
-        body: formData,
-    });
-    if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`Whisper transcription failed: ${error}`);
-    }
-    const data = await response.json();
-    return {
-        words: data.words || [],
-        text: data.text,
-    };
-}
-/**
- * Detect filler word ranges and merge adjacent ones within padding distance.
- *
- * @param words - Word-level transcript with timestamps
- * @param fillers - List of filler words/phrases to match
- * @param padding - Maximum gap in seconds to merge adjacent fillers
- * @returns Merged filler word ranges sorted by start time
- */
-export function detectFillerRanges(words, fillers, padding) {
-    const fillerSet = new Set(fillers.map((f) => f.toLowerCase().trim()));
-    // Find individual filler words
-    const matches = [];
-    for (const w of words) {
-        const cleaned = w.word.toLowerCase().replace(/[^a-z\s-]/g, "").trim();
-        if (fillerSet.has(cleaned)) {
-            matches.push({ word: w.word, start: w.start, end: w.end });
-        }
-    }
-    if (matches.length === 0)
-        return [];
-    // Merge adjacent filler ranges (within padding distance)
-    const merged = [{ ...matches[0] }];
-    for (let i = 1; i < matches.length; i++) {
-        const last = merged[merged.length - 1];
-        if (matches[i].start - last.end <= padding * 2) {
-            last.end = matches[i].end;
-            last.word += ` ${matches[i].word}`;
-        }
-        else {
-            merged.push({ ...matches[i] });
-        }
-    }
-    return merged;
-}
-/**
- * Remove filler words from a video using Whisper word-level timestamps + FFmpeg concat.
- *
- * Pipeline: extract audio -> Whisper transcription (word-level) -> detect fillers ->
- * invert to keep-segments -> FFmpeg stream-copy concat.
- *
- * @param options - Jump cut configuration
- * @returns Result with output path and detected fillers
- */
-export async function executeJumpCut(options) {
-    const { videoPath, outputPath, fillers = DEFAULT_FILLER_WORDS, padding = 0.05, language, analyzeOnly = false, apiKey, } = options;
-    if (!existsSync(videoPath)) {
-        return { success: false, error: `Video not found: ${videoPath}` };
-    }
-    if (!commandExists("ffmpeg")) {
-        return { success: false, error: "FFmpeg not found. Please install FFmpeg." };
-    }
-    const openaiKey = apiKey || process.env.OPENAI_API_KEY;
-    if (!openaiKey) {
-        return { success: false, error: "OpenAI API key required for Whisper transcription. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
-    }
-    try {
-        const tmpDir = `/tmp/vibe_jumpcut_${Date.now()}`;
-        await mkdir(tmpDir, { recursive: true });
-        const audioPath = join(tmpDir, "audio.wav");
-        try {
-            // Step 1: Extract audio
-            await execSafe("ffmpeg", [
-                "-i", videoPath, "-vn", "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", audioPath, "-y",
-            ], { timeout: 300000, maxBuffer: 50 * 1024 * 1024 });
-            // Step 2: Transcribe with word-level timestamps
-            const { words } = await transcribeWithWords(audioPath, openaiKey, language);
-            if (words.length === 0) {
-                return { success: false, error: "No words detected in audio" };
-            }
-            // Step 3: Detect filler ranges
-            const fillerRanges = detectFillerRanges(words, fillers, padding);
-            const totalDuration = await getVideoDuration(videoPath);
-            const fillerDuration = fillerRanges.reduce((sum, f) => sum + (f.end - f.start), 0);
-            if (analyzeOnly || fillerRanges.length === 0) {
-                return {
-                    success: true,
-                    totalDuration,
-                    fillerCount: fillerRanges.length,
-                    fillerDuration,
-                    fillers: fillerRanges,
-                };
-            }
-            // Step 4: Compute keep-segments (invert filler ranges)
-            const segments = [];
-            let cursor = 0;
-            for (const filler of fillerRanges) {
-                const segStart = Math.max(0, cursor);
-                const segEnd = Math.max(segStart, filler.start - padding);
-                if (segEnd > segStart) {
-                    segments.push({ start: segStart, end: segEnd });
-                }
-                cursor = filler.end + padding;
-            }
-            // Add final segment after last filler
-            if (cursor < totalDuration) {
-                segments.push({ start: cursor, end: totalDuration });
-            }
-            if (segments.length === 0) {
-                return { success: false, error: "No non-filler segments found" };
-            }
-            // Step 5: Extract segments and concat with FFmpeg (stream copy)
-            const segmentPaths = [];
-            for (let i = 0; i < segments.length; i++) {
-                const seg = segments[i];
-                const segPath = join(tmpDir, `seg-${i.toString().padStart(4, "0")}.ts`);
-                const duration = seg.end - seg.start;
-                await execSafe("ffmpeg", [
-                    "-i", videoPath, "-ss", String(seg.start), "-t", String(duration),
-                    "-c", "copy", "-avoid_negative_ts", "make_zero", segPath, "-y",
-                ], { timeout: 300000, maxBuffer: 50 * 1024 * 1024 });
-                segmentPaths.push(segPath);
-            }
-            // Create concat list
-            const concatList = segmentPaths.map((p) => `file '${p}'`).join("\n");
-            const listPath = join(tmpDir, "concat.txt");
-            await writeFile(listPath, concatList);
-            // Concat segments
-            await execSafe("ffmpeg", [
-                "-f", "concat", "-safe", "0", "-i", listPath, "-c", "copy", outputPath, "-y",
-            ], { timeout: 300000, maxBuffer: 50 * 1024 * 1024 });
-            return {
-                success: true,
-                outputPath,
-                totalDuration,
-                fillerCount: fillerRanges.length,
-                fillerDuration,
-                fillers: fillerRanges,
-            };
-        }
-        finally {
-            // Cleanup temp files
-            try {
-                const { rm } = await import("node:fs/promises");
-                await rm(tmpDir, { recursive: true, force: true });
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Jump cut failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-/**
- * Get ASS force_style string for caption preset
- */
-function getCaptionForceStyle(style, fontSize, fontColor, position) {
-    // ASS alignment: 1-3 bottom, 4-6 middle, 7-9 top (left/center/right)
-    const alignment = position === "top" ? 8 : position === "center" ? 5 : 2;
-    const marginV = position === "center" ? 0 : 30;
-    switch (style) {
-        case "minimal":
-            return `FontSize=${fontSize},FontName=Arial,PrimaryColour=&H00FFFFFF,OutlineColour=&H80000000,Outline=1,Shadow=0,Alignment=${alignment},MarginV=${marginV}`;
-        case "bold":
-            return `FontSize=${fontSize},FontName=Arial,Bold=1,PrimaryColour=&H00${fontColor === "yellow" ? "00FFFF" : "FFFFFF"},OutlineColour=&H00000000,Outline=3,Shadow=1,Alignment=${alignment},MarginV=${marginV}`;
-        case "outline":
-            return `FontSize=${fontSize},FontName=Arial,Bold=1,PrimaryColour=&H00FFFFFF,OutlineColour=&H000000FF,Outline=4,Shadow=0,Alignment=${alignment},MarginV=${marginV}`;
-        case "karaoke":
-            return `FontSize=${fontSize},FontName=Arial,Bold=1,PrimaryColour=&H0000FFFF,OutlineColour=&H00000000,Outline=2,Shadow=1,Alignment=${alignment},MarginV=${marginV}`;
-        default:
-            return `FontSize=${fontSize},FontName=Arial,Bold=1,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,Outline=3,Shadow=1,Alignment=${alignment},MarginV=${marginV}`;
-    }
-}
-/**
- * Transcribe video audio and burn styled captions using Whisper + FFmpeg.
- *
- * Pipeline: extract audio -> Whisper transcription -> generate SRT ->
- * burn captions via FFmpeg subtitles filter (or Remotion fallback).
- *
- * @param options - Caption configuration
- * @returns Result with output video path and SRT path
- */
-export async function executeCaption(options) {
-    const { videoPath, outputPath, style = "bold", fontSize: customFontSize, fontColor = "white", language, position = "bottom", apiKey, } = options;
-    if (!existsSync(videoPath)) {
-        return { success: false, error: `Video not found: ${videoPath}` };
-    }
-    if (!commandExists("ffmpeg")) {
-        return { success: false, error: "FFmpeg not found. Please install FFmpeg." };
-    }
-    const openaiKey = apiKey || process.env.OPENAI_API_KEY;
-    if (!openaiKey) {
-        return { success: false, error: "OpenAI API key required for Whisper transcription. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
-    }
-    try {
-        // Step 1: Extract audio from video
-        const tmpDir = `/tmp/vibe_caption_${Date.now()}`;
-        await mkdir(tmpDir, { recursive: true });
-        const audioPath = join(tmpDir, "audio.wav");
-        const srtPath = join(tmpDir, "captions.srt");
-        try {
-            await execSafe("ffmpeg", [
-                "-i", videoPath, "-vn", "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", audioPath, "-y",
-            ], { timeout: 300000, maxBuffer: 50 * 1024 * 1024 });
-            // Step 2: Transcribe with Whisper
-            const whisper = new WhisperProvider();
-            await whisper.initialize({ apiKey: openaiKey });
-            const audioBuffer = await readFile(audioPath);
-            const audioBlob = new Blob([audioBuffer]);
-            const transcriptResult = await whisper.transcribe(audioBlob, language);
-            if (transcriptResult.status === "failed" || !transcriptResult.segments || transcriptResult.segments.length === 0) {
-                return { success: false, error: `Transcription failed: ${transcriptResult.error || "No segments detected"}` };
-            }
-            // Step 3: Generate SRT
-            const srtContent = formatSRT(transcriptResult.segments);
-            await writeFile(srtPath, srtContent);
-            // Step 4: Get video resolution for auto font size
-            const { width, height } = await getVideoResolution(videoPath);
-            const fontSize = customFontSize || Math.round(height / 18);
-            // Step 5: Check FFmpeg subtitle filter support
-            let hasSubtitles = false;
-            try {
-                const { stdout: filterList } = await execSafe("ffmpeg", ["-filters"], { maxBuffer: 10 * 1024 * 1024 });
-                hasSubtitles = filterList.includes("subtitles");
-            }
-            catch {
-                // If filter check fails, continue and let FFmpeg error naturally
-            }
-            // Step 6: Burn captions
-            if (hasSubtitles) {
-                // Fast path: FFmpeg subtitles filter (requires libass)
-                const forceStyle = getCaptionForceStyle(style, fontSize, fontColor, position);
-                const escapedSrtPath = srtPath.replace(/\\/g, "/").replace(/:/g, "\\:");
-                await execSafe("ffmpeg", [
-                    "-i", videoPath, "-vf", `subtitles=${escapedSrtPath}:force_style='${forceStyle}'`,
-                    "-c:a", "copy", outputPath, "-y",
-                ], { timeout: 600000, maxBuffer: 50 * 1024 * 1024 });
-            }
-            else {
-                // Remotion fallback: embed video + captions in a single Remotion composition
-                console.log("FFmpeg missing subtitles filter (libass) — using Remotion fallback...");
-                const { generateCaptionComponent, renderWithEmbeddedVideo, ensureRemotionInstalled } = await import("../utils/remotion.js");
-                const remotionErr = await ensureRemotionInstalled();
-                if (remotionErr) {
-                    // Save SRT so the user still gets something
-                    const outputDir = dirname(outputPath);
-                    const outputSrtPath = join(outputDir, basename(outputPath, extname(outputPath)) + ".srt");
-                    await writeFile(outputSrtPath, srtContent);
-                    return { success: false, error: `${remotionErr}\nSRT saved to: ${outputSrtPath}` };
-                }
-                const videoDuration = await getVideoDuration(videoPath);
-                const fps = 30;
-                const durationInFrames = Math.ceil(videoDuration * fps);
-                const videoFileName = "source_video.mp4";
-                const { code, name } = generateCaptionComponent({
-                    segments: transcriptResult.segments.map((s) => ({
-                        start: s.startTime,
-                        end: s.endTime,
-                        text: s.text,
-                    })),
-                    style,
-                    fontSize,
-                    fontColor,
-                    position,
-                    width,
-                    height,
-                    videoFileName,
-                });
-                const renderResult = await renderWithEmbeddedVideo({
-                    componentCode: code,
-                    componentName: name,
-                    width,
-                    height,
-                    fps,
-                    durationInFrames,
-                    videoPath,
-                    videoFileName,
-                    outputPath,
-                });
-                if (!renderResult.success) {
-                    const outputDir = dirname(outputPath);
-                    const outputSrtPath = join(outputDir, basename(outputPath, extname(outputPath)) + ".srt");
-                    await writeFile(outputSrtPath, srtContent);
-                    return { success: false, error: `${renderResult.error}\nSRT saved to: ${outputSrtPath}` };
-                }
-            }
-            // Copy SRT to output directory for user reference
-            const outputDir = dirname(outputPath);
-            const outputSrtPath = join(outputDir, basename(outputPath, extname(outputPath)) + ".srt");
-            await writeFile(outputSrtPath, srtContent);
-            return {
-                success: true,
-                outputPath,
-                srtPath: outputSrtPath,
-                segmentCount: transcriptResult.segments.length,
-            };
-        }
-        finally {
-            // Cleanup temp files
-            try {
-                const { rm } = await import("node:fs/promises");
-                await rm(tmpDir, { recursive: true, force: true });
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Caption failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-/**
- * Reduce audio noise in a video or audio file using FFmpeg afftdn filter.
- *
- * Supports three strength presets (low/medium/high) with optional highpass/lowpass
- * for the "high" setting. Video streams are copied without re-encoding.
- *
- * @param options - Noise reduction configuration
- * @returns Result with output path and input duration
- */
-export async function executeNoiseReduce(options) {
-    const { inputPath, outputPath, strength = "medium", noiseFloor, } = options;
-    if (!existsSync(inputPath)) {
-        return { success: false, error: `File not found: ${inputPath}` };
-    }
-    if (!commandExists("ffmpeg")) {
-        return { success: false, error: "FFmpeg not found. Please install FFmpeg." };
-    }
-    try {
-        const inputDuration = await getVideoDuration(inputPath);
-        // Map strength to noise floor dB value
-        const nf = noiseFloor ?? (strength === "low" ? -20 : strength === "high" ? -35 : -25);
-        // Build audio filter
-        let audioFilter = `afftdn=nf=${nf}`;
-        if (strength === "high") {
-            audioFilter = `${audioFilter},highpass=f=80,lowpass=f=12000`;
-        }
-        // Check if input has video stream
-        let hasVideo = false;
-        try {
-            const { stdout } = await execSafe("ffprobe", [
-                "-v", "error", "-select_streams", "v", "-show_entries", "stream=codec_type", "-of", "csv=p=0", inputPath,
-            ], { maxBuffer: 10 * 1024 * 1024 });
-            hasVideo = stdout.trim().includes("video");
-        }
-        catch {
-            // No video stream
-        }
-        const args = ["-i", inputPath, "-af", audioFilter];
-        if (hasVideo)
-            args.push("-c:v", "copy");
-        args.push(outputPath, "-y");
-        await execSafe("ffmpeg", args, { timeout: 600000, maxBuffer: 50 * 1024 * 1024 });
-        return {
-            success: true,
-            outputPath,
-            inputDuration,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Noise reduction failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-/**
- * Apply fade-in and/or fade-out effects to video and/or audio using FFmpeg.
- *
- * @param options - Fade configuration
- * @returns Result with output path and which fades were applied
- */
-export async function executeFade(options) {
-    const { videoPath, outputPath, fadeIn = 1, fadeOut = 1, audioOnly = false, videoOnly = false, } = options;
-    if (!existsSync(videoPath)) {
-        return { success: false, error: `Video not found: ${videoPath}` };
-    }
-    if (!commandExists("ffmpeg")) {
-        return { success: false, error: "FFmpeg not found. Please install FFmpeg." };
-    }
-    try {
-        const totalDuration = await getVideoDuration(videoPath);
-        const videoFilters = [];
-        const audioFilters = [];
-        // Video fade filters
-        if (!audioOnly) {
-            if (fadeIn > 0) {
-                videoFilters.push(`fade=t=in:st=0:d=${fadeIn}`);
-            }
-            if (fadeOut > 0) {
-                const fadeOutStart = Math.max(0, totalDuration - fadeOut);
-                videoFilters.push(`fade=t=out:st=${fadeOutStart}:d=${fadeOut}`);
-            }
-        }
-        // Audio fade filters
-        if (!videoOnly) {
-            if (fadeIn > 0) {
-                audioFilters.push(`afade=t=in:st=0:d=${fadeIn}`);
-            }
-            if (fadeOut > 0) {
-                const fadeOutStart = Math.max(0, totalDuration - fadeOut);
-                audioFilters.push(`afade=t=out:st=${fadeOutStart}:d=${fadeOut}`);
-            }
-        }
-        // Build FFmpeg command
-        const ffmpegArgs = ["-i", videoPath];
-        if (videoFilters.length > 0) {
-            ffmpegArgs.push("-vf", videoFilters.join(","));
-        }
-        else if (audioOnly) {
-            ffmpegArgs.push("-c:v", "copy");
-        }
-        if (audioFilters.length > 0) {
-            ffmpegArgs.push("-af", audioFilters.join(","));
-        }
-        else if (videoOnly) {
-            ffmpegArgs.push("-c:a", "copy");
-        }
-        ffmpegArgs.push(outputPath, "-y");
-        await execSafe("ffmpeg", ffmpegArgs, { timeout: 600000, maxBuffer: 50 * 1024 * 1024 });
-        return {
-            success: true,
-            outputPath,
-            totalDuration,
-            fadeInApplied: fadeIn > 0,
-            fadeOutApplied: fadeOut > 0,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Fade failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-/**
- * Translate an SRT subtitle file to a target language using Claude or OpenAI.
- *
- * Segments are batched (~30 at a time) for efficient API usage. Preserves
- * original timestamps; only text content is translated.
- *
- * @param options - Translation configuration
- * @returns Result with output path and segment count
- */
-export async function executeTranslateSrt(options) {
-    const { srtPath, outputPath, targetLanguage, provider = "claude", sourceLanguage, apiKey, } = options;
-    if (!existsSync(srtPath)) {
-        return { success: false, error: `SRT file not found: ${srtPath}` };
-    }
-    try {
-        const srtContent = await readFile(srtPath, "utf-8");
-        const segments = parseSRT(srtContent);
-        if (segments.length === 0) {
-            return { success: false, error: "No subtitle segments found in SRT file" };
-        }
-        // Batch translate segments (~30 at a time)
-        const batchSize = 30;
-        const translatedSegments = [];
-        for (let i = 0; i < segments.length; i += batchSize) {
-            const batch = segments.slice(i, i + batchSize);
-            const textsToTranslate = batch.map((s, idx) => `[${idx}] ${s.text}`).join("\n");
-            const translatePrompt = `Translate the following subtitle texts to ${targetLanguage}.` +
-                (sourceLanguage ? ` The source language is ${sourceLanguage}.` : "") +
-                ` Return ONLY the translated texts, one per line, preserving the [N] prefix format exactly. ` +
-                `Do not add explanations.\n\n${textsToTranslate}`;
-            let translatedText;
-            if (provider === "openai") {
-                const openaiKey = apiKey || process.env.OPENAI_API_KEY;
-                if (!openaiKey) {
-                    return { success: false, error: "OpenAI API key required for translation. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
-                }
-                const response = await fetch("https://api.openai.com/v1/chat/completions", {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: `Bearer ${openaiKey}`,
-                    },
-                    body: JSON.stringify({
-                        model: "gpt-5-mini",
-                        messages: [{ role: "user", content: translatePrompt }],
-                        temperature: 0.3,
-                    }),
-                });
-                if (!response.ok) {
-                    return { success: false, error: `OpenAI API error: ${response.status} ${response.statusText}` };
-                }
-                const data = await response.json();
-                translatedText = data.choices[0]?.message?.content || "";
-            }
-            else {
-                const claudeKey = apiKey || process.env.ANTHROPIC_API_KEY;
-                if (!claudeKey) {
-                    return { success: false, error: "Anthropic API key required for translation. Run 'vibe setup' or set ANTHROPIC_API_KEY in .env" };
-                }
-                const response = await fetch("https://api.anthropic.com/v1/messages", {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        "x-api-key": claudeKey,
-                        "anthropic-version": "2023-06-01",
-                    },
-                    body: JSON.stringify({
-                        model: "claude-sonnet-4-6-20250514",
-                        max_tokens: 4096,
-                        messages: [{ role: "user", content: translatePrompt }],
-                    }),
-                });
-                if (!response.ok) {
-                    return { success: false, error: `Claude API error: ${response.status} ${response.statusText}` };
-                }
-                const data = await response.json();
-                translatedText = data.content?.find((c) => c.type === "text")?.text || "";
-            }
-            // Parse translated lines
-            const translatedLines = translatedText.trim().split("\n");
-            for (let j = 0; j < batch.length; j++) {
-                const seg = batch[j];
-                // Try to match [N] prefix
-                const line = translatedLines[j];
-                let text;
-                if (line) {
-                    text = line.replace(/^\[\d+\]\s*/, "").trim();
-                }
-                else {
-                    // Fallback: use original text if translation is missing
-                    text = seg.text;
-                }
-                translatedSegments.push({
-                    startTime: seg.startTime,
-                    endTime: seg.endTime,
-                    text,
-                });
-            }
-        }
-        // Format as SRT and write
-        const translatedSrt = formatSRT(translatedSegments);
-        await writeFile(outputPath, translatedSrt);
-        return {
-            success: true,
-            outputPath,
-            segmentCount: translatedSegments.length,
-            sourceLanguage: sourceLanguage || "auto",
-            targetLanguage,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `Translation failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-/**
- * Detect system font path for FFmpeg drawtext
- */
-function detectSystemFont() {
-    const platform = process.platform;
-    if (platform === "darwin") {
-        const candidates = [
-            "/System/Library/Fonts/Helvetica.ttc",
-            "/System/Library/Fonts/HelveticaNeue.ttc",
-            "/Library/Fonts/Arial.ttf",
-        ];
-        for (const f of candidates) {
-            if (existsSync(f))
-                return f;
-        }
-    }
-    else if (platform === "linux") {
-        const candidates = [
-            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
-            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
-            "/usr/share/fonts/TTF/DejaVuSans-Bold.ttf",
-        ];
-        for (const f of candidates) {
-            if (existsSync(f))
-                return f;
-        }
-    }
-    else if (platform === "win32") {
-        const candidates = [
-            "C:\\Windows\\Fonts\\arial.ttf",
-            "C:\\Windows\\Fonts\\segoeui.ttf",
-        ];
-        for (const f of candidates) {
-            if (existsSync(f))
-                return f;
-        }
-    }
-    return null;
-}
-/**
- * Get video resolution via ffprobe
- */
-async function getVideoResolution(videoPath) {
-    const { stdout } = await execSafe("ffprobe", [
-        "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height", "-of", "csv=p=0", videoPath,
-    ]);
-    const [w, h] = stdout.trim().split(",").map(Number);
-    return { width: w || 1920, height: h || 1080 };
-}
-/**
- * Escape text for FFmpeg drawtext filter
- */
-function escapeDrawtext(text) {
-    return text
-        .replace(/\\/g, "\\\\\\\\")
-        .replace(/'/g, "'\\\\\\''")
-        .replace(/:/g, "\\\\:")
-        .replace(/%/g, "\\\\%");
-}
-/**
- * Apply text overlays to a video using FFmpeg drawtext filter.
- *
- * Supports multiple text lines with configurable style, position, font,
- * and fade-in/out. Auto-detects system fonts across macOS, Linux, and Windows.
- *
- * @param options - Text overlay configuration
- * @returns Result with absolute output path
- */
-export async function applyTextOverlays(options) {
-    const { videoPath, texts, outputPath, style = "lower-third", fontSize: customFontSize, fontColor = "white", fadeDuration = 0.3, startTime = 0, } = options;
-    if (!texts || texts.length === 0) {
-        return { success: false, error: "No texts provided" };
-    }
-    const absVideoPath = resolve(process.cwd(), videoPath);
-    const absOutputPath = resolve(process.cwd(), outputPath);
-    // Check video exists
-    if (!existsSync(absVideoPath)) {
-        return { success: false, error: `Video not found: ${absVideoPath}` };
-    }
-    // Check FFmpeg
-    if (!commandExists("ffmpeg")) {
-        return { success: false, error: "FFmpeg not found. Please install FFmpeg." };
-    }
-    // Check drawtext filter availability
-    let hasDrawtext = true;
-    try {
-        const { stdout } = await execSafe("ffmpeg", ["-filters"]);
-        hasDrawtext = stdout.includes("drawtext");
-    }
-    catch {
-        // If filter check fails, assume available and let FFmpeg error naturally
-    }
-    if (!hasDrawtext) {
-        // Remotion fallback: render text overlay without libfreetype
-        console.log("FFmpeg missing drawtext filter (libfreetype) — using Remotion fallback...");
-        const { generateTextOverlayComponent, renderWithEmbeddedVideo, ensureRemotionInstalled } = await import("../utils/remotion.js");
-        const remotionErr = await ensureRemotionInstalled();
-        if (remotionErr) {
-            const platform = process.platform;
-            let hint = "";
-            if (platform === "darwin") {
-                hint = "\n\nFix: brew uninstall ffmpeg && brew install ffmpeg\n(The default homebrew formula includes libfreetype)";
-            }
-            else if (platform === "linux") {
-                hint = "\n\nFix: sudo apt install ffmpeg (Ubuntu/Debian)\n     or rebuild FFmpeg with --enable-libfreetype";
-            }
-            return {
-                success: false,
-                error: `FFmpeg 'drawtext' filter not available and Remotion fallback unavailable.\n${remotionErr}${hint}`,
-            };
-        }
-        const { width, height } = await getVideoResolution(absVideoPath);
-        const videoDuration = await getVideoDuration(absVideoPath);
-        const baseFontSize = customFontSize || Math.round(height / 20);
-        const endTime = options.endTime ?? videoDuration;
-        const fps = 30;
-        const durationInFrames = Math.ceil(videoDuration * fps);
-        const videoFileName = "source_video.mp4";
-        const { code, name } = generateTextOverlayComponent({
-            texts,
-            style,
-            fontSize: baseFontSize,
-            fontColor,
-            startTime,
-            endTime,
-            fadeDuration,
-            width,
-            height,
-            videoFileName,
-        });
-        const renderResult = await renderWithEmbeddedVideo({
-            componentCode: code,
-            componentName: name,
-            width,
-            height,
-            fps,
-            durationInFrames,
-            videoPath: absVideoPath,
-            videoFileName,
-            outputPath: absOutputPath,
-        });
-        return renderResult.success
-            ? { success: true, outputPath: renderResult.outputPath || absOutputPath }
-            : { success: false, error: renderResult.error || "Remotion render failed" };
-    }
-    // Get video resolution for scaling
-    const { width, height } = await getVideoResolution(absVideoPath);
-    const baseFontSize = customFontSize || Math.round(height / 20);
-    // Get video duration for endTime default
-    const videoDuration = await getVideoDuration(absVideoPath);
-    const endTime = options.endTime ?? videoDuration;
-    // Detect font
-    const fontPath = detectSystemFont();
-    const fontFile = fontPath ? `fontfile=${fontPath}:` : "";
-    // Build drawtext filters based on style
-    const filters = [];
-    for (let i = 0; i < texts.length; i++) {
-        const escaped = escapeDrawtext(texts[i]);
-        let x;
-        let y;
-        let fs;
-        let fc = fontColor;
-        let boxEnabled = 0;
-        let boxColor = "black@0.5";
-        let borderW = 0;
-        switch (style) {
-            case "center-bold":
-                x = "(w-text_w)/2";
-                y = `(h-text_h)/2+${i * Math.round(baseFontSize * 1.4)}`;
-                fs = Math.round(baseFontSize * 1.5);
-                borderW = 3;
-                break;
-            case "subtitle":
-                x = "(w-text_w)/2";
-                y = `h-${Math.round(height * 0.12)}+${i * Math.round(baseFontSize * 1.3)}`;
-                fs = baseFontSize;
-                boxEnabled = 1;
-                boxColor = "black@0.6";
-                break;
-            case "minimal":
-                x = `${Math.round(width * 0.05)}`;
-                y = `${Math.round(height * 0.05)}+${i * Math.round(baseFontSize * 1.3)}`;
-                fs = Math.round(baseFontSize * 0.8);
-                fc = "white@0.85";
-                break;
-            case "lower-third":
-            default:
-                x = `${Math.round(width * 0.05)}`;
-                y = `h-${Math.round(height * 0.18)}+${i * Math.round(baseFontSize * 1.3)}`;
-                fs = i === 0 ? Math.round(baseFontSize * 1.2) : baseFontSize;
-                boxEnabled = 1;
-                boxColor = "black@0.5";
-                break;
-        }
-        // Build alpha expression for fade in/out
-        const fadeIn = `if(lt(t-${startTime}\\,${fadeDuration})\\,(t-${startTime})/${fadeDuration}\\,1)`;
-        const fadeOut = `if(gt(t\\,${endTime - fadeDuration})\\,( ${endTime}-t)/${fadeDuration}\\,1)`;
-        const alpha = `min(${fadeIn}\\,${fadeOut})`;
-        let filter = `drawtext=${fontFile}text='${escaped}':fontsize=${fs}:fontcolor=${fc}:x=${x}:y=${y}:borderw=${borderW}:enable='between(t\\,${startTime}\\,${endTime})'`;
-        filter += `:alpha='${alpha}'`;
-        if (boxEnabled) {
-            filter += `:box=1:boxcolor=${boxColor}:boxborderw=8`;
-        }
-        filters.push(filter);
-    }
-    const filterChain = filters.join(",");
-    try {
-        await execSafe("ffmpeg", [
-            "-i", absVideoPath, "-vf", filterChain, "-c:a", "copy", absOutputPath, "-y",
-        ], { timeout: 600000, maxBuffer: 50 * 1024 * 1024 });
-        return { success: true, outputPath: absOutputPath };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `FFmpeg failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-/**
- * Execute text overlay for CLI/Agent usage. Delegates to {@link applyTextOverlays}.
- *
- * @param options - Text overlay configuration
- * @returns Result with absolute output path
- */
-export async function executeTextOverlay(options) {
-    return applyTextOverlays(options);
-}
-//# sourceMappingURL=ai-edit.js.map