@vibeframe/cli 0.27.0

package/dist/commands/ai-image.js

@@ -0,0 +1,653 @@
+/**
+ * @module ai-image
+ * @description Image generation and editing commands for the VibeFrame CLI.
+ *
+ * ## Commands: vibe ai image, vibe ai thumbnail, vibe ai background,
+ *             vibe ai gemini, vibe ai gemini-edit
+ * ## Dependencies: OpenAI, Gemini, FFmpeg
+ *
+ * Extracted from ai.ts as part of modularisation.
+ * ai.ts calls registerImageCommands(aiCommand).
+ * @see MODELS.md for AI model configuration
+ */
+import { resolve, dirname, basename, extname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import chalk from 'chalk';
+import ora from 'ora';
+import { GeminiProvider, OpenAIImageProvider, } from '@vibeframe/ai-providers';
+import { getApiKey } from '../utils/api-key.js';
+import { execSafe, commandExists } from '../utils/exec-safe.js';
+function _registerImageCommands(aiCommand) {
+    aiCommand
+        .command("image")
+        .description("Generate image using AI (Gemini or DALL-E)")
+        .argument("<prompt>", "Image description prompt")
+        .option("-p, --provider <provider>", "Provider: gemini, openai, runway (dalle is deprecated)", "gemini")
+        .option("-k, --api-key <key>", "API key (or set env: OPENAI_API_KEY, GOOGLE_API_KEY)")
+        .option("-o, --output <path>", "Output file path (downloads image)")
+        .option("-s, --size <size>", "Image size (openai: 1024x1024, 1536x1024, 1024x1536)", "1024x1024")
+        .option("-r, --ratio <ratio>", "Aspect ratio (gemini: 1:1, 1:4, 1:8, 4:1, 8:1, 16:9, 9:16, 3:4, 4:3, etc.)", "1:1")
+        .option("-q, --quality <quality>", "Quality: standard, hd (openai only)", "standard")
+        .option("--style <style>", "Style: vivid, natural (openai only)", "vivid")
+        .option("-n, --count <n>", "Number of images to generate", "1")
+        .option("-m, --model <model>", "Gemini model: flash, 3.1-flash, latest (Nano Banana 2), pro (4K)")
+        .action(async (prompt, options) => {
+        try {
+            const provider = options.provider.toLowerCase();
+            const validProviders = ["openai", "dalle", "gemini", "runway"];
+            if (!validProviders.includes(provider)) {
+                console.error(chalk.red(`Invalid provider: ${provider}`));
+                console.error(chalk.dim(`Available providers: openai, gemini, runway`));
+                process.exit(1);
+            }
+            // Show deprecation warning for "dalle"
+            if (provider === "dalle") {
+                console.log(chalk.yellow('Warning: "dalle" is deprecated. Use "openai" instead.'));
+            }
+            // Get API key based on provider
+            const envKeyMap = {
+                openai: "OPENAI_API_KEY",
+                dalle: "OPENAI_API_KEY", // backward compatibility
+                gemini: "GOOGLE_API_KEY",
+                runway: "RUNWAY_API_SECRET",
+            };
+            const providerNameMap = {
+                openai: "OpenAI",
+                dalle: "OpenAI", // backward compatibility
+                gemini: "Google",
+                runway: "Runway",
+            };
+            const envKey = envKeyMap[provider];
+            const providerName = providerNameMap[provider];
+            const apiKey = await getApiKey(envKey, providerName, options.apiKey);
+            if (!apiKey) {
+                console.error(chalk.red(`${providerName} API key required. Set ${envKey} in .env or run: vibe setup`));
+                console.error(chalk.dim(`Use --api-key or set ${envKey} environment variable`));
+                process.exit(1);
+            }
+            const spinner = ora(`Generating image with ${providerName}...`).start();
+            if (provider === "dalle" || provider === "openai") {
+                const openaiImage = new OpenAIImageProvider();
+                await openaiImage.initialize({ apiKey });
+                const result = await openaiImage.generateImage(prompt, {
+                    size: options.size,
+                    quality: options.quality,
+                    style: options.style,
+                    n: parseInt(options.count),
+                });
+                if (!result.success || !result.images) {
+                    spinner.fail(chalk.red(result.error || "Image generation failed"));
+                    process.exit(1);
+                }
+                spinner.succeed(chalk.green(`Generated ${result.images.length} image(s) with OpenAI GPT Image 1.5`));
+                console.log();
+                console.log(chalk.bold.cyan("Generated Images"));
+                console.log(chalk.dim("─".repeat(60)));
+                for (let i = 0; i < result.images.length; i++) {
+                    const img = result.images[i];
+                    console.log();
+                    if (img.url) {
+                        console.log(`${chalk.yellow(`[${i + 1}]`)} ${img.url}`);
+                    }
+                    else if (img.base64) {
+                        console.log(`${chalk.yellow(`[${i + 1}]`)} (base64 image data)`);
+                    }
+                    if (img.revisedPrompt) {
+                        console.log(chalk.dim(`    Revised: ${img.revisedPrompt.slice(0, 100)}...`));
+                    }
+                }
+                console.log();
+                // Save if output specified
+                if (options.output && result.images.length > 0) {
+                    const img = result.images[0];
+                    const saveSpinner = ora("Saving image...").start();
+                    try {
+                        let buffer;
+                        if (img.url) {
+                            // Download from URL
+                            const response = await fetch(img.url);
+                            buffer = Buffer.from(await response.arrayBuffer());
+                        }
+                        else if (img.base64) {
+                            // Decode base64
+                            buffer = Buffer.from(img.base64, "base64");
+                        }
+                        else {
+                            throw new Error("No image data available");
+                        }
+                        const outputPath = resolve(process.cwd(), options.output);
+                        await mkdir(dirname(outputPath), { recursive: true });
+                        await writeFile(outputPath, buffer);
+                        saveSpinner.succeed(chalk.green(`Saved to: ${outputPath}`));
+                    }
+                    catch (err) {
+                        saveSpinner.fail(chalk.red(`Failed to save image: ${err instanceof Error ? err.message : err}`));
+                    }
+                }
+            }
+            else if (provider === "gemini") {
+                // Validate model name
+                const validGeminiModels = ["flash", "3.1-flash", "latest", "pro"];
+                if (options.model && !validGeminiModels.includes(options.model)) {
+                    console.warn(chalk.yellow(`Unknown model "${options.model}", using flash. Valid: ${validGeminiModels.join(", ")}`));
+                    options.model = "flash";
+                }
+                // Validate aspect ratio
+                const validRatios = ["1:1", "1:4", "1:8", "2:3", "3:2", "3:4", "4:1", "4:3", "4:5", "5:4", "8:1", "9:16", "16:9", "21:9"];
+                if (options.ratio && !validRatios.includes(options.ratio)) {
+                    console.error(chalk.red(`Invalid ratio "${options.ratio}". Valid: ${validRatios.join(", ")}`));
+                    process.exit(1);
+                }
+                const gemini = new GeminiProvider();
+                await gemini.initialize({ apiKey });
+                const geminiModelNames = {
+                    flash: "Nano Banana",
+                    "3.1-flash": "Nano Banana 2",
+                    latest: "Nano Banana 2",
+                    pro: "Nano Banana Pro",
+                };
+                const modelLabel = geminiModelNames[options.model] || "Nano Banana";
+                let result = await gemini.generateImage(prompt, {
+                    model: options.model,
+                    aspectRatio: options.ratio,
+                });
+                // Auto-fallback: if latest/3.1-flash fails, retry with flash
+                let usedLabel = modelLabel;
+                const fallbackModels = ["latest", "3.1-flash"];
+                if (!result.success && options.model && fallbackModels.includes(options.model)) {
+                    spinner.text = `${chalk.dim(result.error || "Failed")} — retrying with Nano Banana (flash)...`;
+                    result = await gemini.generateImage(prompt, {
+                        model: "flash",
+                        aspectRatio: options.ratio,
+                    });
+                    usedLabel = "Nano Banana (fallback)";
+                }
+                if (!result.success || !result.images) {
+                    spinner.fail(chalk.red(result.error || "Image generation failed"));
+                    process.exit(1);
+                }
+                spinner.succeed(chalk.green(`Generated ${result.images.length} image(s) with Gemini (${usedLabel})`));
+                console.log();
+                console.log(chalk.bold.cyan("Generated Images"));
+                console.log(chalk.dim("─".repeat(60)));
+                // Gemini returns base64, we need to save or display
+                for (let i = 0; i < result.images.length; i++) {
+                    const img = result.images[i];
+                    console.log();
+                    console.log(`${chalk.yellow(`[${i + 1}]`)} (base64 image, ${img.mimeType})`);
+                }
+                console.log();
+                // Save if output specified
+                if (options.output && result.images.length > 0) {
+                    const saveSpinner = ora("Saving image...").start();
+                    try {
+                        const img = result.images[0];
+                        const buffer = Buffer.from(img.base64, "base64");
+                        const outputPath = resolve(process.cwd(), options.output);
+                        await mkdir(dirname(outputPath), { recursive: true });
+                        await writeFile(outputPath, buffer);
+                        saveSpinner.succeed(chalk.green(`Saved to: ${outputPath}`));
+                    }
+                    catch (err) {
+                        saveSpinner.fail(chalk.red(`Failed to save image: ${err instanceof Error ? err.message : err}`));
+                    }
+                }
+                else {
+                    console.log(chalk.yellow("Use -o to save the generated image to a file"));
+                }
+            }
+            else if (provider === "runway") {
+                // Use Runway's Gemini model for text-to-image (no reference needed)
+                const { spawn } = await import("child_process");
+                const __filename = fileURLToPath(import.meta.url);
+                const __dirname = dirname(__filename);
+                const scriptPath = resolve(__dirname, "../../../../.claude/skills/runway-video/scripts/image.py");
+                if (!options.output) {
+                    spinner.fail(chalk.red("Output path required for Runway. Use -o option."));
+                    process.exit(1);
+                }
+                const outputPath = resolve(process.cwd(), options.output);
+                const args = [scriptPath, prompt, "-o", outputPath, "-r", options.ratio || "16:9"];
+                spinner.text = "Generating image with Runway (gemini_2.5_flash)...";
+                await new Promise((resolvePromise, reject) => {
+                    const proc = spawn("python3", args, {
+                        env: { ...process.env, RUNWAY_API_SECRET: apiKey },
+                        stdio: ["ignore", "pipe", "pipe"],
+                    });
+                    let stdout = "";
+                    let stderr = "";
+                    proc.stdout.on("data", (data) => {
+                        stdout += data.toString();
+                    });
+                    proc.stderr.on("data", (data) => {
+                        stderr += data.toString();
+                    });
+                    proc.on("close", (code) => {
+                        if (code === 0) {
+                            spinner.succeed(chalk.green("Generated image with Runway"));
+                            console.log(chalk.dim(stdout.trim()));
+                            resolvePromise();
+                        }
+                        else {
+                            spinner.fail(chalk.red("Runway image generation failed"));
+                            console.error(chalk.red(stderr || stdout));
+                            reject(new Error("Runway generation failed"));
+                        }
+                    });
+                    proc.on("error", (err) => {
+                        spinner.fail(chalk.red("Failed to run Runway script"));
+                        reject(err);
+                    });
+                });
+            }
+        }
+        catch (error) {
+            console.error(chalk.red("Image generation failed"));
+            console.error(error);
+            process.exit(1);
+        }
+    });
+    aiCommand
+        .command("thumbnail")
+        .description("Generate video thumbnail (DALL-E) or extract best frame from video (Gemini)")
+        .argument("[description]", "Thumbnail description (for DALL-E generation)")
+        .option("-k, --api-key <key>", "API key (OpenAI for generation, Google for best-frame)")
+        .option("-o, --output <path>", "Output file path")
+        .option("-s, --style <style>", "Platform style: youtube, instagram, tiktok, twitter")
+        .option("--best-frame <video>", "Extract best thumbnail frame from video using Gemini AI")
+        .option("--prompt <prompt>", "Custom prompt for best-frame analysis")
+        .option("--model <model>", "Gemini model: flash, latest, pro (default: flash)", "flash")
+        .action(async (description, options) => {
+        try {
+            // Best-frame mode: analyze video with Gemini and extract frame
+            if (options.bestFrame) {
+                const absVideoPath = resolve(process.cwd(), options.bestFrame);
+                if (!existsSync(absVideoPath)) {
+                    console.error(chalk.red(`Video not found: ${absVideoPath}`));
+                    process.exit(1);
+                }
+                if (!commandExists("ffmpeg")) {
+                    console.error(chalk.red("FFmpeg not found. Please install FFmpeg."));
+                    process.exit(1);
+                }
+                const apiKey = await getApiKey("GOOGLE_API_KEY", "Google", options.apiKey);
+                if (!apiKey) {
+                    console.error(chalk.red("Google API key required for Gemini video analysis. Set GOOGLE_API_KEY in .env or run: vibe setup"));
+                    console.error(chalk.dim("Use --api-key or set GOOGLE_API_KEY"));
+                    process.exit(1);
+                }
+                const name = basename(options.bestFrame, extname(options.bestFrame));
+                const outputPath = options.output || `${name}-thumbnail.png`;
+                const spinner = ora("Analyzing video for best frame...").start();
+                const result = await executeThumbnailBestFrame({
+                    videoPath: absVideoPath,
+                    outputPath: resolve(process.cwd(), outputPath),
+                    prompt: options.prompt,
+                    model: options.model,
+                    apiKey,
+                });
+                if (!result.success) {
+                    spinner.fail(chalk.red(result.error || "Best frame extraction failed"));
+                    process.exit(1);
+                }
+                spinner.succeed(chalk.green("Best frame extracted"));
+                console.log();
+                console.log(chalk.bold.cyan("Best Frame Result"));
+                console.log(chalk.dim("─".repeat(60)));
+                console.log(`Timestamp: ${chalk.bold(result.timestamp.toFixed(2))}s`);
+                if (result.reason)
+                    console.log(`Reason: ${chalk.dim(result.reason)}`);
+                console.log(`Output: ${chalk.green(result.outputPath)}`);
+                console.log();
+                return;
+            }
+            // Generation mode: create thumbnail with DALL-E
+            if (!description) {
+                console.error(chalk.red("Description required for thumbnail generation."));
+                console.error(chalk.dim("Usage: vibe ai thumbnail <description> or vibe ai thumbnail --best-frame <video>"));
+                process.exit(1);
+            }
+            const apiKey = await getApiKey("OPENAI_API_KEY", "OpenAI", options.apiKey);
+            if (!apiKey) {
+                console.error(chalk.red("OpenAI API key required. Set OPENAI_API_KEY in .env or run: vibe setup"));
+                process.exit(1);
+            }
+            const spinner = ora("Generating thumbnail...").start();
+            const openaiImage = new OpenAIImageProvider();
+            await openaiImage.initialize({ apiKey });
+            const result = await openaiImage.generateThumbnail(description, options.style);
+            if (!result.success || !result.images) {
+                spinner.fail(chalk.red(result.error || "Thumbnail generation failed"));
+                process.exit(1);
+            }
+            spinner.succeed(chalk.green("Thumbnail generated"));
+            const img = result.images[0];
+            console.log();
+            console.log(chalk.bold.cyan("Generated Thumbnail"));
+            console.log(chalk.dim("─".repeat(60)));
+            console.log(`URL: ${img.url}`);
+            if (img.revisedPrompt) {
+                console.log(chalk.dim(`Prompt: ${img.revisedPrompt.slice(0, 100)}...`));
+            }
+            console.log();
+            // Save if output specified
+            if (options.output) {
+                const saveSpinner = ora("Saving thumbnail...").start();
+                try {
+                    let buffer;
+                    if (img.url) {
+                        const response = await fetch(img.url);
+                        buffer = Buffer.from(await response.arrayBuffer());
+                    }
+                    else if (img.base64) {
+                        buffer = Buffer.from(img.base64, "base64");
+                    }
+                    else {
+                        throw new Error("No image data available");
+                    }
+                    const outputPath = resolve(process.cwd(), options.output);
+                    await mkdir(dirname(outputPath), { recursive: true });
+                    await writeFile(outputPath, buffer);
+                    saveSpinner.succeed(chalk.green(`Saved to: ${outputPath}`));
+                }
+                catch (err) {
+                    saveSpinner.fail(chalk.red("Failed to save thumbnail"));
+                }
+            }
+        }
+        catch (error) {
+            console.error(chalk.red("Thumbnail generation failed"));
+            console.error(error);
+            process.exit(1);
+        }
+    });
+    aiCommand
+        .command("background")
+        .description("Generate video background using DALL-E")
+        .argument("<description>", "Background description")
+        .option("-k, --api-key <key>", "OpenAI API key (or set OPENAI_API_KEY env)")
+        .option("-o, --output <path>", "Output file path (downloads image)")
+        .option("-a, --aspect <ratio>", "Aspect ratio: 16:9, 9:16, 1:1", "16:9")
+        .action(async (description, options) => {
+        try {
+            const apiKey = await getApiKey("OPENAI_API_KEY", "OpenAI", options.apiKey);
+            if (!apiKey) {
+                console.error(chalk.red("OpenAI API key required. Set OPENAI_API_KEY in .env or run: vibe setup"));
+                process.exit(1);
+            }
+            const spinner = ora("Generating background...").start();
+            const openaiImage = new OpenAIImageProvider();
+            await openaiImage.initialize({ apiKey });
+            const result = await openaiImage.generateBackground(description, options.aspect);
+            if (!result.success || !result.images) {
+                spinner.fail(chalk.red(result.error || "Background generation failed"));
+                process.exit(1);
+            }
+            spinner.succeed(chalk.green("Background generated"));
+            const img = result.images[0];
+            console.log();
+            console.log(chalk.bold.cyan("Generated Background"));
+            console.log(chalk.dim("─".repeat(60)));
+            console.log(`Image: ${img.url || "(base64 data)"}`);
+            if (img.revisedPrompt) {
+                console.log(chalk.dim(`Prompt: ${img.revisedPrompt.slice(0, 100)}...`));
+            }
+            console.log();
+            // Save if output specified
+            if (options.output) {
+                const saveSpinner = ora("Saving background...").start();
+                try {
+                    let buffer;
+                    if (img.url) {
+                        const response = await fetch(img.url);
+                        buffer = Buffer.from(await response.arrayBuffer());
+                    }
+                    else if (img.base64) {
+                        buffer = Buffer.from(img.base64, "base64");
+                    }
+                    else {
+                        throw new Error("No image data available");
+                    }
+                    const outputPath = resolve(process.cwd(), options.output);
+                    await mkdir(dirname(outputPath), { recursive: true });
+                    await writeFile(outputPath, buffer);
+                    saveSpinner.succeed(chalk.green(`Saved to: ${outputPath}`));
+                }
+                catch (err) {
+                    saveSpinner.fail(chalk.red("Failed to save background"));
+                }
+            }
+        }
+        catch (error) {
+            console.error(chalk.red("Background generation failed"));
+            console.error(error);
+            process.exit(1);
+        }
+    });
+    // Gemini (Nano Banana) commands
+    aiCommand
+        .command("gemini")
+        .description("Generate image using Gemini (Nano Banana)")
+        .argument("<prompt>", "Text prompt describing the image")
+        .option("-k, --api-key <key>", "Google API key (or set GOOGLE_API_KEY env)")
+        .option("-o, --output <path>", "Output file path", "output.png")
+        .option("-m, --model <model>", "Model: flash (fast), 3.1-flash / latest (Nano Banana 2), pro (professional, 4K)", "flash")
+        .option("-r, --ratio <ratio>", "Aspect ratio: 1:1, 1:4, 1:8, 4:1, 8:1, 16:9, 9:16, 4:3, 3:4, 21:9, etc.", "1:1")
+        .option("-s, --size <resolution>", "Resolution: 512px, 1K, 2K, 4K")
+        .option("--grounding", "Enable Google Search grounding (Pro only)")
+        .option("--thinking <level>", "Enable thinking mode: minimal or high")
+        .option("--image-search", "Enable Image Search grounding (3.1 Flash only)")
+        .action(async (prompt, options) => {
+        try {
+            const apiKey = await getApiKey("GOOGLE_API_KEY", "Google", options.apiKey);
+            if (!apiKey) {
+                console.error(chalk.red("Google API key required. Set GOOGLE_API_KEY in .env or run: vibe setup"));
+                console.error(chalk.dim("Use --api-key or set GOOGLE_API_KEY environment variable"));
+                process.exit(1);
+            }
+            const modelNames = {
+                flash: "gemini-2.5-flash-image",
+                "3.1-flash": "gemini-3.1-flash-image-preview",
+                latest: "gemini-3.1-flash-image-preview",
+                pro: "gemini-3-pro-image-preview",
+            };
+            const modelName = modelNames[options.model] || modelNames.flash;
+            const spinner = ora(`Generating image with ${modelName}...`).start();
+            const gemini = new GeminiProvider();
+            await gemini.initialize({ apiKey });
+            let result = await gemini.generateImage(prompt, {
+                model: options.model,
+                aspectRatio: options.ratio,
+                resolution: options.size,
+                grounding: options.grounding,
+                thinkingConfig: options.thinking ? { thinkingLevel: options.thinking } : undefined,
+                imageSearchGrounding: options.imageSearch,
+            });
+            // Auto-fallback: if latest/3.1-flash fails, retry with flash
+            const fallbackModels = ["latest", "3.1-flash"];
+            if (!result.success && fallbackModels.includes(options.model)) {
+                spinner.text = `${chalk.dim(result.error || `${modelName} failed`)} — retrying with flash...`;
+                result = await gemini.generateImage(prompt, {
+                    model: "flash",
+                    aspectRatio: options.ratio,
+                    resolution: options.size,
+                });
+            }
+            if (!result.success || !result.images || result.images.length === 0) {
+                spinner.fail(chalk.red(result.error || "Image generation failed"));
+                process.exit(1);
+            }
+            spinner.succeed(chalk.green("Image generated"));
+            if (result.model) {
+                console.log(chalk.dim(`Model: ${result.model}`));
+            }
+            const img = result.images[0];
+            if (img.base64) {
+                const outputPath = resolve(process.cwd(), options.output);
+                await mkdir(dirname(outputPath), { recursive: true });
+                const buffer = Buffer.from(img.base64, "base64");
+                await writeFile(outputPath, buffer);
+                console.log(chalk.green(`Saved to: ${outputPath}`));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red("Image generation failed"));
+            console.error(error);
+            process.exit(1);
+        }
+    });
+    aiCommand
+        .command("gemini-edit")
+        .description("Edit image(s) using Gemini (Nano Banana)")
+        .argument("<images...>", "Input image file(s) followed by edit prompt")
+        .option("-k, --api-key <key>", "Google API key (or set GOOGLE_API_KEY env)")
+        .option("-o, --output <path>", "Output file path", "edited.png")
+        .option("-m, --model <model>", "Model: flash (max 3 images), 3.1-flash / latest (max 3 images), pro (max 14 images)", "flash")
+        .option("-r, --ratio <ratio>", "Output aspect ratio")
+        .option("-s, --size <resolution>", "Resolution: 1K, 2K, 4K (Pro model only)")
+        .action(async (args, options) => {
+        try {
+            // Last argument is the prompt, rest are image paths
+            if (args.length < 2) {
+                console.error(chalk.red("Need at least one image and a prompt"));
+                process.exit(1);
+            }
+            const prompt = args[args.length - 1];
+            const imagePaths = args.slice(0, -1);
+            const apiKey = await getApiKey("GOOGLE_API_KEY", "Google", options.apiKey);
+            if (!apiKey) {
+                console.error(chalk.red("Google API key required. Set GOOGLE_API_KEY in .env or run: vibe setup"));
+                process.exit(1);
+            }
+            const spinner = ora(`Reading ${imagePaths.length} image(s)...`).start();
+            // Load all images
+            const imageBuffers = [];
+            for (const imagePath of imagePaths) {
+                const absPath = resolve(process.cwd(), imagePath);
+                const buffer = await readFile(absPath);
+                imageBuffers.push(buffer);
+            }
+            const editModelNames = {
+                flash: "gemini-2.5-flash-image",
+                "3.1-flash": "gemini-3.1-flash-image-preview",
+                latest: "gemini-3.1-flash-image-preview",
+                pro: "gemini-3-pro-image-preview",
+            };
+            const editModelName = editModelNames[options.model] || editModelNames.flash;
+            spinner.text = `Editing with ${editModelName}...`;
+            const gemini = new GeminiProvider();
+            await gemini.initialize({ apiKey });
+            let result = await gemini.editImage(imageBuffers, prompt, {
+                model: options.model,
+                aspectRatio: options.ratio,
+                resolution: options.size,
+            });
+            // Auto-fallback: if latest/3.1-flash fails, retry with flash
+            const fallbackModels = ["latest", "3.1-flash"];
+            if (!result.success && fallbackModels.includes(options.model)) {
+                spinner.text = `${chalk.dim(result.error || `${editModelName} failed`)} — retrying with flash...`;
+                result = await gemini.editImage(imageBuffers, prompt, {
+                    model: "flash",
+                    aspectRatio: options.ratio,
+                    resolution: options.size,
+                });
+            }
+            if (!result.success || !result.images || result.images.length === 0) {
+                spinner.fail(chalk.red(result.error || "Image editing failed"));
+                process.exit(1);
+            }
+            spinner.succeed(chalk.green("Image edited"));
+            if (result.model) {
+                console.log(chalk.dim(`Model: ${result.model}`));
+            }
+            const img = result.images[0];
+            if (img.base64) {
+                const outputPath = resolve(process.cwd(), options.output);
+                await mkdir(dirname(outputPath), { recursive: true });
+                const buffer = Buffer.from(img.base64, "base64");
+                await writeFile(outputPath, buffer);
+                console.log(chalk.green(`Saved to: ${outputPath}`));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red("Image editing failed"));
+            console.error(error);
+            process.exit(1);
+        }
+    });
+}
+export async function executeThumbnailBestFrame(options) {
+    const { videoPath, outputPath, prompt, model = "flash", 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 googleKey = apiKey || process.env.GOOGLE_API_KEY;
+    if (!googleKey) {
+        return { success: false, error: "Google API key required for Gemini video analysis. Run 'vibe setup' or set GOOGLE_API_KEY in .env" };
+    }
+    try {
+        const gemini = new GeminiProvider();
+        await gemini.initialize({ apiKey: googleKey });
+        const videoData = await readFile(videoPath);
+        const analysisPrompt = prompt ||
+            "Analyze this video and find the single best frame for a thumbnail. " +
+                "Look for frames that are visually striking, well-composed, emotionally engaging, " +
+                "and representative of the video content. Avoid blurry frames, transitions, or dark scenes. " +
+                "Return ONLY a JSON object: {\"timestamp\": <seconds as number>, \"reason\": \"<brief explanation>\"}";
+        const modelMap = {
+            flash: "gemini-3-flash-preview",
+            latest: "gemini-2.5-flash",
+            "flash-2.5": "gemini-2.5-flash", // backward compat
+            pro: "gemini-2.5-pro",
+        };
+        const modelId = modelMap[model] || "gemini-3-flash-preview";
+        const result = await gemini.analyzeVideo(videoData, analysisPrompt, {
+            model: modelId,
+            fps: 1,
+        });
+        if (!result.success || !result.response) {
+            return { success: false, error: result.error || "Gemini analysis failed" };
+        }
+        // Parse timestamp from response
+        const jsonMatch = result.response.match(/\{[\s\S]*?"timestamp"\s*:\s*([\d.]+)[\s\S]*?\}/);
+        if (!jsonMatch) {
+            return { success: false, error: `Could not parse timestamp from Gemini response: ${result.response.slice(0, 200)}` };
+        }
+        const timestamp = parseFloat(jsonMatch[1]);
+        let reason;
+        const reasonMatch = result.response.match(/"reason"\s*:\s*"([^"]+)"/);
+        if (reasonMatch) {
+            reason = reasonMatch[1];
+        }
+        // Extract frame with FFmpeg
+        await execSafe("ffmpeg", ["-ss", String(timestamp), "-i", videoPath, "-frames:v", "1", "-q:v", "2", outputPath, "-y"], { timeout: 60000, maxBuffer: 50 * 1024 * 1024 });
+        if (!existsSync(outputPath)) {
+            return { success: false, error: "FFmpeg failed to extract frame" };
+        }
+        return {
+            success: true,
+            outputPath,
+            timestamp,
+            reason,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Best frame extraction failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+/**
+ * Register all image sub-commands on the given parent command.
+ * Called from ai.ts: registerImageCommands(aiCommand)
+ */
+export function registerImageCommands(aiCommand) {
+    _registerImageCommands(aiCommand);
+}
+//# sourceMappingURL=ai-image.js.map