@vibeframe/cli 0.31.1 → 0.33.0

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

@@ -18,6 +18,8 @@ import { applyTextOverlays } from "./ai-edit.js";
 import { executeReview } from "./ai-review.js";
 import { DEFAULT_VIDEO_RETRIES, RETRY_DELAY_MS, sleep, uploadToImgbb, extendVideoToTarget, generateVideoWithRetryKling, generateVideoWithRetryRunway, } from "./ai-script-pipeline.js";
 import { downloadVideo } from "./ai-helpers.js";
+import { exitWithError, outputResult, authError, notFoundError, usageError, apiError, generalError } from "./output.js";
+import { validateOutputPath } from "./validate.js";
 export function registerScriptPipelineCommands(aiCommand) {
     // Script-to-Video command
     aiCommand
@@ -29,7 +31,7 @@ export function registerScriptPipelineCommands(aiCommand) {
         .option("-o, --output <path>", "Output project file path", "script-video.vibe.json")
         .option("-d, --duration <seconds>", "Target total duration in seconds")
         .option("-v, --voice <id>", "ElevenLabs voice ID for narration")
-        .option("-g, --generator <engine>", "Video generator: kling | runway | veo", "kling")
+        .option("-g, --generator <engine>", "Video generator: grok | kling | runway | veo", "grok")
         .option("-i, --image-provider <provider>", "Image provider: gemini | openai | grok", "gemini")
         .option("-a, --aspect-ratio <ratio>", "Aspect ratio: 16:9 | 9:16 | 1:1", "16:9")
         .option("--images-only", "Generate images only, skip video generation")
@@ -44,8 +46,36 @@ export function registerScriptPipelineCommands(aiCommand) {
         .option("--text-style <style>", "Text overlay style: lower-third, center-bold, subtitle, minimal", "lower-third")
         .option("--review", "Run AI review after assembly (requires GOOGLE_API_KEY)")
         .option("--review-auto-apply", "Auto-apply fixable issues from AI review")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (script, options) => {
         try {
+            if (options.output) {
+                validateOutputPath(options.output);
+            }
+            if (options.dryRun) {
+                outputResult({
+                    dryRun: true,
+                    command: "pipeline script-to-video",
+                    params: {
+                        script: script.slice(0, 200),
+                        file: options.file ?? false,
+                        output: options.output,
+                        duration: options.duration,
+                        generator: options.generator,
+                        imageProvider: options.imageProvider,
+                        aspectRatio: options.aspectRatio,
+                        imagesOnly: options.imagesOnly ?? false,
+                        voiceover: options.voiceover,
+                        outputDir: options.outputDir,
+                        creativity: options.creativity,
+                        storyboardProvider: options.storyboardProvider,
+                        textOverlay: options.textOverlay,
+                        textStyle: options.textStyle,
+                        review: options.review ?? false,
+                    },
+                });
+                return;
+            }
             // Load environment variables from .env file
             loadEnv();
             // Get storyboard provider API key
@@ -54,27 +84,23 @@ export function registerScriptPipelineCommands(aiCommand) {
             if (storyboardProvider === "openai") {
                 storyboardApiKey = (await getApiKey("OPENAI_API_KEY", "OpenAI")) ?? undefined;
                 if (!storyboardApiKey) {
-                    console.error(chalk.red("OpenAI API key required for storyboard generation (-s openai). Set OPENAI_API_KEY in .env or run: vibe setup"));
-                    process.exit(1);
+                    exitWithError(authError("OPENAI_API_KEY", "OpenAI"));
                 }
             }
             else if (storyboardProvider === "gemini") {
                 storyboardApiKey = (await getApiKey("GOOGLE_API_KEY", "Google")) ?? undefined;
                 if (!storyboardApiKey) {
-                    console.error(chalk.red("Google API key required for storyboard generation (-s gemini). Set GOOGLE_API_KEY in .env or run: vibe setup"));
-                    process.exit(1);
+                    exitWithError(authError("GOOGLE_API_KEY", "Google"));
                 }
             }
             else if (storyboardProvider === "claude") {
                 storyboardApiKey = (await getApiKey("ANTHROPIC_API_KEY", "Anthropic")) ?? undefined;
                 if (!storyboardApiKey) {
-                    console.error(chalk.red("Anthropic API key required for storyboard generation. Set ANTHROPIC_API_KEY in .env or run: vibe setup"));
-                    process.exit(1);
+                    exitWithError(authError("ANTHROPIC_API_KEY", "Anthropic"));
                 }
             }
             else {
-                console.error(chalk.red(`Unknown storyboard provider: ${storyboardProvider}. Use claude, openai, or gemini`));
-                process.exit(1);
+                exitWithError(usageError(`Unknown storyboard provider: ${storyboardProvider}`, "Use claude, openai, or gemini"));
             }
             // Get image provider API key
             let imageApiKey;
@@ -82,55 +108,50 @@ export function registerScriptPipelineCommands(aiCommand) {
             if (imageProvider === "openai" || imageProvider === "dalle") {
                 imageApiKey = (await getApiKey("OPENAI_API_KEY", "OpenAI")) ?? undefined;
                 if (!imageApiKey) {
-                    console.error(chalk.red("OpenAI API key required for DALL-E image generation. Set OPENAI_API_KEY in .env or run: vibe setup"));
-                    process.exit(1);
+                    exitWithError(authError("OPENAI_API_KEY", "OpenAI"));
                 }
             }
             else if (imageProvider === "gemini") {
                 imageApiKey = (await getApiKey("GOOGLE_API_KEY", "Google")) ?? undefined;
                 if (!imageApiKey) {
-                    console.error(chalk.red("Google API key required for Gemini image generation. Set GOOGLE_API_KEY in .env or run: vibe setup"));
-                    process.exit(1);
+                    exitWithError(authError("GOOGLE_API_KEY", "Google"));
                 }
             }
             else if (imageProvider === "grok") {
                 imageApiKey = (await getApiKey("XAI_API_KEY", "xAI")) ?? undefined;
                 if (!imageApiKey) {
-                    console.error(chalk.red("xAI API key required for Grok image generation. Set XAI_API_KEY in .env or run: vibe setup"));
-                    process.exit(1);
+                    exitWithError(authError("XAI_API_KEY", "xAI"));
                 }
             }
             else {
-                console.error(chalk.red(`Unknown image provider: ${imageProvider}. Use openai, gemini, or grok`));
-                process.exit(1);
+                exitWithError(usageError(`Unknown image provider: ${imageProvider}`, "Use openai, gemini, or grok"));
             }
             let elevenlabsApiKey;
             if (options.voiceover !== false) {
                 const key = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs");
                 if (!key) {
-                    console.error(chalk.red("ElevenLabs API key required for voiceover (or use --no-voiceover). Set ELEVENLABS_API_KEY in .env or run: vibe setup"));
-                    process.exit(1);
+                    exitWithError(authError("ELEVENLABS_API_KEY", "ElevenLabs"));
                 }
                 elevenlabsApiKey = key;
             }
             let videoApiKey;
             if (!options.imagesOnly) {
-                if (options.generator === "kling") {
-                    const key = await getApiKey("KLING_API_KEY", "Kling");
-                    if (!key) {
-                        console.error(chalk.red("Kling API key required (or use --images-only). Set KLING_API_KEY in .env or run: vibe setup"));
-                        process.exit(1);
-                    }
-                    videoApiKey = key;
+                const generatorKeyMap = {
+                    grok: { envVar: "XAI_API_KEY", name: "xAI" },
+                    kling: { envVar: "KLING_API_KEY", name: "Kling" },
+                    runway: { envVar: "RUNWAY_API_SECRET", name: "Runway" },
+                    veo: { envVar: "GOOGLE_API_KEY", name: "Google" },
+                };
+                const generator = options.generator || "grok";
+                const genInfo = generatorKeyMap[generator];
+                if (!genInfo) {
+                    exitWithError(usageError(`Invalid generator: ${generator}`, `Available: ${Object.keys(generatorKeyMap).join(", ")}`));
                 }
-                else {
-                    const key = await getApiKey("RUNWAY_API_SECRET", "Runway");
-                    if (!key) {
-                        console.error(chalk.red("Runway API key required (or use --images-only). Set RUNWAY_API_SECRET in .env or run: vibe setup"));
-                        process.exit(1);
-                    }
-                    videoApiKey = key;
+                const key = await getApiKey(genInfo.envVar, genInfo.name);
+                if (!key) {
+                    exitWithError(authError(genInfo.envVar, genInfo.name));
                 }
+                videoApiKey = key;
             }
             // Read script content
             let scriptContent = script;
@@ -155,8 +176,7 @@ export function registerScriptPipelineCommands(aiCommand) {
             // Validate creativity level
             const creativity = options.creativity?.toLowerCase();
             if (creativity && creativity !== "low" && creativity !== "high") {
-                console.error(chalk.red("Invalid creativity level. Use 'low' or 'high'."));
-                process.exit(1);
+                exitWithError(usageError("Invalid creativity level.", "Use 'low' or 'high'."));
             }
             console.log();
             console.log(chalk.bold.cyan("🎬 Script-to-Video Pipeline"));
@@ -190,8 +210,8 @@ export function registerScriptPipelineCommands(aiCommand) {
                 segments = await claude.analyzeContent(scriptContent, durationOpt, creativityOpts);
             }
             if (segments.length === 0) {
-                storyboardSpinner.fail(chalk.red("Failed to generate storyboard (check API key and error above)"));
-                process.exit(1);
+                storyboardSpinner.fail("Failed to generate storyboard");
+                exitWithError(apiError("Failed to generate storyboard (check API key and error above)", true));
             }
             let totalDuration = segments.reduce((sum, seg) => sum + seg.duration, 0);
             storyboardSpinner.succeed(chalk.green(`Generated ${segments.length} scenes (total: ${totalDuration}s)`));
@@ -447,8 +467,8 @@ export function registerScriptPipelineCommands(aiCommand) {
                     const kling = new KlingProvider();
                     await kling.initialize({ apiKey: videoApiKey });
                     if (!kling.isConfigured()) {
-                        videoSpinner.fail(chalk.red("Invalid Kling API key format. Use ACCESS_KEY:SECRET_KEY"));
-                        process.exit(1);
+                        videoSpinner.fail("Invalid Kling API key format");
+                        exitWithError(authError("KLING_API_KEY", "Kling"));
                     }
                     // Check for ImgBB API key for image-to-video support (from config or env)
                     const imgbbApiKey = await getApiKeyFromConfig("imgbb") || process.env.IMGBB_API_KEY;
@@ -1000,9 +1020,7 @@ export function registerScriptPipelineCommands(aiCommand) {
             console.log();
         }
         catch (error) {
-            console.error(chalk.red("Script-to-Video failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(generalError(error instanceof Error ? error.message : "Script-to-Video failed"));
         }
     });
     // Regenerate Scene command
@@ -1014,12 +1032,13 @@ export function registerScriptPipelineCommands(aiCommand) {
         .option("--video-only", "Only regenerate video")
         .option("--narration-only", "Only regenerate narration")
         .option("--image-only", "Only regenerate image")
-        .option("-g, --generator <engine>", "Video generator: kling | runway | veo", "kling")
+        .option("-g, --generator <engine>", "Video generator: grok | kling | runway | veo", "grok")
         .option("-i, --image-provider <provider>", "Image provider: gemini | openai | grok", "gemini")
         .option("-v, --voice <id>", "ElevenLabs voice ID for narration")
         .option("-a, --aspect-ratio <ratio>", "Aspect ratio: 16:9 | 9:16 | 1:1", "16:9")
         .option("--retries <count>", "Number of retries for video generation failures", String(DEFAULT_VIDEO_RETRIES))
         .option("--reference-scene <num>", "Use another scene's image as reference for character consistency")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (projectDir, options) => {
         try {
             const outputDir = resolve(process.cwd(), projectDir);
@@ -1027,19 +1046,34 @@ export function registerScriptPipelineCommands(aiCommand) {
             const projectPath = resolve(outputDir, "project.vibe.json");
             // Validate project directory
             if (!existsSync(outputDir)) {
-                console.error(chalk.red(`Project directory not found: ${outputDir}`));
-                process.exit(1);
+                exitWithError(notFoundError(outputDir));
             }
             if (!existsSync(storyboardPath)) {
-                console.error(chalk.red(`Storyboard not found: ${storyboardPath}`));
-                console.error(chalk.dim("This command requires a storyboard.json file from script-to-video output"));
-                process.exit(1);
+                exitWithError(notFoundError(storyboardPath));
             }
             // Parse scene number(s) - supports "3" or "3,4,5"
             const sceneNums = options.scene.split(",").map((s) => parseInt(s.trim())).filter((n) => !isNaN(n) && n >= 1);
             if (sceneNums.length === 0) {
-                console.error(chalk.red("Scene number must be a positive integer (1-based), e.g., --scene 3 or --scene 3,4,5"));
-                process.exit(1);
+                exitWithError(usageError("Scene number must be a positive integer (1-based)", "e.g., --scene 3 or --scene 3,4,5"));
+            }
+            if (options.dryRun) {
+                outputResult({
+                    dryRun: true,
+                    command: "pipeline regenerate-scene",
+                    params: {
+                        projectDir,
+                        scene: sceneNums,
+                        videoOnly: options.videoOnly ?? false,
+                        narrationOnly: options.narrationOnly ?? false,
+                        imageOnly: options.imageOnly ?? false,
+                        generator: options.generator,
+                        imageProvider: options.imageProvider,
+                        aspectRatio: options.aspectRatio,
+                        retries: options.retries,
+                        referenceScene: options.referenceScene,
+                    },
+                });
+                return;
             }
             // Load storyboard
             const storyboardContent = await readFile(storyboardPath, "utf-8");
@@ -1047,8 +1081,7 @@ export function registerScriptPipelineCommands(aiCommand) {
             // Validate all scene numbers
             for (const sceneNum of sceneNums) {
                 if (sceneNum > segments.length) {
-                    console.error(chalk.red(`Scene ${sceneNum} does not exist. Storyboard has ${segments.length} scenes.`));
-                    process.exit(1);
+                    exitWithError(usageError(`Scene ${sceneNum} does not exist. Storyboard has ${segments.length} scenes.`));
                 }
             }
             // Determine what to regenerate
@@ -1071,48 +1104,44 @@ export function registerScriptPipelineCommands(aiCommand) {
                 if (imageProvider === "openai" || imageProvider === "dalle") {
                     imageApiKey = (await getApiKey("OPENAI_API_KEY", "OpenAI")) ?? undefined;
                     if (!imageApiKey) {
-                        console.error(chalk.red("OpenAI API key required for image generation. Set OPENAI_API_KEY in .env or run: vibe setup"));
-                        process.exit(1);
+                        exitWithError(authError("OPENAI_API_KEY", "OpenAI"));
                     }
                 }
                 else if (imageProvider === "gemini") {
                     imageApiKey = (await getApiKey("GOOGLE_API_KEY", "Google")) ?? undefined;
                     if (!imageApiKey) {
-                        console.error(chalk.red("Google API key required for Gemini image generation. Set GOOGLE_API_KEY in .env or run: vibe setup"));
-                        process.exit(1);
+                        exitWithError(authError("GOOGLE_API_KEY", "Google"));
                     }
                 }
                 else if (imageProvider === "grok") {
                     imageApiKey = (await getApiKey("XAI_API_KEY", "xAI")) ?? undefined;
                     if (!imageApiKey) {
-                        console.error(chalk.red("xAI API key required for Grok image generation. Set XAI_API_KEY in .env or run: vibe setup"));
-                        process.exit(1);
+                        exitWithError(authError("XAI_API_KEY", "xAI"));
                     }
                 }
             }
             if (regenerateVideo) {
-                if (options.generator === "kling") {
-                    const key = await getApiKey("KLING_API_KEY", "Kling");
-                    if (!key) {
-                        console.error(chalk.red("Kling API key required. Set KLING_API_KEY in .env or run: vibe setup"));
-                        process.exit(1);
-                    }
-                    videoApiKey = key;
+                const generatorKeyMap = {
+                    grok: { envVar: "XAI_API_KEY", name: "xAI" },
+                    kling: { envVar: "KLING_API_KEY", name: "Kling" },
+                    runway: { envVar: "RUNWAY_API_SECRET", name: "Runway" },
+                    veo: { envVar: "GOOGLE_API_KEY", name: "Google" },
+                };
+                const generator = options.generator || "grok";
+                const genInfo = generatorKeyMap[generator];
+                if (!genInfo) {
+                    exitWithError(usageError(`Invalid generator: ${generator}`, `Available: ${Object.keys(generatorKeyMap).join(", ")}`));
                 }
-                else {
-                    const key = await getApiKey("RUNWAY_API_SECRET", "Runway");
-                    if (!key) {
-                        console.error(chalk.red("Runway API key required. Set RUNWAY_API_SECRET in .env or run: vibe setup"));
-                        process.exit(1);
-                    }
-                    videoApiKey = key;
+                const key = await getApiKey(genInfo.envVar, genInfo.name);
+                if (!key) {
+                    exitWithError(authError(genInfo.envVar, genInfo.name));
                 }
+                videoApiKey = key;
             }
             if (regenerateNarration) {
                 const key = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs");
                 if (!key) {
-                    console.error(chalk.red("ElevenLabs API key required for narration. Set ELEVENLABS_API_KEY in .env or run: vibe setup"));
-                    process.exit(1);
+                    exitWithError(authError("ELEVENLABS_API_KEY", "ElevenLabs"));
                 }
                 elevenlabsApiKey = key;
             }
@@ -1133,8 +1162,8 @@ export function registerScriptPipelineCommands(aiCommand) {
                         voiceId: options.voice,
                     });
                     if (!ttsResult.success || !ttsResult.audioBuffer) {
-                        ttsSpinner.fail(chalk.red(`Failed to generate narration: ${ttsResult.error || "Unknown error"}`));
-                        process.exit(1);
+                        ttsSpinner.fail(`Failed to generate narration: ${ttsResult.error || "Unknown error"}`);
+                        exitWithError(apiError(`Failed to generate narration: ${ttsResult.error || "Unknown error"}`, true));
                     }
                     await writeFile(narrationPath, ttsResult.audioBuffer);
                     narrationDuration = await getAudioDuration(narrationPath);
@@ -1286,8 +1315,8 @@ Generate the single-person scene image now.`;
                     }
                     else {
                         const errorMsg = imageError || "Unknown error";
-                        imageSpinner.fail(chalk.red(`Failed to generate image: ${errorMsg}`));
-                        process.exit(1);
+                        imageSpinner.fail(`Failed to generate image: ${errorMsg}`);
+                        exitWithError(apiError(`Failed to generate image: ${errorMsg}`, true));
                     }
                 }
                 // Step 3: Regenerate video if needed
@@ -1296,9 +1325,8 @@ Generate the single-person scene image now.`;
                     const videoSpinner = ora(`🎬 Regenerating video for scene ${sceneNum}...`).start();
                     // Check if image exists
                     if (!existsSync(imagePath)) {
-                        videoSpinner.fail(chalk.red(`Reference image not found: ${imagePath}`));
-                        console.error(chalk.dim("Generate an image first with --image-only or regenerate all assets"));
-                        process.exit(1);
+                        videoSpinner.fail(`Reference image not found: ${imagePath}`);
+                        exitWithError(notFoundError(imagePath));
                     }
                     const imageBuffer = await readFile(imagePath);
                     const ext = extname(imagePath).toLowerCase().slice(1);
@@ -1311,8 +1339,8 @@ Generate the single-person scene image now.`;
                         const kling = new KlingProvider();
                         await kling.initialize({ apiKey: videoApiKey });
                         if (!kling.isConfigured()) {
-                            videoSpinner.fail(chalk.red("Invalid Kling API key format. Use ACCESS_KEY:SECRET_KEY"));
-                            process.exit(1);
+                            videoSpinner.fail("Invalid Kling API key format");
+                            exitWithError(authError("KLING_API_KEY", "Kling"));
                         }
                         // Try to use image-to-video if ImgBB API key is available
                         const imgbbApiKey = await getApiKeyFromConfig("imgbb") || process.env.IMGBB_API_KEY;
@@ -1412,8 +1440,8 @@ Generate the single-person scene image now.`;
                         videoSpinner.succeed(chalk.green("Generated video"));
                     }
                     else {
-                        videoSpinner.fail(chalk.red("Failed to generate video after all retries"));
-                        process.exit(1);
+                        videoSpinner.fail("Failed to generate video after all retries");
+                        exitWithError(apiError("Failed to generate video after all retries", true));
                     }
                 }
                 // Step 4: Recalculate startTime for ALL segments and re-save storyboard
@@ -1485,9 +1513,7 @@ Generate the single-person scene image now.`;
             console.log();
         }
         catch (error) {
-            console.error(chalk.red("Scene regeneration failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(generalError(error instanceof Error ? error.message : "Scene regeneration failed"));
         }
     });
 }