@vibeframe/cli 0.27.0

package/dist/commands/ai-script-pipeline.js

@@ -0,0 +1,1027 @@
+/**
+ * @module ai-script-pipeline
+ *
+ * Script-to-video pipeline and scene regeneration execute functions.
+ *
+ * CLI commands: script-to-video, regenerate-scene
+ *
+ * Execute functions:
+ *   executeScriptToVideo  - Full pipeline: storyboard -> TTS -> images -> videos -> project
+ *   executeRegenerateScene - Re-generate specific scene(s) in an existing project
+ *
+ * Also exports shared helpers: uploadToImgbb, extendVideoToTarget,
+ * generateVideoWithRetryKling, generateVideoWithRetryRunway, generateVideoWithRetryVeo, waitForVideoWithRetry
+ *
+ * @dependencies Claude (storyboard), ElevenLabs (TTS), OpenAI/Gemini (images),
+ *              Kling/Runway (video), FFmpeg (assembly/extension)
+ */
+import { readFile, writeFile, mkdir, unlink, rename } from "node:fs/promises";
+import { resolve, basename, extname } from "node:path";
+import { existsSync } from "node:fs";
+import chalk from "chalk";
+import { GeminiProvider, OpenAIProvider, OpenAIImageProvider, ClaudeProvider, ElevenLabsProvider, KlingProvider, RunwayProvider, GrokProvider, } from "@vibeframe/ai-providers";
+import { getApiKey } from "../utils/api-key.js";
+import { getApiKeyFromConfig } from "../config/index.js";
+import { Project } from "../engine/index.js";
+import { getAudioDuration, getVideoDuration, extendVideoNaturally } from "../utils/audio.js";
+import { applyTextOverlays } from "./ai-edit.js";
+import { executeReview } from "./ai-review.js";
+import { execSafe } from "../utils/exec-safe.js";
+import { downloadVideo } from "./ai-helpers.js";
+/** Default retry count for video generation API calls. */
+export const DEFAULT_VIDEO_RETRIES = 2;
+/** Delay between retries in milliseconds. */
+export const RETRY_DELAY_MS = 5000;
+/**
+ * Sleep helper
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Upload image to ImgBB and return the URL
+ * Used for Kling v2.5/v2.6 image-to-video which requires URL (not base64)
+ */
+export async function uploadToImgbb(imageBuffer, apiKey) {
+    try {
+        const base64Image = imageBuffer.toString("base64");
+        const formData = new URLSearchParams();
+        formData.append("key", apiKey);
+        formData.append("image", base64Image);
+        const response = await fetch("https://api.imgbb.com/1/upload", {
+            method: "POST",
+            body: formData,
+        });
+        if (!response.ok) {
+            return { success: false, error: `ImgBB API error (${response.status}): ${response.statusText}` };
+        }
+        const data = (await response.json());
+        if (data.success && data.data?.url) {
+            return { success: true, url: data.data.url };
+        }
+        else {
+            return { success: false, error: data.error?.message || "Upload failed" };
+        }
+    }
+    catch (err) {
+        return { success: false, error: String(err) };
+    }
+}
+/**
+ * Extend a video to target duration using Kling extend API when possible,
+ * with fallback to FFmpeg-based extendVideoNaturally.
+ *
+ * When the extension ratio > 1.4 and a Kling provider + videoId are available,
+ * uses the Kling video-extend API for natural continuation instead of freeze frames.
+ */
+export async function extendVideoToTarget(videoPath, targetDuration, outputDir, sceneLabel, options) {
+    const actualDuration = await getVideoDuration(videoPath);
+    if (actualDuration >= targetDuration - 0.1)
+        return;
+    const ratio = targetDuration / actualDuration;
+    const extendedPath = resolve(outputDir, `${basename(videoPath, ".mp4")}-extended.mp4`);
+    // Try Kling extend API for large gaps (ratio > 1.4) where freeze frames look bad
+    if (ratio > 1.4 && options?.kling && options?.videoId) {
+        try {
+            options.onProgress?.(`${sceneLabel}: Extending via Kling API...`);
+            const extendResult = await options.kling.extendVideo(options.videoId, {
+                duration: "5",
+            });
+            if (extendResult.status !== "failed" && extendResult.id) {
+                const waitResult = await options.kling.waitForExtendCompletion(extendResult.id, (status) => {
+                    options.onProgress?.(`${sceneLabel}: extend ${status.status}...`);
+                }, 600000);
+                if (waitResult.status === "completed" && waitResult.videoUrl) {
+                    // Download extended video
+                    const extendedVideoPath = resolve(outputDir, `${basename(videoPath, ".mp4")}-kling-ext.mp4`);
+                    const buffer = await downloadVideo(waitResult.videoUrl);
+                    await writeFile(extendedVideoPath, buffer);
+                    // Concatenate original + extension
+                    const concatPath = resolve(outputDir, `${basename(videoPath, ".mp4")}-concat.mp4`);
+                    const listPath = resolve(outputDir, `${basename(videoPath, ".mp4")}-concat.txt`);
+                    await writeFile(listPath, `file '${videoPath}'\nfile '${extendedVideoPath}'`, "utf-8");
+                    await execSafe("ffmpeg", ["-y", "-f", "concat", "-safe", "0", "-i", listPath, "-c", "copy", concatPath]);
+                    // Trim to exact target duration if concatenated video is longer
+                    const concatDuration = await getVideoDuration(concatPath);
+                    if (concatDuration > targetDuration + 0.5) {
+                        await execSafe("ffmpeg", ["-y", "-i", concatPath, "-t", targetDuration.toFixed(2), "-c", "copy", extendedPath]);
+                        await unlink(concatPath);
+                    }
+                    else {
+                        await rename(concatPath, extendedPath);
+                    }
+                    // Cleanup temp files
+                    await unlink(extendedVideoPath).catch(() => { });
+                    await unlink(listPath).catch(() => { });
+                    await unlink(videoPath);
+                    await rename(extendedPath, videoPath);
+                    return;
+                }
+            }
+            // If Kling extend failed, fall through to FFmpeg fallback
+            options.onProgress?.(`${sceneLabel}: Kling extend failed, using FFmpeg fallback...`);
+        }
+        catch {
+            options.onProgress?.(`${sceneLabel}: Kling extend error, using FFmpeg fallback...`);
+        }
+    }
+    // FFmpeg-based fallback (slowdown + frame interpolation + freeze frame)
+    await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+    await unlink(videoPath);
+    await rename(extendedPath, videoPath);
+}
+/**
+ * Generate video with retry logic for Kling provider
+ * Supports image-to-video with URL (v2.5/v2.6 models)
+ */
+export async function generateVideoWithRetryKling(kling, segment, options, maxRetries, onProgress) {
+    // Build detailed prompt from storyboard segment
+    const prompt = segment.visualStyle
+        ? `${segment.visuals}. Style: ${segment.visualStyle}`
+        : segment.visuals;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const result = await kling.generateVideo(prompt, {
+                prompt,
+                // Pass reference image (base64 or URL) - KlingProvider handles v1.5 fallback for base64
+                referenceImage: options.referenceImage,
+                duration: options.duration,
+                aspectRatio: options.aspectRatio,
+                mode: "std", // Use std mode for faster generation
+            });
+            if (result.status !== "failed" && result.id) {
+                return {
+                    taskId: result.id,
+                    type: options.referenceImage ? "image2video" : "text2video",
+                };
+            }
+            if (attempt < maxRetries) {
+                onProgress?.(`⚠ Retry ${attempt + 1}/${maxRetries}...`);
+                await sleep(RETRY_DELAY_MS);
+            }
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            if (attempt < maxRetries) {
+                onProgress?.(`⚠ Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
+                await sleep(RETRY_DELAY_MS);
+            }
+            else {
+                // Log the final error on last attempt
+                console.error(chalk.dim(`\n  [Kling error: ${errMsg}]`));
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Generate video with retry logic for Runway provider
+ */
+export async function generateVideoWithRetryRunway(runway, segment, referenceImage, options, maxRetries, onProgress) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const result = await runway.generateVideo(segment.visuals, {
+                prompt: segment.visuals,
+                referenceImage,
+                duration: options.duration,
+                aspectRatio: options.aspectRatio,
+            });
+            if (result.status !== "failed" && result.id) {
+                return { taskId: result.id };
+            }
+            if (attempt < maxRetries) {
+                onProgress?.(`⚠ Retry ${attempt + 1}/${maxRetries}...`);
+                await sleep(RETRY_DELAY_MS);
+            }
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            if (attempt < maxRetries) {
+                onProgress?.(`⚠ Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
+                await sleep(RETRY_DELAY_MS);
+            }
+            else {
+                console.error(chalk.dim(`\n  [Runway error: ${errMsg}]`));
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Generate video with retry logic for Veo (Gemini) provider
+ */
+export async function generateVideoWithRetryVeo(gemini, segment, options, maxRetries, onProgress) {
+    const prompt = segment.visualStyle
+        ? `${segment.visuals}. Style: ${segment.visualStyle}`
+        : segment.visuals;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const result = await gemini.generateVideo(prompt, {
+                prompt,
+                referenceImage: options.referenceImage,
+                duration: options.duration,
+                aspectRatio: options.aspectRatio,
+                model: "veo-3.1-fast-generate-preview",
+            });
+            if (result.status !== "failed" && result.id) {
+                return { operationName: result.id };
+            }
+            if (attempt < maxRetries) {
+                onProgress?.(`⚠ Retry ${attempt + 1}/${maxRetries}...`);
+                await sleep(RETRY_DELAY_MS);
+            }
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            if (attempt < maxRetries) {
+                onProgress?.(`⚠ Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
+                await sleep(RETRY_DELAY_MS);
+            }
+            else {
+                console.error(chalk.dim(`\n  [Veo error: ${errMsg}]`));
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Wait for video completion with retry logic
+ */
+export async function waitForVideoWithRetry(provider, taskId, providerType, maxRetries, onProgress, timeout) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            let result;
+            if (providerType === "kling") {
+                result = await provider.waitForCompletion(taskId, "image2video", (status) => onProgress?.(status.status || "processing"), timeout || 600000);
+            }
+            else {
+                result = await provider.waitForCompletion(taskId, (status) => {
+                    const progress = status.progress !== undefined ? `${status.progress}%` : status.status;
+                    onProgress?.(progress || "processing");
+                }, timeout || 300000);
+            }
+            if (result.status === "completed" && result.videoUrl) {
+                return { videoUrl: result.videoUrl };
+            }
+            // If failed, try resubmitting on next attempt
+            if (attempt < maxRetries) {
+                onProgress?.(`⚠ Failed, will need resubmission...`);
+                return null; // Signal need for resubmission
+            }
+        }
+        catch (err) {
+            if (attempt < maxRetries) {
+                onProgress?.(`⚠ Error waiting, retry ${attempt + 1}/${maxRetries}...`);
+                await sleep(RETRY_DELAY_MS);
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Execute the full script-to-video pipeline programmatically.
+ *
+ * Pipeline stages:
+ * 1. Generate storyboard with Claude
+ * 2. Generate per-scene voiceovers with ElevenLabs TTS
+ * 3. Generate scene images (OpenAI/Gemini)
+ * 4. Generate scene videos (Kling/Runway) with extension to match narration
+ * 4.5. Apply text overlays if present in storyboard
+ * 5. Assemble .vibe.json project file
+ * 6. Optional AI review and auto-fix (Gemini)
+ *
+ * @param options - Pipeline configuration
+ * @returns Result with paths to all generated assets and project file
+ */
+export async function executeScriptToVideo(options) {
+    const outputDir = options.outputDir || "script-video-output";
+    try {
+        // Get storyboard provider API key
+        const storyboardProvider = options.storyboardProvider || "claude";
+        let storyboardApiKey;
+        if (storyboardProvider === "openai") {
+            storyboardApiKey = (await getApiKey("OPENAI_API_KEY", "OpenAI")) ?? undefined;
+            if (!storyboardApiKey) {
+                return { success: false, outputDir, scenes: 0, error: "OpenAI API key required for storyboard generation (--storyboard-provider openai). Run 'vibe setup' or set OPENAI_API_KEY in .env" };
+            }
+        }
+        else if (storyboardProvider === "gemini") {
+            storyboardApiKey = (await getApiKey("GOOGLE_API_KEY", "Google")) ?? undefined;
+            if (!storyboardApiKey) {
+                return { success: false, outputDir, scenes: 0, error: "Google API key required for storyboard generation (--storyboard-provider gemini). Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
+            }
+        }
+        else {
+            // Default: Claude
+            storyboardApiKey = (await getApiKey("ANTHROPIC_API_KEY", "Anthropic")) ?? undefined;
+            if (!storyboardApiKey) {
+                return { success: false, outputDir, scenes: 0, error: "Anthropic API key required for storyboard generation. Run 'vibe setup' or set ANTHROPIC_API_KEY in .env" };
+            }
+        }
+        // Get image provider API key
+        let imageApiKey;
+        const imageProvider = options.imageProvider || "openai";
+        if (imageProvider === "openai" || imageProvider === "dalle") {
+            imageApiKey = (await getApiKey("OPENAI_API_KEY", "OpenAI")) ?? undefined;
+            if (!imageApiKey) {
+                return { success: false, outputDir, scenes: 0, error: "OpenAI API key required for image generation. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
+            }
+        }
+        else if (imageProvider === "gemini") {
+            imageApiKey = (await getApiKey("GOOGLE_API_KEY", "Google")) ?? undefined;
+            if (!imageApiKey) {
+                return { success: false, outputDir, scenes: 0, error: "Google API key required for Gemini image generation. Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
+            }
+        }
+        else if (imageProvider === "grok") {
+            imageApiKey = (await getApiKey("XAI_API_KEY", "xAI")) ?? undefined;
+            if (!imageApiKey) {
+                return { success: false, outputDir, scenes: 0, error: "xAI API key required for Grok image generation. Run 'vibe setup' or set XAI_API_KEY in .env" };
+            }
+        }
+        let elevenlabsApiKey;
+        if (!options.noVoiceover) {
+            elevenlabsApiKey = (await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs")) ?? undefined;
+            if (!elevenlabsApiKey) {
+                return { success: false, outputDir, scenes: 0, error: "ElevenLabs API key required for voiceover (or use noVoiceover option). Run 'vibe setup' or set ELEVENLABS_API_KEY in .env" };
+            }
+        }
+        let videoApiKey;
+        if (!options.imagesOnly) {
+            if (options.generator === "kling") {
+                videoApiKey = (await getApiKey("KLING_API_KEY", "Kling")) ?? undefined;
+                if (!videoApiKey) {
+                    return { success: false, outputDir, scenes: 0, error: "Kling API key required (or use imagesOnly option). Run 'vibe setup' or set KLING_API_KEY in .env" };
+                }
+            }
+            else if (options.generator === "veo") {
+                videoApiKey = (await getApiKey("GOOGLE_API_KEY", "Google")) ?? undefined;
+                if (!videoApiKey) {
+                    return { success: false, outputDir, scenes: 0, error: "Google API key required for Veo video generation (or use imagesOnly option). Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
+                }
+            }
+            else {
+                videoApiKey = (await getApiKey("RUNWAY_API_SECRET", "Runway")) ?? undefined;
+                if (!videoApiKey) {
+                    return { success: false, outputDir, scenes: 0, error: "Runway API key required (or use imagesOnly option). Run 'vibe setup' or set RUNWAY_API_SECRET in .env" };
+                }
+            }
+        }
+        // Create output directory
+        const absOutputDir = resolve(process.cwd(), outputDir);
+        if (!existsSync(absOutputDir)) {
+            await mkdir(absOutputDir, { recursive: true });
+        }
+        // Step 1: Generate storyboard
+        let segments;
+        const creativityOpts = { creativity: options.creativity };
+        if (storyboardProvider === "openai") {
+            const openai = new OpenAIProvider();
+            await openai.initialize({ apiKey: storyboardApiKey });
+            segments = await openai.analyzeContent(options.script, options.duration, creativityOpts);
+        }
+        else if (storyboardProvider === "gemini") {
+            const gemini = new GeminiProvider();
+            await gemini.initialize({ apiKey: storyboardApiKey });
+            segments = await gemini.analyzeContent(options.script, options.duration, creativityOpts);
+        }
+        else {
+            const claude = new ClaudeProvider();
+            await claude.initialize({ apiKey: storyboardApiKey });
+            segments = await claude.analyzeContent(options.script, options.duration, creativityOpts);
+        }
+        if (segments.length === 0) {
+            return { success: false, outputDir, scenes: 0, error: "Failed to generate storyboard" };
+        }
+        // Save storyboard
+        const storyboardPath = resolve(absOutputDir, "storyboard.json");
+        await writeFile(storyboardPath, JSON.stringify(segments, null, 2), "utf-8");
+        const result = {
+            success: true,
+            outputDir: absOutputDir,
+            scenes: segments.length,
+            storyboardPath,
+            narrations: [],
+            narrationEntries: [],
+            images: [],
+            videos: [],
+            failedScenes: [],
+            failedNarrations: [],
+        };
+        // Step 2: Generate per-scene voiceovers with ElevenLabs
+        if (!options.noVoiceover && elevenlabsApiKey) {
+            const elevenlabs = new ElevenLabsProvider();
+            await elevenlabs.initialize({ apiKey: elevenlabsApiKey });
+            for (let i = 0; i < segments.length; i++) {
+                const segment = segments[i];
+                const narrationText = segment.narration || segment.description;
+                if (!narrationText) {
+                    // No narration text for this segment - add placeholder entry
+                    result.narrationEntries.push({
+                        path: null,
+                        duration: segment.duration,
+                        segmentIndex: i,
+                        failed: false, // Not failed, just no text
+                    });
+                    continue;
+                }
+                const ttsResult = await elevenlabs.textToSpeech(narrationText, {
+                    voiceId: options.voice,
+                });
+                if (ttsResult.success && ttsResult.audioBuffer) {
+                    const audioPath = resolve(absOutputDir, `narration-${i + 1}.mp3`);
+                    await writeFile(audioPath, ttsResult.audioBuffer);
+                    // Get actual audio duration
+                    const actualDuration = await getAudioDuration(audioPath);
+                    segment.duration = actualDuration;
+                    // Add to both arrays for backwards compatibility
+                    result.narrations.push(audioPath);
+                    result.narrationEntries.push({
+                        path: audioPath,
+                        duration: actualDuration,
+                        segmentIndex: i,
+                        failed: false,
+                    });
+                }
+                else {
+                    // TTS failed - add placeholder entry with error info
+                    result.narrationEntries.push({
+                        path: null,
+                        duration: segment.duration, // Keep original estimated duration
+                        segmentIndex: i,
+                        failed: true,
+                        error: ttsResult.error || "Unknown TTS error",
+                    });
+                    result.failedNarrations.push(i + 1); // 1-indexed for user display
+                }
+            }
+            // Recalculate startTime for all segments
+            let currentTime = 0;
+            for (const segment of segments) {
+                segment.startTime = currentTime;
+                currentTime += segment.duration;
+            }
+            // Re-save storyboard with updated durations
+            await writeFile(storyboardPath, JSON.stringify(segments, null, 2), "utf-8");
+        }
+        // Step 3: Generate images
+        const dalleImageSizes = {
+            "16:9": "1536x1024",
+            "9:16": "1024x1536",
+            "1:1": "1024x1024",
+        };
+        let openaiImageInstance;
+        let geminiInstance;
+        let grokInstance;
+        if (imageProvider === "openai" || imageProvider === "dalle") {
+            openaiImageInstance = new OpenAIImageProvider();
+            await openaiImageInstance.initialize({ apiKey: imageApiKey });
+        }
+        else if (imageProvider === "gemini") {
+            geminiInstance = new GeminiProvider();
+            await geminiInstance.initialize({ apiKey: imageApiKey });
+        }
+        else if (imageProvider === "grok") {
+            grokInstance = new GrokProvider();
+            await grokInstance.initialize({ apiKey: imageApiKey });
+        }
+        const imagePaths = [];
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            const imagePrompt = segment.visualStyle
+                ? `${segment.visuals}. Style: ${segment.visualStyle}`
+                : segment.visuals;
+            try {
+                let imageBuffer;
+                let imageUrl;
+                if ((imageProvider === "openai" || imageProvider === "dalle") && openaiImageInstance) {
+                    const imageResult = await openaiImageInstance.generateImage(imagePrompt, {
+                        size: dalleImageSizes[options.aspectRatio || "16:9"] || "1536x1024",
+                        quality: "standard",
+                    });
+                    if (imageResult.success && imageResult.images && imageResult.images.length > 0) {
+                        // GPT Image 1.5 returns base64, DALL-E 3 returns URL
+                        const img = imageResult.images[0];
+                        if (img.base64) {
+                            imageBuffer = Buffer.from(img.base64, "base64");
+                        }
+                        else if (img.url) {
+                            imageUrl = img.url;
+                        }
+                    }
+                    // else: imageResult.error is available but not captured
+                }
+                else if (imageProvider === "gemini" && geminiInstance) {
+                    const imageResult = await geminiInstance.generateImage(imagePrompt, {
+                        aspectRatio: (options.aspectRatio || "16:9"),
+                    });
+                    if (imageResult.success && imageResult.images?.[0]?.base64) {
+                        imageBuffer = Buffer.from(imageResult.images[0].base64, "base64");
+                    }
+                    // else: imageResult.error is available but not captured
+                }
+                else if (imageProvider === "grok" && grokInstance) {
+                    const imageResult = await grokInstance.generateImage(imagePrompt, {
+                        aspectRatio: options.aspectRatio || "16:9",
+                    });
+                    if (imageResult.success && imageResult.images && imageResult.images.length > 0) {
+                        const img = imageResult.images[0];
+                        if (img.base64) {
+                            imageBuffer = Buffer.from(img.base64, "base64");
+                        }
+                        else if (img.url) {
+                            imageUrl = img.url;
+                        }
+                    }
+                }
+                const imagePath = resolve(absOutputDir, `scene-${i + 1}.png`);
+                if (imageBuffer) {
+                    await writeFile(imagePath, imageBuffer);
+                    imagePaths.push(imagePath);
+                    result.images.push(imagePath);
+                }
+                else if (imageUrl) {
+                    const response = await fetch(imageUrl);
+                    const buffer = Buffer.from(await response.arrayBuffer());
+                    await writeFile(imagePath, buffer);
+                    imagePaths.push(imagePath);
+                    result.images.push(imagePath);
+                }
+                else {
+                    // Track failed scene - error details not captured (see provider imageResult.error)
+                    // The failedScenes array tracks which scenes failed for the caller
+                    imagePaths.push("");
+                }
+            }
+            catch {
+                imagePaths.push("");
+            }
+            // Rate limiting delay
+            if (i < segments.length - 1) {
+                await new Promise((r) => setTimeout(r, 500));
+            }
+        }
+        // Step 4: Generate videos (if not images-only)
+        const videoPaths = [];
+        const maxRetries = options.retries ?? DEFAULT_VIDEO_RETRIES;
+        if (!options.imagesOnly && videoApiKey) {
+            if (options.generator === "kling") {
+                const kling = new KlingProvider();
+                await kling.initialize({ apiKey: videoApiKey });
+                if (!kling.isConfigured()) {
+                    return { success: false, outputDir: absOutputDir, scenes: segments.length, error: "Invalid Kling API key format. Use ACCESS_KEY:SECRET_KEY" };
+                }
+                for (let i = 0; i < segments.length; i++) {
+                    if (!imagePaths[i]) {
+                        videoPaths.push("");
+                        continue;
+                    }
+                    const segment = segments[i];
+                    const videoDuration = (segment.duration > 5 ? 10 : 5);
+                    // Using text2video since Kling's image2video requires URL (not base64)
+                    const taskResult = await generateVideoWithRetryKling(kling, segment, { duration: videoDuration, aspectRatio: (options.aspectRatio || "16:9") }, maxRetries);
+                    if (taskResult) {
+                        try {
+                            const waitResult = await kling.waitForCompletion(taskResult.taskId, taskResult.type, undefined, 600000);
+                            if (waitResult.status === "completed" && waitResult.videoUrl) {
+                                const videoPath = resolve(absOutputDir, `scene-${i + 1}.mp4`);
+                                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                                await writeFile(videoPath, buffer);
+                                // Extend video to match narration duration if needed
+                                const targetDuration = segment.duration; // Already updated to narration length
+                                const actualVideoDuration = await getVideoDuration(videoPath);
+                                if (actualVideoDuration < targetDuration - 0.1) {
+                                    const extendedPath = resolve(absOutputDir, `scene-${i + 1}-extended.mp4`);
+                                    await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+                                    // Replace original with extended version
+                                    await unlink(videoPath);
+                                    await rename(extendedPath, videoPath);
+                                }
+                                videoPaths.push(videoPath);
+                                result.videos.push(videoPath);
+                            }
+                            else {
+                                videoPaths.push("");
+                                result.failedScenes.push(i + 1);
+                            }
+                        }
+                        catch {
+                            videoPaths.push("");
+                            result.failedScenes.push(i + 1);
+                        }
+                    }
+                    else {
+                        videoPaths.push("");
+                        result.failedScenes.push(i + 1);
+                    }
+                }
+            }
+            else if (options.generator === "veo") {
+                // Veo (Gemini)
+                const veo = new GeminiProvider();
+                await veo.initialize({ apiKey: videoApiKey });
+                for (let i = 0; i < segments.length; i++) {
+                    if (!imagePaths[i]) {
+                        videoPaths.push("");
+                        continue;
+                    }
+                    const segment = segments[i];
+                    const veoDuration = (segment.duration > 6 ? 8 : segment.duration > 4 ? 6 : 4);
+                    const taskResult = await generateVideoWithRetryVeo(veo, segment, { duration: veoDuration, aspectRatio: (options.aspectRatio || "16:9") }, maxRetries);
+                    if (taskResult) {
+                        try {
+                            const waitResult = await veo.waitForVideoCompletion(taskResult.operationName, undefined, 300000);
+                            if (waitResult.status === "completed" && waitResult.videoUrl) {
+                                const videoPath = resolve(absOutputDir, `scene-${i + 1}.mp4`);
+                                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                                await writeFile(videoPath, buffer);
+                                // Extend video to match narration duration if needed
+                                const targetDuration = segment.duration;
+                                const actualVideoDuration = await getVideoDuration(videoPath);
+                                if (actualVideoDuration < targetDuration - 0.1) {
+                                    const extendedPath = resolve(absOutputDir, `scene-${i + 1}-extended.mp4`);
+                                    await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+                                    await unlink(videoPath);
+                                    await rename(extendedPath, videoPath);
+                                }
+                                videoPaths.push(videoPath);
+                                result.videos.push(videoPath);
+                            }
+                            else {
+                                videoPaths.push("");
+                                result.failedScenes.push(i + 1);
+                            }
+                        }
+                        catch {
+                            videoPaths.push("");
+                            result.failedScenes.push(i + 1);
+                        }
+                    }
+                    else {
+                        videoPaths.push("");
+                        result.failedScenes.push(i + 1);
+                    }
+                }
+            }
+            else {
+                // Runway
+                const runway = new RunwayProvider();
+                await runway.initialize({ apiKey: videoApiKey });
+                for (let i = 0; i < segments.length; i++) {
+                    if (!imagePaths[i]) {
+                        videoPaths.push("");
+                        continue;
+                    }
+                    const segment = segments[i];
+                    const imageBuffer = await readFile(imagePaths[i]);
+                    const ext = extname(imagePaths[i]).toLowerCase().slice(1);
+                    const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
+                    const referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
+                    const videoDuration = (segment.duration > 5 ? 10 : 5);
+                    const aspectRatio = options.aspectRatio === "1:1" ? "16:9" : (options.aspectRatio || "16:9");
+                    const taskResult = await generateVideoWithRetryRunway(runway, segment, referenceImage, { duration: videoDuration, aspectRatio }, maxRetries);
+                    if (taskResult) {
+                        try {
+                            const waitResult = await runway.waitForCompletion(taskResult.taskId, undefined, 300000);
+                            if (waitResult.status === "completed" && waitResult.videoUrl) {
+                                const videoPath = resolve(absOutputDir, `scene-${i + 1}.mp4`);
+                                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                                await writeFile(videoPath, buffer);
+                                // Extend video to match narration duration if needed
+                                const targetDuration = segment.duration;
+                                const actualVideoDuration = await getVideoDuration(videoPath);
+                                if (actualVideoDuration < targetDuration - 0.1) {
+                                    const extendedPath = resolve(absOutputDir, `scene-${i + 1}-extended.mp4`);
+                                    await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+                                    await unlink(videoPath);
+                                    await rename(extendedPath, videoPath);
+                                }
+                                videoPaths.push(videoPath);
+                                result.videos.push(videoPath);
+                            }
+                            else {
+                                videoPaths.push("");
+                                result.failedScenes.push(i + 1);
+                            }
+                        }
+                        catch {
+                            videoPaths.push("");
+                            result.failedScenes.push(i + 1);
+                        }
+                    }
+                    else {
+                        videoPaths.push("");
+                        result.failedScenes.push(i + 1);
+                    }
+                }
+            }
+        }
+        // Step 4.5: Apply text overlays (if segments have textOverlays)
+        if (!options.noTextOverlay) {
+            for (let i = 0; i < segments.length; i++) {
+                const segment = segments[i];
+                if (segment.textOverlays && segment.textOverlays.length > 0 && videoPaths[i] && videoPaths[i] !== "") {
+                    try {
+                        const overlayOutput = videoPaths[i].replace(/(\.[^.]+)$/, "-overlay$1");
+                        const overlayResult = await applyTextOverlays({
+                            videoPath: videoPaths[i],
+                            texts: segment.textOverlays,
+                            outputPath: overlayOutput,
+                            style: options.textStyle || "lower-third",
+                        });
+                        if (overlayResult.success && overlayResult.outputPath) {
+                            videoPaths[i] = overlayResult.outputPath;
+                        }
+                        // Silent fallback: keep original on failure
+                    }
+                    catch {
+                        // Silent fallback: keep original video
+                    }
+                }
+            }
+        }
+        // Step 5: Create project file
+        const project = new Project("Script-to-Video Output");
+        project.setAspectRatio((options.aspectRatio || "16:9"));
+        // Clear default tracks
+        const defaultTracks = project.getTracks();
+        for (const track of defaultTracks) {
+            project.removeTrack(track.id);
+        }
+        const videoTrack = project.addTrack({
+            name: "Video",
+            type: "video",
+            order: 1,
+            isMuted: false,
+            isLocked: false,
+            isVisible: true,
+        });
+        const audioTrack = project.addTrack({
+            name: "Audio",
+            type: "audio",
+            order: 0,
+            isMuted: false,
+            isLocked: false,
+            isVisible: true,
+        });
+        // Add narration clips - use narrationEntries for proper segment alignment
+        if (result.narrationEntries && result.narrationEntries.length > 0) {
+            for (const entry of result.narrationEntries) {
+                // Skip failed or missing narrations
+                if (entry.failed || !entry.path)
+                    continue;
+                const segment = segments[entry.segmentIndex];
+                const narrationDuration = await getAudioDuration(entry.path);
+                const audioSource = project.addSource({
+                    name: `Narration ${entry.segmentIndex + 1}`,
+                    url: entry.path,
+                    type: "audio",
+                    duration: narrationDuration,
+                });
+                project.addClip({
+                    sourceId: audioSource.id,
+                    trackId: audioTrack.id,
+                    startTime: segment.startTime,
+                    duration: narrationDuration,
+                    sourceStartOffset: 0,
+                    sourceEndOffset: narrationDuration,
+                });
+            }
+        }
+        // Add video/image clips
+        let currentTime = 0;
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            const hasVideo = videoPaths[i] && videoPaths[i] !== "";
+            const hasImage = imagePaths[i] && imagePaths[i] !== "";
+            if (!hasVideo && !hasImage) {
+                currentTime += segment.duration;
+                continue;
+            }
+            const assetPath = hasVideo ? videoPaths[i] : imagePaths[i];
+            const mediaType = hasVideo ? "video" : "image";
+            // Use actual video duration (after extension) instead of segment.duration
+            const actualDuration = hasVideo
+                ? await getVideoDuration(assetPath)
+                : segment.duration;
+            const source = project.addSource({
+                name: `Scene ${i + 1}`,
+                url: assetPath,
+                type: mediaType,
+                duration: actualDuration,
+            });
+            project.addClip({
+                sourceId: source.id,
+                trackId: videoTrack.id,
+                startTime: currentTime,
+                duration: actualDuration,
+                sourceStartOffset: 0,
+                sourceEndOffset: actualDuration,
+            });
+            currentTime += actualDuration;
+        }
+        // Save project file
+        const projectPath = resolve(absOutputDir, "project.vibe.json");
+        await writeFile(projectPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+        result.projectPath = projectPath;
+        result.totalDuration = currentTime;
+        // Step 6: AI Review & Auto-fix (optional, --review flag)
+        if (options.review) {
+            try {
+                const storyboardFile = resolve(absOutputDir, "storyboard.json");
+                // Export project to temp MP4 for review (use first valid video as proxy)
+                const reviewTarget = videoPaths.find((p) => p && p !== "") || imagePaths.find((p) => p && p !== "");
+                if (reviewTarget) {
+                    const reviewResult = await executeReview({
+                        videoPath: reviewTarget,
+                        storyboardPath: existsSync(storyboardFile) ? storyboardFile : undefined,
+                        autoApply: options.reviewAutoApply,
+                        model: "flash",
+                    });
+                    if (reviewResult.success) {
+                        result.reviewFeedback = reviewResult.feedback;
+                        result.appliedFixes = reviewResult.appliedFixes;
+                        result.reviewedVideoPath = reviewResult.outputPath;
+                    }
+                }
+            }
+            catch {
+                // Review is non-critical, continue with result
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        return {
+            success: false,
+            outputDir,
+            scenes: 0,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Regenerate specific scene(s) in an existing script-to-video project.
+ *
+ * Reads the storyboard.json from the project directory, then regenerates
+ * the requested scenes using the specified video/image provider. Supports
+ * image-to-video via ImgBB URL upload for Kling.
+ *
+ * @param options - Scene regeneration configuration
+ * @returns Result with lists of regenerated and failed scene numbers
+ */
+export async function executeRegenerateScene(options) {
+    const result = {
+        success: false,
+        regeneratedScenes: [],
+        failedScenes: [],
+    };
+    try {
+        const outputDir = resolve(process.cwd(), options.projectDir);
+        const storyboardPath = resolve(outputDir, "storyboard.json");
+        if (!existsSync(outputDir)) {
+            return { ...result, error: `Project directory not found: ${outputDir}` };
+        }
+        if (!existsSync(storyboardPath)) {
+            return { ...result, error: `Storyboard not found: ${storyboardPath}` };
+        }
+        const storyboardContent = await readFile(storyboardPath, "utf-8");
+        const segments = JSON.parse(storyboardContent);
+        // Validate scenes
+        for (const sceneNum of options.scenes) {
+            if (sceneNum < 1 || sceneNum > segments.length) {
+                return { ...result, error: `Scene ${sceneNum} does not exist. Storyboard has ${segments.length} scenes.` };
+            }
+        }
+        const regenerateVideo = options.videoOnly || (!options.narrationOnly && !options.imageOnly);
+        // Get API keys
+        let videoApiKey;
+        if (regenerateVideo) {
+            if (options.generator === "kling" || !options.generator) {
+                videoApiKey = (await getApiKey("KLING_API_KEY", "Kling")) ?? undefined;
+                if (!videoApiKey) {
+                    return { ...result, error: "Kling API key required. Run 'vibe setup' or set KLING_API_KEY in .env" };
+                }
+            }
+            else {
+                videoApiKey = (await getApiKey("RUNWAY_API_SECRET", "Runway")) ?? undefined;
+                if (!videoApiKey) {
+                    return { ...result, error: "Runway API key required. Run 'vibe setup' or set RUNWAY_API_SECRET in .env" };
+                }
+            }
+        }
+        // Process each scene
+        for (const sceneNum of options.scenes) {
+            const segment = segments[sceneNum - 1];
+            const imagePath = resolve(outputDir, `scene-${sceneNum}.png`);
+            const videoPath = resolve(outputDir, `scene-${sceneNum}.mp4`);
+            if (regenerateVideo && videoApiKey) {
+                if (!existsSync(imagePath)) {
+                    result.failedScenes.push(sceneNum);
+                    continue;
+                }
+                const imageBuffer = await readFile(imagePath);
+                const videoDuration = (segment.duration > 5 ? 10 : 5);
+                const maxRetries = options.retries ?? DEFAULT_VIDEO_RETRIES;
+                if (options.generator === "kling" || !options.generator) {
+                    const kling = new KlingProvider();
+                    await kling.initialize({ apiKey: videoApiKey });
+                    if (!kling.isConfigured()) {
+                        result.failedScenes.push(sceneNum);
+                        continue;
+                    }
+                    // Try to use image-to-video if ImgBB key available
+                    const imgbbApiKey = await getApiKeyFromConfig("imgbb") || process.env.IMGBB_API_KEY;
+                    let imageUrl;
+                    if (imgbbApiKey) {
+                        const uploadResult = await uploadToImgbb(imageBuffer, imgbbApiKey);
+                        if (uploadResult.success && uploadResult.url) {
+                            imageUrl = uploadResult.url;
+                        }
+                    }
+                    const taskResult = await generateVideoWithRetryKling(kling, segment, {
+                        duration: videoDuration,
+                        aspectRatio: (options.aspectRatio || "16:9"),
+                        referenceImage: imageUrl,
+                    }, maxRetries);
+                    if (taskResult) {
+                        try {
+                            const waitResult = await kling.waitForCompletion(taskResult.taskId, taskResult.type, undefined, 600000);
+                            if (waitResult.status === "completed" && waitResult.videoUrl) {
+                                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                                await writeFile(videoPath, buffer);
+                                // Extend video to match narration duration if needed
+                                const targetDuration = segment.duration;
+                                const actualVideoDuration = await getVideoDuration(videoPath);
+                                if (actualVideoDuration < targetDuration - 0.1) {
+                                    const extendedPath = resolve(outputDir, `scene-${sceneNum}-extended.mp4`);
+                                    await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+                                    await unlink(videoPath);
+                                    await rename(extendedPath, videoPath);
+                                }
+                                result.regeneratedScenes.push(sceneNum);
+                            }
+                            else {
+                                result.failedScenes.push(sceneNum);
+                            }
+                        }
+                        catch {
+                            result.failedScenes.push(sceneNum);
+                        }
+                    }
+                    else {
+                        result.failedScenes.push(sceneNum);
+                    }
+                }
+                else {
+                    // Runway
+                    const runway = new RunwayProvider();
+                    await runway.initialize({ apiKey: videoApiKey });
+                    const ext = extname(imagePath).toLowerCase().slice(1);
+                    const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
+                    const referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
+                    const aspectRatio = options.aspectRatio === "1:1" ? "16:9" : (options.aspectRatio || "16:9");
+                    const taskResult = await generateVideoWithRetryRunway(runway, segment, referenceImage, { duration: videoDuration, aspectRatio }, maxRetries);
+                    if (taskResult) {
+                        try {
+                            const waitResult = await runway.waitForCompletion(taskResult.taskId, undefined, 300000);
+                            if (waitResult.status === "completed" && waitResult.videoUrl) {
+                                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                                await writeFile(videoPath, buffer);
+                                // Extend video to match narration duration if needed
+                                const targetDuration = segment.duration;
+                                const actualVideoDuration = await getVideoDuration(videoPath);
+                                if (actualVideoDuration < targetDuration - 0.1) {
+                                    const extendedPath = resolve(outputDir, `scene-${sceneNum}-extended.mp4`);
+                                    await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+                                    await unlink(videoPath);
+                                    await rename(extendedPath, videoPath);
+                                }
+                                result.regeneratedScenes.push(sceneNum);
+                            }
+                            else {
+                                result.failedScenes.push(sceneNum);
+                            }
+                        }
+                        catch {
+                            result.failedScenes.push(sceneNum);
+                        }
+                    }
+                    else {
+                        result.failedScenes.push(sceneNum);
+                    }
+                }
+            }
+        }
+        result.success = result.failedScenes.length === 0;
+        return result;
+    }
+    catch (error) {
+        return {
+            ...result,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/* CLI command registration moved to ai-script-pipeline-cli.ts */
+//# sourceMappingURL=ai-script-pipeline.js.map