bazaar.it 0.1.0 → 0.2.1

package/dist/commands/recipe.js

@@ -0,0 +1,607 @@
+/**
+ * Recipe Commands - Agent Handshake Protocol
+ *
+ * Implements the REVIEW → APPROVE/EDIT → EXECUTE flow for external agents.
+ * See: memory-bank/sprints/sprint501_baz_cli/HANDSHAKE-PROTOCOL.md
+ *
+ * Commands:
+ * - baz recipe show      → Review the current plan
+ * - baz recipe execute   → Approve and run
+ * - baz recipe edit      → Modify before executing
+ * - baz recipe clear     → Reject/abandon
+ * - baz recipe assets    → List generated assets
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, hasAuth, getProjectId } from '../lib/config.js';
+import { apiRequest, ApiError } from '../lib/api.js';
+import { success, error, output, outputNDJSON, table } from '../lib/output.js';
+function exitRecipeAuthError(globalOpts) {
+    if (globalOpts.json) {
+        output({
+            type: 'error',
+            code: 'AUTH_MISSING',
+            message: 'Not authenticated',
+            category: 'auth',
+            retryable: false,
+            transient: false,
+            exitCode: 13,
+            suggestion: 'Run: baz auth login <api-key>',
+            continue: false,
+        }, { json: true, compact: globalOpts.compact });
+    }
+    else {
+        error('Not authenticated', 'Run: baz auth login <api-key>');
+    }
+    process.exit(13);
+}
+function exitRecipeProjectValidationError(message, globalOpts) {
+    if (globalOpts.json) {
+        output({
+            type: 'error',
+            code: 'VALIDATION',
+            message,
+            category: 'validation',
+            retryable: false,
+            transient: false,
+            exitCode: 64,
+            continue: false,
+        }, { json: true, compact: globalOpts.compact });
+    }
+    else {
+        error(message);
+    }
+    process.exit(64);
+}
+export const recipeCommand = new Command('recipe')
+    .description('Manage video recipes (agent handshake protocol)');
+/**
+ * baz recipe show
+ * Phase 2: REVIEW - External agent inspects the plan
+ */
+recipeCommand
+    .command('show')
+    .description('Show current recipe for review')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        exitRecipeAuthError(globalOpts);
+    }
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        exitRecipeProjectValidationError(err.message, globalOpts);
+    }
+    const spinner = globalOpts.json ? null : ora('Fetching recipe...').start();
+    try {
+        const result = await apiRequest(config, 'recipe.getByProject', {
+            projectId,
+        });
+        spinner?.stop();
+        if (!result || !result.recipe) {
+            if (globalOpts.json) {
+                output({
+                    type: 'no_recipe',
+                    message: 'No recipe found for this project',
+                    projectId,
+                    continue: false,
+                }, { json: true, compact: globalOpts.compact });
+            }
+            else {
+                console.log(chalk.gray('No recipe found for this project.'));
+                console.log(chalk.gray('Create one with: baz prompt "..." --plan'));
+            }
+            return;
+        }
+        if (globalOpts.json) {
+            output({
+                type: 'recipe',
+                executionId: result.executionId,
+                status: result.status,
+                recipe: result.recipe,
+                videoPlan: result.videoPlan,
+                sourceUrl: result.sourceUrl,
+                createdAt: result.createdAt,
+                continue: true, // Agent should decide: approve, edit, or reject
+            }, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        // Human-readable output
+        const recipe = result.recipe;
+        console.log(chalk.bold(`\n📋 Recipe: ${recipe.title}`));
+        console.log(chalk.gray(`Execution ID: ${result.executionId}`));
+        console.log(chalk.gray(`Status: ${result.status}`));
+        console.log();
+        if (recipe.voiceovers && recipe.voiceovers.length > 0) {
+            console.log(chalk.bold('🎙️  Voiceovers:'));
+            recipe.voiceovers.forEach((vo, i) => {
+                const duration = vo.duration ? ` (${vo.duration.toFixed(1)}s)` : '';
+                console.log(`  ${i + 1}. [${vo.id.slice(0, 8)}]${duration}`);
+                console.log(chalk.gray(`     "${vo.text.slice(0, 80)}${vo.text.length > 80 ? '...' : ''}"`));
+            });
+            console.log();
+        }
+        if (recipe.scenes && recipe.scenes.length > 0) {
+            console.log(chalk.bold('🎬 Scenes:'));
+            recipe.scenes.forEach((scene, i) => {
+                const trackLabel = `Track ${scene.track ?? 1}`;
+                console.log(`  ${i + 1}. ${scene.name} (${scene.type}, ${trackLabel})`);
+                console.log(chalk.gray(`     [${scene.id.slice(0, 8)}] "${scene.prompt.slice(0, 60)}..."`));
+            });
+            console.log();
+        }
+        if (recipe.music) {
+            console.log(chalk.bold('🎵 Music:'));
+            console.log(chalk.gray(`  "${recipe.music.prompt}"`));
+            console.log();
+        }
+        console.log(chalk.cyan('Next steps:'));
+        console.log(chalk.gray('  baz recipe execute      # Approve and run'));
+        console.log(chalk.gray('  baz recipe edit ...     # Modify first'));
+        console.log(chalk.gray('  baz recipe clear        # Reject/abandon'));
+    }
+    catch (err) {
+        spinner?.stop();
+        if (err instanceof ApiError) {
+            if (globalOpts.json) {
+                output(err.toJSON(), { json: true, compact: globalOpts.compact });
+            }
+            else {
+                error(err.message, err.suggestion);
+            }
+            process.exit(err.exitCode);
+        }
+        error(err.message);
+        process.exit(1);
+    }
+});
+/**
+ * baz recipe execute
+ * Phase 3A: APPROVE - Execute the approved plan
+ */
+recipeCommand
+    .command('execute')
+    .description('Execute the current recipe (approve and run)')
+    .option('--stream-json', 'Stream progress events as NDJSON')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const streamJson = options.streamJson || globalOpts.json;
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        if (streamJson) {
+            outputNDJSON({
+                type: 'error',
+                code: 'AUTH_MISSING',
+                message: 'Not authenticated',
+                category: 'auth',
+                retryable: false,
+                continue: false,
+            });
+        }
+        else {
+            error('Not authenticated', 'Run: baz auth login <api-key>');
+        }
+        if (streamJson) {
+            process.exit(13);
+        }
+        exitRecipeAuthError(globalOpts);
+    }
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        if (streamJson) {
+            outputNDJSON({
+                type: 'error',
+                code: 'NOT_FOUND',
+                message: err.message,
+                category: 'validation',
+                retryable: false,
+                continue: false,
+            });
+        }
+        else {
+            error(err.message);
+        }
+        if (streamJson) {
+            process.exit(64);
+        }
+        exitRecipeProjectValidationError(err.message, globalOpts);
+    }
+    // First, get the current recipe
+    if (streamJson) {
+        outputNDJSON({
+            type: 'execution_started',
+            message: 'Fetching recipe for execution...',
+            projectId,
+            continue: true,
+        });
+    }
+    const spinner = streamJson ? null : ora('Fetching recipe...').start();
+    try {
+        const recipeResult = await apiRequest(config, 'recipe.getByProject', {
+            projectId,
+        });
+        if (!recipeResult || !recipeResult.recipe) {
+            spinner?.stop();
+            if (streamJson) {
+                outputNDJSON({
+                    type: 'error',
+                    code: 'NOT_FOUND',
+                    message: 'No recipe found. Create one first with: baz prompt "..." --plan',
+                    category: 'validation',
+                    retryable: false,
+                    continue: false,
+                });
+            }
+            else {
+                error('No recipe found', 'Create one first with: baz prompt "..." --plan');
+            }
+            process.exit(64);
+        }
+        if (spinner)
+            spinner.text = 'Executing recipe...';
+        if (streamJson) {
+            outputNDJSON({
+                type: 'execution_running',
+                executionId: recipeResult.executionId,
+                recipeTitle: recipeResult.recipe.title,
+                scenesCount: recipeResult.recipe.scenes?.length || 0,
+                voiceoversCount: recipeResult.recipe.voiceovers?.length || 0,
+                continue: true,
+            });
+        }
+        // Execute the recipe
+        const executeResult = await apiRequest(config, 'recipe.execute', {
+            executionId: recipeResult.executionId,
+            recipe: recipeResult.recipe,
+        });
+        spinner?.stop();
+        if (!executeResult.success) {
+            if (streamJson) {
+                outputNDJSON({
+                    type: 'error',
+                    code: 'SERVER',
+                    message: executeResult.error || 'Recipe execution failed',
+                    category: 'transient',
+                    retryable: true,
+                    continue: false,
+                });
+            }
+            else {
+                error('Recipe execution failed', executeResult.error);
+            }
+            process.exit(1);
+        }
+        // Success!
+        if (streamJson) {
+            outputNDJSON({
+                type: 'execution_complete',
+                success: true,
+                executionId: recipeResult.executionId,
+                totalDuration: executeResult.totalDuration,
+                sceneIds: executeResult.sceneIds,
+                scenesCreated: executeResult.sceneIds?.length || 0,
+                continue: false, // Agent should verify and potentially iterate
+            });
+        }
+        else {
+            success(`Recipe executed successfully!`);
+            console.log(chalk.gray(`  Duration: ${executeResult.totalDuration?.toFixed(1) || '?'}s`));
+            console.log(chalk.gray(`  Scenes: ${executeResult.sceneIds?.length || 0} created`));
+            console.log();
+            console.log(chalk.cyan('Next steps:'));
+            console.log(chalk.gray('  baz scenes list         # Verify result'));
+            console.log(chalk.gray('  baz export start --wait # Export video'));
+        }
+    }
+    catch (err) {
+        spinner?.stop();
+        if (err instanceof ApiError) {
+            if (streamJson) {
+                outputNDJSON({ ...err.toJSON(), continue: false });
+            }
+            else {
+                error(err.message, err.suggestion);
+            }
+            process.exit(err.exitCode);
+        }
+        if (streamJson) {
+            outputNDJSON({
+                type: 'error',
+                code: 'UNKNOWN',
+                message: err.message,
+                category: 'fatal',
+                retryable: false,
+                continue: false,
+            });
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(1);
+    }
+});
+/**
+ * baz recipe edit
+ * Phase 3B: EDIT - Modify the plan before executing
+ */
+recipeCommand
+    .command('edit')
+    .description('Edit the current recipe before executing')
+    .option('--voiceover <id>', 'Voiceover ID to edit')
+    .option('--scene <id>', 'Scene ID to edit')
+    .option('--text <text>', 'New voiceover text')
+    .option('--prompt <prompt>', 'New scene prompt')
+    .option('--name <name>', 'New scene name')
+    .option('--add-scene', 'Add a new scene instead of editing')
+    .option('--type <type>', 'Scene type for new scene (motion_graphics, image, etc.)')
+    .option('--track <n>', 'Track number for new scene', parseInt)
+    .option('--remove-voiceover <id>', 'Remove a voiceover by ID')
+    .option('--remove-scene <id>', 'Remove a scene by ID')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        exitRecipeAuthError(globalOpts);
+    }
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        exitRecipeProjectValidationError(err.message, globalOpts);
+    }
+    const spinner = globalOpts.json ? null : ora('Fetching recipe...').start();
+    try {
+        // Get current recipe
+        const recipeResult = await apiRequest(config, 'recipe.getByProject', {
+            projectId,
+        });
+        if (!recipeResult || !recipeResult.recipe) {
+            spinner?.stop();
+            error('No recipe found', 'Create one first with: baz prompt "..." --plan');
+            process.exit(64);
+        }
+        const recipe = recipeResult.recipe;
+        let modified = false;
+        // Edit voiceover
+        if (options.voiceover && options.text) {
+            const vo = recipe.voiceovers.find((v) => v.id === options.voiceover || v.id.startsWith(options.voiceover));
+            if (!vo) {
+                spinner?.stop();
+                error(`Voiceover not found: ${options.voiceover}`);
+                process.exit(64);
+            }
+            vo.text = options.text;
+            modified = true;
+        }
+        // Edit scene
+        if (options.scene) {
+            const scene = recipe.scenes.find((s) => s.id === options.scene || s.id.startsWith(options.scene));
+            if (!scene) {
+                spinner?.stop();
+                error(`Scene not found: ${options.scene}`);
+                process.exit(64);
+            }
+            if (options.prompt) {
+                scene.prompt = options.prompt;
+                modified = true;
+            }
+            if (options.name) {
+                scene.name = options.name;
+                modified = true;
+            }
+            if (options.track !== undefined) {
+                scene.track = options.track;
+                modified = true;
+            }
+        }
+        // Add new scene
+        if (options.addScene) {
+            if (!options.name || !options.prompt) {
+                spinner?.stop();
+                error('--add-scene requires --name and --prompt');
+                process.exit(65);
+            }
+            const newScene = {
+                id: crypto.randomUUID(),
+                name: options.name,
+                type: options.type || 'motion_graphics',
+                prompt: options.prompt,
+                track: options.track ?? 1,
+            };
+            recipe.scenes.push(newScene);
+            modified = true;
+        }
+        // Remove voiceover
+        if (options.removeVoiceover) {
+            const idx = recipe.voiceovers.findIndex((v) => v.id === options.removeVoiceover || v.id.startsWith(options.removeVoiceover));
+            if (idx === -1) {
+                spinner?.stop();
+                error(`Voiceover not found: ${options.removeVoiceover}`);
+                process.exit(64);
+            }
+            recipe.voiceovers.splice(idx, 1);
+            modified = true;
+        }
+        // Remove scene
+        if (options.removeScene) {
+            const idx = recipe.scenes.findIndex((s) => s.id === options.removeScene || s.id.startsWith(options.removeScene));
+            if (idx === -1) {
+                spinner?.stop();
+                error(`Scene not found: ${options.removeScene}`);
+                process.exit(64);
+            }
+            recipe.scenes.splice(idx, 1);
+            modified = true;
+        }
+        if (!modified) {
+            spinner?.stop();
+            error('No modifications specified', 'Use --voiceover, --scene, --add-scene, --remove-voiceover, or --remove-scene');
+            process.exit(65);
+        }
+        if (spinner)
+            spinner.text = 'Saving changes...';
+        // Update the recipe
+        await apiRequest(config, 'recipe.update', {
+            executionId: recipeResult.executionId,
+            recipe,
+        });
+        spinner?.stop();
+        if (globalOpts.json) {
+            output({
+                type: 'recipe_updated',
+                executionId: recipeResult.executionId,
+                recipe,
+                continue: true, // Agent can continue editing or execute
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            success('Recipe updated');
+            console.log(chalk.cyan('Next steps:'));
+            console.log(chalk.gray('  baz recipe show         # Review changes'));
+            console.log(chalk.gray('  baz recipe execute      # Run the recipe'));
+        }
+    }
+    catch (err) {
+        spinner?.stop();
+        if (err instanceof ApiError) {
+            if (globalOpts.json) {
+                output(err.toJSON(), { json: true, compact: globalOpts.compact });
+            }
+            else {
+                error(err.message, err.suggestion);
+            }
+            process.exit(err.exitCode);
+        }
+        error(err.message);
+        process.exit(1);
+    }
+});
+/**
+ * baz recipe clear
+ * Phase 3C: REJECT - Abandon the current plan
+ */
+recipeCommand
+    .command('clear')
+    .description('Clear/abandon the current recipe')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        exitRecipeAuthError(globalOpts);
+    }
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        exitRecipeProjectValidationError(err.message, globalOpts);
+    }
+    // For now, "clear" just means the agent starts fresh with a new prompt
+    // We could add a recipe.delete endpoint, but typically agents just create a new recipe
+    if (globalOpts.json) {
+        output({
+            type: 'recipe_cleared',
+            message: 'Recipe abandoned. Start fresh with: baz prompt "..." --plan',
+            projectId,
+            continue: true, // Agent can start over
+        }, { json: true, compact: globalOpts.compact });
+    }
+    else {
+        success('Recipe cleared');
+        console.log(chalk.gray('Start fresh with: baz prompt "..." --plan'));
+    }
+});
+/**
+ * baz recipe assets
+ * List generated assets from recipe execution
+ */
+recipeCommand
+    .command('assets')
+    .description('List assets generated by recipe execution')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        exitRecipeAuthError(globalOpts);
+    }
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        exitRecipeProjectValidationError(err.message, globalOpts);
+    }
+    const spinner = globalOpts.json ? null : ora('Fetching generated assets...').start();
+    try {
+        const assets = await apiRequest(config, 'recipe.getGeneratedAssets', {
+            projectId,
+        });
+        spinner?.stop();
+        if (globalOpts.json) {
+            output({
+                type: 'assets',
+                projectId,
+                assets,
+                count: assets.length,
+                continue: false,
+            }, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        if (assets.length === 0) {
+            console.log(chalk.gray('No generated assets yet.'));
+            console.log(chalk.gray('Execute a recipe first: baz recipe execute'));
+            return;
+        }
+        console.log(chalk.bold(`\n🎨 Generated Assets (${assets.length})`));
+        console.log();
+        const rows = assets.map((asset) => [
+            asset.assetId.slice(0, 12),
+            asset.type,
+            asset.name,
+            asset.duration ? `${asset.duration.toFixed(1)}s` : '-',
+        ]);
+        table(['ID', 'Type', 'Name', 'Duration'], rows);
+    }
+    catch (err) {
+        spinner?.stop();
+        if (err instanceof ApiError) {
+            if (globalOpts.json) {
+                output(err.toJSON(), { json: true, compact: globalOpts.compact });
+            }
+            else {
+                error(err.message, err.suggestion);
+            }
+            process.exit(err.exitCode);
+        }
+        error(err.message);
+        process.exit(1);
+    }
+});

package/dist/commands/review.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Review Command - Full State Dump for External Agent Evaluation
+ *
+ * Returns all the data an external agent needs to evaluate the video:
+ * - Original goal and requirements
+ * - Each scene with actual TSX code
+ * - Voiceovers with text
+ * - AI-generated asset prompts (Seedance, etc.)
+ * - Timing information
+ *
+ * The external agent (Maya, Claude, GPT) then makes its own intelligent
+ * judgment about whether the video meets the original goal.
+ *
+ * See: memory-bank/sprints/sprint501_baz_cli/HANDSHAKE-PROTOCOL.md
+ */
+import { Command } from 'commander';
+export declare const reviewCommand: Command;