@vibeframe/cli 0.31.1 → 0.33.1

package/dist/commands/ai-audio.js

@@ -21,6 +21,8 @@ import { getApiKey } from '../utils/api-key.js';
 import { execSafe, execSafeSync, commandExists } from '../utils/exec-safe.js';
 import { detectFormat, formatTranscript } from '../utils/subtitle.js';
 import { formatTime } from './ai-helpers.js';
+import { exitWithError, authError, notFoundError, apiError, usageError, generalError, outputResult } from './output.js';
+import { validateOutputPath } from "./validate.js";
 function _registerAudioCommands(aiCommand) {
     aiCommand
         .command("transcribe")
@@ -30,12 +32,19 @@ function _registerAudioCommands(aiCommand) {
         .option("-l, --language <lang>", "Language code (e.g., en, ko)")
         .option("-o, --output <path>", "Output file path")
         .option("-f, --format <format>", "Output format: json, srt, vtt (auto-detected from extension)")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (audioPath, options) => {
         try {
+            if (options.output) {
+                validateOutputPath(options.output);
+            }
+            if (options.dryRun) {
+                outputResult({ dryRun: true, command: "ai transcribe", params: { audio: audioPath, output: options.output, language: options.language, format: options.format } });
+                return;
+            }
             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);
+                exitWithError(authError("OPENAI_API_KEY", "OpenAI"));
             }
             const spinner = ora("Initializing Whisper...").start();
             const whisper = new WhisperProvider();
@@ -47,8 +56,8 @@ function _registerAudioCommands(aiCommand) {
             spinner.text = "Transcribing...";
             const result = await whisper.transcribe(audioBlob, options.language);
             if (result.status === "failed") {
-                spinner.fail(chalk.red(`Transcription failed: ${result.error}`));
-                process.exit(1);
+                spinner.fail("Transcription failed");
+                exitWithError(apiError(`Transcription failed: ${result.error}`, true));
             }
             spinner.succeed(chalk.green("Transcription complete"));
             console.log();
@@ -74,9 +83,7 @@ function _registerAudioCommands(aiCommand) {
             }
         }
         catch (error) {
-            console.error(chalk.red("Transcription failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(apiError(`Transcription failed: ${error instanceof Error ? error.message : String(error)}`, true));
         }
     });
     aiCommand
@@ -87,12 +94,19 @@ function _registerAudioCommands(aiCommand) {
         .option("-o, --output <path>", "Output audio file path", "output.mp3")
         .option("-v, --voice <id>", "Voice ID (default: Rachel)", "21m00Tcm4TlvDq8ikWAM")
         .option("--list-voices", "List available voices")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (text, options) => {
         try {
+            if (options.output) {
+                validateOutputPath(options.output);
+            }
+            if (options.dryRun) {
+                outputResult({ dryRun: true, command: "ai tts", params: { text, output: options.output, voice: options.voice } });
+                return;
+            }
             const apiKey = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs", options.apiKey);
             if (!apiKey) {
-                console.error(chalk.red("ElevenLabs API key required. Set ELEVENLABS_API_KEY in .env or run: vibe setup"));
-                process.exit(1);
+                exitWithError(authError("ELEVENLABS_API_KEY", "ElevenLabs"));
             }
             const elevenlabs = new ElevenLabsProvider();
             await elevenlabs.initialize({ apiKey });
@@ -123,8 +137,8 @@ function _registerAudioCommands(aiCommand) {
                 voiceId: options.voice,
             });
             if (!result.success || !result.audioBuffer) {
-                spinner.fail(chalk.red(result.error || "TTS generation failed"));
-                process.exit(1);
+                spinner.fail("TTS generation failed");
+                exitWithError(apiError(result.error || "TTS generation failed", true));
             }
             const outputPath = resolve(process.cwd(), options.output);
             await writeFile(outputPath, result.audioBuffer);
@@ -135,9 +149,7 @@ function _registerAudioCommands(aiCommand) {
             console.log();
         }
         catch (error) {
-            console.error(chalk.red("TTS generation failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(apiError(`TTS generation failed: ${error instanceof Error ? error.message : String(error)}`, true));
         }
     });
     aiCommand
@@ -148,8 +160,7 @@ function _registerAudioCommands(aiCommand) {
         try {
             const apiKey = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs", options.apiKey);
             if (!apiKey) {
-                console.error(chalk.red("ElevenLabs API key required. Set ELEVENLABS_API_KEY in .env or run: vibe setup"));
-                process.exit(1);
+                exitWithError(authError("ELEVENLABS_API_KEY", "ElevenLabs"));
             }
             const spinner = ora("Fetching voices...").start();
             const elevenlabs = new ElevenLabsProvider();
@@ -167,9 +178,7 @@ function _registerAudioCommands(aiCommand) {
             console.log();
         }
         catch (error) {
-            console.error(chalk.red("Failed to fetch voices"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(apiError(`Failed to fetch voices: ${error instanceof Error ? error.message : String(error)}`, true));
         }
     });
     aiCommand
@@ -180,12 +189,19 @@ function _registerAudioCommands(aiCommand) {
         .option("-o, --output <path>", "Output audio file path", "sound-effect.mp3")
         .option("-d, --duration <seconds>", "Duration in seconds (0.5-22, default: auto)")
         .option("--prompt-influence <value>", "Prompt influence (0-1, default: 0.3)")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (prompt, options) => {
         try {
+            if (options.output) {
+                validateOutputPath(options.output);
+            }
+            if (options.dryRun) {
+                outputResult({ dryRun: true, command: "ai sfx", params: { prompt, output: options.output, duration: options.duration, promptInfluence: options.promptInfluence } });
+                return;
+            }
             const apiKey = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs", options.apiKey);
             if (!apiKey) {
-                console.error(chalk.red("ElevenLabs API key required. Set ELEVENLABS_API_KEY in .env or run: vibe setup"));
-                process.exit(1);
+                exitWithError(authError("ELEVENLABS_API_KEY", "ElevenLabs"));
             }
             const spinner = ora("Generating sound effect...").start();
             const elevenlabs = new ElevenLabsProvider();
@@ -195,8 +211,8 @@ function _registerAudioCommands(aiCommand) {
                 promptInfluence: options.promptInfluence ? parseFloat(options.promptInfluence) : undefined,
             });
             if (!result.success || !result.audioBuffer) {
-                spinner.fail(chalk.red(result.error || "Sound effect generation failed"));
-                process.exit(1);
+                spinner.fail("Sound effect generation failed");
+                exitWithError(apiError(result.error || "Sound effect generation failed", true));
             }
             const outputPath = resolve(process.cwd(), options.output);
             await writeFile(outputPath, result.audioBuffer);
@@ -205,9 +221,7 @@ function _registerAudioCommands(aiCommand) {
             console.log();
         }
         catch (error) {
-            console.error(chalk.red("Sound effect generation failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(apiError(`Sound effect generation failed: ${error instanceof Error ? error.message : String(error)}`, true));
         }
     });
     aiCommand
@@ -216,12 +230,19 @@ function _registerAudioCommands(aiCommand) {
         .argument("<audio>", "Input audio file path")
         .option("-k, --api-key <key>", "ElevenLabs API key (or set ELEVENLABS_API_KEY env)")
         .option("-o, --output <path>", "Output audio file path", "vocals.mp3")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (audioPath, options) => {
         try {
+            if (options.output) {
+                validateOutputPath(options.output);
+            }
+            if (options.dryRun) {
+                outputResult({ dryRun: true, command: "ai isolate", params: { audio: audioPath, output: options.output } });
+                return;
+            }
             const apiKey = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs", options.apiKey);
             if (!apiKey) {
-                console.error(chalk.red("ElevenLabs API key required. Set ELEVENLABS_API_KEY in .env or run: vibe setup"));
-                process.exit(1);
+                exitWithError(authError("ELEVENLABS_API_KEY", "ElevenLabs"));
             }
             const spinner = ora("Reading audio file...").start();
             const absPath = resolve(process.cwd(), audioPath);
@@ -231,8 +252,8 @@ function _registerAudioCommands(aiCommand) {
             await elevenlabs.initialize({ apiKey });
             const result = await elevenlabs.isolateVocals(audioBuffer);
             if (!result.success || !result.audioBuffer) {
-                spinner.fail(chalk.red(result.error || "Audio isolation failed"));
-                process.exit(1);
+                spinner.fail("Audio isolation failed");
+                exitWithError(apiError(result.error || "Audio isolation failed", true));
             }
             const outputPath = resolve(process.cwd(), options.output);
             await writeFile(outputPath, result.audioBuffer);
@@ -241,9 +262,7 @@ function _registerAudioCommands(aiCommand) {
             console.log();
         }
         catch (error) {
-            console.error(chalk.red("Audio isolation failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(apiError(`Audio isolation failed: ${error instanceof Error ? error.message : String(error)}`, true));
         }
     });
     aiCommand
@@ -256,12 +275,16 @@ function _registerAudioCommands(aiCommand) {
         .option("--labels <json>", "Labels as JSON (e.g., '{\"accent\": \"american\"}')")
         .option("--remove-noise", "Remove background noise from samples")
         .option("--list", "List all available voices")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (samples, options) => {
         try {
+            if (options.dryRun) {
+                outputResult({ dryRun: true, command: "ai voice-clone", params: { samples, name: options.name, description: options.description, removeNoise: options.removeNoise } });
+                return;
+            }
             const apiKey = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs", options.apiKey);
             if (!apiKey) {
-                console.error(chalk.red("ElevenLabs API key required. Set ELEVENLABS_API_KEY in .env or run: vibe setup"));
-                process.exit(1);
+                exitWithError(authError("ELEVENLABS_API_KEY", "ElevenLabs"));
             }
             const elevenlabs = new ElevenLabsProvider();
             await elevenlabs.initialize({ apiKey });
@@ -286,20 +309,18 @@ function _registerAudioCommands(aiCommand) {
             }
             // Clone voice mode
             if (!options.name) {
-                console.error(chalk.red("Voice name is required. Use --name <name>"));
-                process.exit(1);
+                exitWithError(usageError("Voice name is required. Use --name <name>"));
             }
             if (!samples || samples.length === 0) {
-                console.error(chalk.red("At least one audio sample is required"));
-                process.exit(1);
+                exitWithError(usageError("At least one audio sample is required"));
             }
             const spinner = ora("Reading audio samples...").start();
             const audioBuffers = [];
             for (const samplePath of samples) {
                 const absPath = resolve(process.cwd(), samplePath);
                 if (!existsSync(absPath)) {
-                    spinner.fail(chalk.red(`File not found: ${samplePath}`));
-                    process.exit(1);
+                    spinner.fail("File not found");
+                    exitWithError(notFoundError(samplePath));
                 }
                 const buffer = await readFile(absPath);
                 audioBuffers.push(buffer);
@@ -313,8 +334,8 @@ function _registerAudioCommands(aiCommand) {
                 removeBackgroundNoise: options.removeNoise,
             });
             if (!result.success) {
-                spinner.fail(chalk.red(result.error || "Voice cloning failed"));
-                process.exit(1);
+                spinner.fail("Voice cloning failed");
+                exitWithError(apiError(result.error || "Voice cloning failed", true));
             }
             spinner.succeed(chalk.green("Voice cloned successfully"));
             console.log();
@@ -328,9 +349,7 @@ function _registerAudioCommands(aiCommand) {
             console.log();
         }
         catch (error) {
-            console.error(chalk.red("Voice cloning failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(apiError(`Voice cloning failed: ${error instanceof Error ? error.message : String(error)}`, true));
         }
     });
     aiCommand
@@ -343,12 +362,19 @@ function _registerAudioCommands(aiCommand) {
         .option("--model <model>", "Model variant: large, stereo-large, melody-large, stereo-melody-large", "stereo-large")
         .option("-o, --output <path>", "Output audio file path", "music.mp3")
         .option("--no-wait", "Don't wait for generation to complete (async mode)")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (prompt, options) => {
         try {
+            if (options.output) {
+                validateOutputPath(options.output);
+            }
+            if (options.dryRun) {
+                outputResult({ dryRun: true, command: "ai music", params: { prompt, output: options.output, duration: options.duration, model: options.model, melody: options.melody } });
+                return;
+            }
             const apiKey = await getApiKey("REPLICATE_API_TOKEN", "Replicate", options.apiKey);
             if (!apiKey) {
-                console.error(chalk.red("Replicate API token required. Set REPLICATE_API_TOKEN in .env or run: vibe setup"));
-                process.exit(1);
+                exitWithError(authError("REPLICATE_API_TOKEN", "Replicate"));
             }
             const replicate = new ReplicateProvider();
             await replicate.initialize({ apiKey });
@@ -360,14 +386,12 @@ function _registerAudioCommands(aiCommand) {
                 spinner.text = "Uploading melody reference...";
                 const absPath = resolve(process.cwd(), options.melody);
                 if (!existsSync(absPath)) {
-                    spinner.fail(chalk.red(`Melody file not found: ${options.melody}`));
-                    process.exit(1);
+                    spinner.fail("Melody file not found");
+                    exitWithError(notFoundError(options.melody));
                 }
                 // For Replicate, we need a publicly accessible URL
                 // In practice, users would need to host the file or use a data URL
-                console.log(chalk.yellow("Note: Melody conditioning requires a publicly accessible URL"));
-                console.log(chalk.yellow("Please upload your melody file and provide the URL"));
-                process.exit(1);
+                exitWithError(usageError("Melody conditioning requires a publicly accessible URL. Please upload your melody file and provide the URL."));
             }
             const result = await replicate.generateMusic(prompt, {
                 duration,
@@ -375,8 +399,8 @@ function _registerAudioCommands(aiCommand) {
                 melodyUrl,
             });
             if (!result.success || !result.taskId) {
-                spinner.fail(chalk.red(result.error || "Music generation failed"));
-                process.exit(1);
+                spinner.fail("Music generation failed");
+                exitWithError(apiError(result.error || "Music generation failed", true));
             }
             if (!options.wait) {
                 spinner.succeed(chalk.green("Music generation started"));
@@ -388,14 +412,14 @@ function _registerAudioCommands(aiCommand) {
             spinner.text = "Generating music (this may take a few minutes)...";
             const finalResult = await replicate.waitForMusic(result.taskId);
             if (!finalResult.success || !finalResult.audioUrl) {
-                spinner.fail(chalk.red(finalResult.error || "Music generation failed"));
-                process.exit(1);
+                spinner.fail("Music generation failed");
+                exitWithError(apiError(finalResult.error || "Music generation failed", true));
             }
             spinner.text = "Downloading generated audio...";
             const response = await fetch(finalResult.audioUrl);
             if (!response.ok) {
-                spinner.fail(chalk.red("Failed to download generated audio"));
-                process.exit(1);
+                spinner.fail("Failed to download generated audio");
+                exitWithError(apiError("Failed to download generated audio", true));
             }
             const audioBuffer = Buffer.from(await response.arrayBuffer());
             const outputPath = resolve(process.cwd(), options.output);
@@ -408,9 +432,7 @@ function _registerAudioCommands(aiCommand) {
             console.log();
         }
         catch (error) {
-            console.error(chalk.red("Music generation failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(apiError(`Music generation failed: ${error instanceof Error ? error.message : String(error)}`, true));
         }
     });
     aiCommand
@@ -422,8 +444,7 @@ function _registerAudioCommands(aiCommand) {
         try {
             const apiKey = await getApiKey("REPLICATE_API_TOKEN", "Replicate", options.apiKey);
             if (!apiKey) {
-                console.error(chalk.red("Replicate API token required. Set REPLICATE_API_TOKEN in .env or run: vibe setup"));
-                process.exit(1);
+                exitWithError(authError("REPLICATE_API_TOKEN", "Replicate"));
             }
             const replicate = new ReplicateProvider();
             await replicate.initialize({ apiKey });
@@ -446,9 +467,7 @@ function _registerAudioCommands(aiCommand) {
             console.log();
         }
         catch (error) {
-            console.error(chalk.red("Failed to get music status"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(apiError(`Failed to get music status: ${error instanceof Error ? error.message : String(error)}`, true));
         }
     });
     aiCommand
@@ -462,12 +481,19 @@ function _registerAudioCommands(aiCommand) {
         .option("--no-denoise", "Disable noise reduction")
         .option("--enhance", "Enable audio enhancement")
         .option("--noise-floor <dB>", "FFmpeg noise floor threshold", "-30")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (audioPath, options) => {
         try {
+            if (options.output) {
+                validateOutputPath(options.output);
+            }
             const absPath = resolve(process.cwd(), audioPath);
             if (!existsSync(absPath)) {
-                console.error(chalk.red(`File not found: ${audioPath}`));
-                process.exit(1);
+                exitWithError(notFoundError(audioPath));
+            }
+            if (options.dryRun) {
+                outputResult({ dryRun: true, command: "ai audio-restore", params: { audio: audioPath, output: options.output, ffmpeg: options.ffmpeg, denoise: options.denoise, enhance: options.enhance, noiseFloor: options.noiseFloor } });
+                return;
             }
             // Default output path
             const ext = extname(audioPath);
@@ -500,36 +526,24 @@ function _registerAudioCommands(aiCommand) {
                     console.log();
                 }
                 catch (error) {
-                    spinner.fail(chalk.red("FFmpeg restoration failed"));
-                    if (error instanceof Error && "message" in error) {
-                        console.error(chalk.dim(error.message));
-                    }
-                    process.exit(1);
+                    spinner.fail("FFmpeg restoration failed");
+                    exitWithError(generalError(`FFmpeg restoration failed: ${error instanceof Error ? error.message : String(error)}`));
                 }
                 return;
             }
             // Replicate AI mode
             const apiKey = await getApiKey("REPLICATE_API_TOKEN", "Replicate", options.apiKey);
             if (!apiKey) {
-                console.error(chalk.red("Replicate API token required. Set REPLICATE_API_TOKEN in .env or run: vibe setup"));
-                console.error(chalk.dim("Or use --ffmpeg for free FFmpeg-based restoration"));
-                process.exit(1);
+                exitWithError(authError("REPLICATE_API_TOKEN", "Replicate"));
             }
             const replicate = new ReplicateProvider();
             await replicate.initialize({ apiKey });
             // For Replicate, we need a publicly accessible URL
             // This is a limitation - users need to upload their file first
-            console.log(chalk.yellow("Note: Replicate requires a publicly accessible audio URL"));
-            console.log(chalk.yellow("For local files, use --ffmpeg for free local processing"));
-            console.log();
-            console.log(chalk.dim("Example with FFmpeg:"));
-            console.log(chalk.dim(`  pnpm vibe ai audio-restore ${audioPath} --ffmpeg`));
-            process.exit(1);
+            exitWithError(usageError("Replicate requires a publicly accessible audio URL. For local files, use --ffmpeg for free local processing.", `pnpm vibe ai audio-restore ${audioPath} --ffmpeg`));
         }
         catch (error) {
-            console.error(chalk.red("Audio restoration failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(apiError(`Audio restoration failed: ${error instanceof Error ? error.message : String(error)}`, true));
         }
     });
     aiCommand
@@ -541,33 +555,35 @@ function _registerAudioCommands(aiCommand) {
         .option("-v, --voice <id>", "ElevenLabs voice ID for output")
         .option("--analyze-only", "Only analyze and show timing, don't generate audio")
         .option("-o, --output <path>", "Output file path")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (mediaPath, options) => {
         try {
+            if (options.output) {
+                validateOutputPath(options.output);
+            }
             if (!options.language) {
-                console.error(chalk.red("Target language is required. Use -l or --language"));
-                process.exit(1);
+                exitWithError(usageError("Target language is required. Use -l or --language"));
+            }
+            if (options.dryRun) {
+                outputResult({ dryRun: true, command: "ai dub", params: { media: mediaPath, output: options.output, language: options.language, source: options.source, voice: options.voice, analyzeOnly: options.analyzeOnly } });
+                return;
             }
             const absPath = resolve(process.cwd(), mediaPath);
             if (!existsSync(absPath)) {
-                console.error(chalk.red(`File not found: ${mediaPath}`));
-                process.exit(1);
+                exitWithError(notFoundError(mediaPath));
             }
             // Check required API keys
             const openaiKey = await getApiKey("OPENAI_API_KEY", "OpenAI", undefined);
             const anthropicKey = await getApiKey("ANTHROPIC_API_KEY", "Anthropic", undefined);
             const elevenlabsKey = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs", undefined);
             if (!openaiKey) {
-                console.error(chalk.red("OpenAI API key required for transcription. Set OPENAI_API_KEY in .env or run: vibe setup"));
-                process.exit(1);
+                exitWithError(authError("OPENAI_API_KEY", "OpenAI"));
             }
             if (!anthropicKey) {
-                console.error(chalk.red("Anthropic API key required for translation. Set ANTHROPIC_API_KEY in .env or run: vibe setup"));
-                process.exit(1);
+                exitWithError(authError("ANTHROPIC_API_KEY", "Anthropic"));
             }
             if (!options.analyzeOnly && !elevenlabsKey) {
-                console.error(chalk.red("ElevenLabs API key required for TTS. Set ELEVENLABS_API_KEY in .env or run: vibe setup"));
-                console.error(chalk.dim("Or use --analyze-only to preview timing without generating audio"));
-                process.exit(1);
+                exitWithError(authError("ELEVENLABS_API_KEY", "ElevenLabs"));
             }
             const spinner = ora("Extracting audio...").start();
             // Check if input is video
@@ -582,8 +598,8 @@ function _registerAudioCommands(aiCommand) {
                     audioPath = tempAudioPath;
                 }
                 catch (error) {
-                    spinner.fail(chalk.red("Failed to extract audio from video"));
-                    process.exit(1);
+                    spinner.fail("Failed to extract audio from video");
+                    exitWithError(generalError(`Failed to extract audio from video: ${error instanceof Error ? error.message : String(error)}`));
                 }
             }
             // Step 2: Transcribe with Whisper
@@ -594,8 +610,8 @@ function _registerAudioCommands(aiCommand) {
             const audioBlob = new Blob([audioBuffer]);
             const transcriptResult = await whisper.transcribe(audioBlob, options.source);
             if (transcriptResult.status === "failed" || !transcriptResult.segments) {
-                spinner.fail(chalk.red(`Transcription failed: ${transcriptResult.error}`));
-                process.exit(1);
+                spinner.fail("Transcription failed");
+                exitWithError(apiError(`Transcription failed: ${transcriptResult.error}`, true));
             }
             // Step 3: Translate with Claude
             spinner.text = "Translating...";
@@ -733,9 +749,7 @@ function _registerAudioCommands(aiCommand) {
             }
         }
         catch (error) {
-            console.error(chalk.red("Dubbing failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(apiError(`Dubbing failed: ${error instanceof Error ? error.message : String(error)}`, true));
         }
     });
     // ============================================
@@ -752,16 +766,22 @@ function _registerAudioCommands(aiCommand) {
         .option("-r, --ratio <ratio>", "Compression ratio", "3")
         .option("-a, --attack <ms>", "Attack time in ms", "20")
         .option("-l, --release <ms>", "Release time in ms", "200")
+        .option("--dry-run", "Preview parameters without executing")
         .action(async (musicPath, options) => {
         try {
+            if (options.output) {
+                validateOutputPath(options.output);
+            }
             if (!options.voice) {
-                console.error(chalk.red("Voice track required. Use --voice <path>"));
-                process.exit(1);
+                exitWithError(usageError("Voice track required. Use --voice <path>"));
+            }
+            if (options.dryRun) {
+                outputResult({ dryRun: true, command: "ai duck", params: { music: musicPath, output: options.output, voice: options.voice, threshold: options.threshold, ratio: options.ratio, attack: options.attack, release: options.release } });
+                return;
             }
             // Check FFmpeg availability
             if (!commandExists("ffmpeg")) {
-                console.error(chalk.red("FFmpeg not found. Please install FFmpeg."));
-                process.exit(1);
+                exitWithError(generalError("FFmpeg not found. Please install FFmpeg."));
             }
             const spinner = ora("Processing audio ducking...").start();
             const absMusic = resolve(process.cwd(), musicPath);
@@ -791,9 +811,7 @@ function _registerAudioCommands(aiCommand) {
             console.log();
         }
         catch (error) {
-            console.error(chalk.red("Audio ducking failed"));
-            console.error(error);
-            process.exit(1);
+            exitWithError(generalError(`Audio ducking failed: ${error instanceof Error ? error.message : String(error)}`));
         }
     });
     // AI Color Grading