bazaar.it 0.1.0 → 0.2.1

package/dist/commands/prompt.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const promptCommand: Command;

package/dist/commands/prompt.js

@@ -0,0 +1,540 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { readFileSync, existsSync } from 'fs';
+import { loadConfig, hasAuth, getProjectId } from '../lib/config.js';
+import { streamGeneration, uploadImage, fetchUrlContent, ApiError } from '../lib/api.js';
+import { error, output } from '../lib/output.js';
+/**
+ * Collector function for repeatable --image option
+ */
+function collect(value, previous) {
+    return previous.concat([value]);
+}
+/**
+ * Format elapsed time in human-readable format
+ */
+function formatElapsed(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSecs = seconds % 60;
+    return `${minutes}m ${remainingSecs}s`;
+}
+export const promptCommand = new Command('prompt')
+    .description('Send a prompt to the autonomous agent')
+    .argument('[text]', 'The prompt text (or use --file)')
+    .option('--mode <mode>', 'Generation mode: agent (default), agent-max, multi-scene', 'agent')
+    .option('--max', 'Shorthand for --mode agent-max')
+    .option('--file <path>', 'Read prompt from file')
+    .option('--image <path>', 'Attach an image file (can be used multiple times)', collect, [])
+    .option('--url <url>', 'Attach a URL for the agent to analyze (can be used multiple times)', collect, [])
+    .option('--no-stream', 'Disable streaming output')
+    .option('--verbose', 'Show agent\'s full response text')
+    .option('--stream-json', 'Output events as newline-delimited JSON (for bots like Maya)')
+    .option('--events-only', 'With --stream-json, only emit structured events (skip text/thinking tokens)')
+    .option('--plan', 'Create a recipe/plan without executing (handshake protocol)')
+    .option('--requirements <list>', 'Requirements to verify against (comma-separated)')
+    .option('--budget <dollars>', 'Max budget per run in USD (default: 5)', parseFloat)
+    .option('--model <model>', 'Agent model: fast, default, max')
+    .action(async (text, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const agentModeEnv = process.env.BAZ_AGENT === '1';
+    const jsonOutput = globalOpts.json || agentModeEnv;
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        if (options.streamJson || jsonOutput) {
+            console.log(JSON.stringify({
+                type: 'error',
+                code: 'AUTH_MISSING',
+                errorType: 'AUTH_MISSING',
+                message: 'Not authenticated',
+                category: 'auth',
+                retryable: false,
+                transient: false,
+                suggestion: 'Run: baz auth login <api-key>',
+                continue: false,
+            }));
+        }
+        else {
+            error('Not authenticated', 'Run: baz auth login <api-key>');
+        }
+        process.exit(13); // Auth error exit code
+    }
+    // Get project ID
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        if (options.streamJson || jsonOutput) {
+            console.log(JSON.stringify({
+                type: 'error',
+                code: 'VALIDATION',
+                errorType: 'VALIDATION',
+                message: err.message,
+                category: 'validation',
+                retryable: false,
+                transient: false,
+                suggestion: 'Set active project with: baz project use <id>',
+                continue: false,
+            }));
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(64); // Input error exit code
+    }
+    // Get prompt text: --file takes precedence, then positional arg
+    let promptText = text || '';
+    if (options.file) {
+        try {
+            promptText = readFileSync(options.file, 'utf-8').trim();
+        }
+        catch (err) {
+            error(`Failed to read file: ${options.file}`);
+            process.exit(1);
+        }
+    }
+    if (!promptText) {
+        error('No prompt provided. Pass text as argument or use --file <path>');
+        process.exit(1);
+    }
+    // Determine mode
+    const mode = options.max ? 'agent-max' : options.mode;
+    // Handle image uploads
+    const imageUrls = [];
+    if (options.image && options.image.length > 0) {
+        const uploadSpinner = ora('Uploading images...').start();
+        try {
+            for (const imagePath of options.image) {
+                if (!existsSync(imagePath)) {
+                    uploadSpinner.fail();
+                    error(`Image file not found: ${imagePath}`);
+                    process.exit(1);
+                }
+                const imageBuffer = readFileSync(imagePath);
+                const url = await uploadImage(config, { projectId, buffer: imageBuffer, filename: imagePath });
+                imageUrls.push(url);
+            }
+            uploadSpinner.succeed(`Uploaded ${imageUrls.length} image${imageUrls.length > 1 ? 's' : ''}`);
+        }
+        catch (err) {
+            uploadSpinner.fail();
+            const errMsg = err instanceof ApiError
+                ? `${err.message}${err.suggestion ? ` — ${err.suggestion}` : ''}`
+                : err.message;
+            error(`Failed to upload images: ${errMsg}`);
+            process.exit(1);
+        }
+    }
+    // Handle URL attachments
+    const urlContents = [];
+    if (options.url && options.url.length > 0) {
+        const urlSpinner = ora('Fetching URLs...').start();
+        try {
+            for (const url of options.url) {
+                const result = await fetchUrlContent(url);
+                urlContents.push({
+                    url,
+                    title: result.title,
+                    content: result.content.slice(0, 10000), // Limit content length
+                });
+            }
+            urlSpinner.succeed(`Fetched ${urlContents.length} URL${urlContents.length > 1 ? 's' : ''}`);
+        }
+        catch (err) {
+            urlSpinner.fail();
+            const errMsg = err instanceof ApiError
+                ? `${err.message}${err.details ? ` — ${err.details}` : ''}`
+                : err.message;
+            error(`Failed to fetch URL: ${errMsg}`);
+            process.exit(1);
+        }
+        // Prepend URL content to the prompt
+        if (urlContents.length > 0) {
+            const urlContext = urlContents.map(u => `--- Content from ${u.url}${u.title ? ` (${u.title})` : ''} ---\n${u.content}`).join('\n\n');
+            promptText = `${urlContext}\n\n---\n\nUser request: ${promptText}`;
+        }
+    }
+    // For bots: --stream-json outputs NDJSON (newline-delimited JSON) with timestamps
+    const streamJson = options.streamJson === true || agentModeEnv;
+    // Show mode info (skip for JSON modes)
+    if (!jsonOutput && !streamJson && options.stream !== false) {
+        console.log(chalk.cyan(`Mode: ${mode}`));
+        console.log(chalk.gray(`Project: ${projectId}`));
+        if (imageUrls.length > 0) {
+            console.log(chalk.gray(`Images: ${imageUrls.length} attached`));
+        }
+        if (urlContents.length > 0) {
+            console.log(chalk.gray(`URLs: ${urlContents.length} attached`));
+        }
+        console.log();
+    }
+    // Track timing and progress
+    const startTime = Date.now();
+    let stepCount = 0;
+    let lastPhase = '';
+    // Stream the generation
+    const spinner = options.stream !== false ? null : ora('Processing...').start();
+    let currentSpinner = null;
+    let textBuffer = '';
+    let isFirstText = true;
+    let scenesCreatedNames = [];
+    let scenesUpdatedNames = [];
+    // Tool display names for better UX
+    const toolNames = {
+        // Scene tools
+        add_scene: '🎬 Creating scene',
+        edit_scene: '✏️  Editing scene',
+        delete_scene: '🗑️  Deleting scene',
+        addScene: '🎬 Creating scene',
+        editScene: '✏️  Editing scene',
+        deleteScene: '🗑️  Deleting scene',
+        trimScene: '⏱️  Adjusting timing',
+        // Media generation
+        generateImage: '🖼️  Generating image',
+        generateVideo: '🎥 Generating video',
+        generateVoiceover: '🎙️  Generating voiceover',
+        generateMusic: '🎵 Generating music',
+        // Gathering tools
+        fetch_url: '🌐 Fetching URL',
+        take_screenshot: '📸 Taking screenshot',
+        removeBackground: '✂️  Removing background',
+        summarize: '📝 Summarizing content',
+        // Code tools
+        str_replace_based_edit_tool: '✏️  Editing code',
+        browse_composition: '👀 Analyzing composition',
+        // Planning & orchestration
+        create_video_plan: '📋 Planning video',
+        create_recipe: '🧪 Creating recipe',
+        workflow: '🔄 Running workflow',
+        execute_workflow: '⚡ Executing workflow',
+        // Audio tools
+        addAudio: '🔊 Adding audio',
+        embedAudio: '🎧 Embedding audio',
+        // Advanced video (Nano Banana, Veo, etc.)
+        generateVeo3: '🎬 Generating Veo video',
+        nanoBanana: '🍌 Running Nano Banana',
+        NanoBananaService: '🍌 Nano Banana generation',
+        seedance: '💃 Generating Seedance video',
+    };
+    // Track recipes and workflows created
+    let recipesCreated = [];
+    let workflowsCreated = [];
+    // Track budget from complete event for summary
+    let budgetData;
+    try {
+        // Resolve model alias to full model ID
+        const MODEL_ALIASES = {
+            fast: 'claude-haiku-4-5',
+            max: 'claude-opus-4-6',
+            default: 'claude-sonnet-4-5',
+        };
+        const resolvedModel = options.model
+            ? MODEL_ALIASES[options.model] || options.model
+            : undefined; // Let api.ts default (Sonnet) handle it
+        const result = await streamGeneration(config, {
+            projectId,
+            prompt: promptText,
+            mode,
+            imageUrls: imageUrls.length > 0 ? imageUrls : undefined,
+            includeRaw: streamJson, // Include raw data and timestamps for bot mode
+            planOnly: options.plan, // Handshake: create plan without executing
+            requirements: options.requirements, // Requirements for verification
+            budgetUsd: options.budget, // Per-run budget in USD
+            modelOverride: resolvedModel,
+            onEvent: options.stream !== false ? (event) => {
+                // Handle streaming output
+                // Stream JSON / JSON mode: output raw event lines, but still track plan/workflow for summaries.
+                if (streamJson || jsonOutput) {
+                    if (event.type === 'recipe_created') {
+                        const recipeName = event.recipeName || 'Untitled Recipe';
+                        recipesCreated.push(recipeName);
+                    }
+                    if (event.type === 'workflow_created') {
+                        const wfName = event.workflowName || 'Untitled Workflow';
+                        workflowsCreated.push(wfName);
+                    }
+                    if (event.type === 'complete' && event.budget) {
+                        budgetData = event.budget;
+                    }
+                    // --events-only (or BAZ_AGENT=1): skip noisy text/thinking tokens and tool_use starts
+                    const effectiveEventsOnly = options.eventsOnly || agentModeEnv;
+                    if (effectiveEventsOnly) {
+                        if (event.type === 'text' || event.type === 'thinking')
+                            return;
+                        if (event.type === 'tool_use' && event.action === 'start')
+                            return;
+                    }
+                    console.log(JSON.stringify(event));
+                    return;
+                }
+                // Track phase changes for step counting
+                const currentPhase = event.type;
+                if (currentPhase !== lastPhase && currentPhase !== 'text') {
+                    if (['tool_use', 'code_gen', 'compile'].includes(currentPhase)) {
+                        stepCount++;
+                    }
+                    lastPhase = currentPhase;
+                }
+                // Format step prefix with elapsed time
+                const elapsed = formatElapsed(Date.now() - startTime);
+                const stepPrefix = chalk.dim(`[${elapsed}]`);
+                switch (event.type) {
+                    case 'thinking':
+                        if (currentSpinner)
+                            currentSpinner.stop();
+                        // Show a truncated version of what the agent is thinking
+                        const thinkingPreview = event.message
+                            ? event.message.slice(0, 55).replace(/\n/g, ' ') + (event.message.length > 55 ? '...' : '')
+                            : 'analyzing...';
+                        currentSpinner = ora(`${stepPrefix} ${chalk.blue(`🧠 ${thinkingPreview}`)}`).start();
+                        break;
+                    case 'tool_use':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        const toolDisplay = toolNames[event.tool || ''] || `🔧 ${event.tool}`;
+                        currentSpinner = ora(`${stepPrefix} ${chalk.yellow(toolDisplay)}`).start();
+                        break;
+                    case 'code_gen':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        currentSpinner = ora(`${stepPrefix} ${chalk.magenta('💻 Generating code...')}`).start();
+                        break;
+                    case 'compile':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        currentSpinner = ora(`${stepPrefix} ${chalk.cyan('⚙️  Compiling scene...')}`).start();
+                        break;
+                    case 'ready':
+                        console.log(`${stepPrefix} ${chalk.blue(`   🚀 Agent ready`)}${event.budgetUsd ? chalk.gray(` (budget: $${event.budgetUsd.toFixed(2)})`) : ''}${event.model ? chalk.gray(` [${event.model}]`) : ''}`);
+                        break;
+                    case 'asset_generated':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        console.log(`${stepPrefix} ${chalk.green(`   🎨 ${event.assetType || 'Asset'}: ${event.message || 'generated'}`)}${event.costUsd ? chalk.gray(` ($${event.costUsd.toFixed(2)})`) : ''}`);
+                        currentSpinner = null;
+                        break;
+                    case 'scene_created':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        const createdName = event.sceneName || event.sceneId?.slice(0, 8) || 'scene';
+                        scenesCreatedNames.push(createdName);
+                        console.log(`${stepPrefix} ${chalk.green(`   ✅ Created: "${createdName}"`)}`);
+                        currentSpinner = null;
+                        break;
+                    case 'scene_updated':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        const updatedName = event.sceneName || event.sceneId?.slice(0, 8) || 'scene';
+                        scenesUpdatedNames.push(updatedName);
+                        console.log(`${stepPrefix} ${chalk.green(`   ✅ Updated: "${updatedName}"`)}`);
+                        currentSpinner = null;
+                        break;
+                    case 'error':
+                        if (currentSpinner)
+                            currentSpinner.fail();
+                        console.log(`${stepPrefix} ${chalk.red(`   ❌ ${event.message}`)}`);
+                        currentSpinner = null;
+                        break;
+                    case 'complete':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        currentSpinner = null;
+                        break;
+                    case 'recipe_created':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        const recipeName = event.recipeName || 'Untitled Recipe';
+                        recipesCreated.push(recipeName);
+                        console.log(`${stepPrefix} ${chalk.magenta(`   🧪 Recipe: "${recipeName}"`)}`);
+                        if (event.recipeDescription) {
+                            console.log(chalk.dim(`      ${event.recipeDescription.slice(0, 60)}...`));
+                        }
+                        // In plan mode, signal awaiting approval
+                        if (options.plan) {
+                            console.log(`${stepPrefix} ${chalk.cyan(`   ⏳ Awaiting approval`)}`);
+                            console.log(chalk.gray(`      Review: baz recipe show --json`));
+                            console.log(chalk.gray(`      Execute: baz recipe execute --stream-json`));
+                        }
+                        currentSpinner = null;
+                        break;
+                    case 'awaiting_approval':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        console.log(`${stepPrefix} ${chalk.cyan(`   ⏳ Plan ready for review`)}`);
+                        if (event.executionId) {
+                            console.log(chalk.gray(`      Execution ID: ${event.executionId}`));
+                        }
+                        console.log(chalk.gray(`      Review: baz recipe show --json`));
+                        console.log(chalk.gray(`      Execute: baz recipe execute --stream-json`));
+                        currentSpinner = null;
+                        break;
+                    case 'workflow_created':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        const wfName = event.workflowName || 'Untitled Workflow';
+                        workflowsCreated.push(wfName);
+                        console.log(`${stepPrefix} ${chalk.cyan(`   🔄 Workflow: "${wfName}"`)}`);
+                        if (event.workflowDescription) {
+                            console.log(chalk.dim(`      ${event.workflowDescription.slice(0, 60)}...`));
+                        }
+                        currentSpinner = null;
+                        break;
+                    case 'video_plan_created':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        console.log(`${stepPrefix} ${chalk.blue(`   📋 Video plan created`)}`);
+                        if (event.videoPlanSummary) {
+                            console.log(chalk.dim(`      ${event.videoPlanSummary.slice(0, 60)}...`));
+                        }
+                        currentSpinner = null;
+                        break;
+                    case 'text':
+                        // Stream text to console (agent's response)
+                        const showText = options.verbose || globalOpts.verbose;
+                        if (event.message) {
+                            textBuffer += event.message;
+                            if (showText) {
+                                if (isFirstText) {
+                                    console.log(); // Add newline before text
+                                    console.log(chalk.gray('─'.repeat(50)));
+                                    console.log(chalk.dim('Agent response:'));
+                                    isFirstText = false;
+                                }
+                                process.stdout.write(chalk.gray(event.message));
+                            }
+                        }
+                        break;
+                }
+            } : undefined,
+        });
+        // Clean up spinner (cast needed due to closure type narrowing)
+        if (currentSpinner) {
+            currentSpinner.stop();
+        }
+        if (spinner) {
+            spinner.stop();
+        }
+        // Calculate final elapsed time
+        const totalElapsed = formatElapsed(Date.now() - startTime);
+        const elapsedMs = Date.now() - startTime;
+        // Output final result
+        if (streamJson) {
+            // In plan mode, emit awaiting_approval instead of summary
+            if (options.plan && recipesCreated.length > 0) {
+                console.log(JSON.stringify({
+                    type: 'awaiting_approval',
+                    timestamp: new Date().toISOString(),
+                    success: true,
+                    recipeName: recipesCreated[0],
+                    recipesCreated,
+                    requirements: options.requirements?.split(',').map((r) => r.trim()),
+                    elapsed: totalElapsed,
+                    elapsedMs,
+                    message: 'Plan ready for review. Use baz recipe show --json to inspect, baz recipe execute to run.',
+                    continue: true, // Critical: signals agent should review and decide
+                }));
+                return;
+            }
+            // Final summary event for bot consumption - OODA loop signal
+            console.log(JSON.stringify({
+                type: 'summary',
+                timestamp: new Date().toISOString(),
+                success: result.success,
+                scenesCreated: result.scenesCreated,
+                scenesUpdated: result.scenesUpdated,
+                errors: result.errors,
+                summary: result.summary,
+                elapsed: totalElapsed,
+                elapsedMs,
+                steps: stepCount,
+                ...(budgetData && { budget: budgetData }),
+                continue: false, // Critical: signals end of generation loop
+            }));
+            return;
+        }
+        if (jsonOutput) {
+            output({
+                ...result,
+                elapsed: totalElapsed,
+                steps: stepCount,
+                continue: false,
+            }, { json: true, compact: globalOpts.compact || agentModeEnv });
+            return;
+        }
+        // Add separator if we streamed text
+        if (textBuffer && !isFirstText) {
+            console.log();
+            console.log(chalk.gray('─'.repeat(50)));
+        }
+        console.log();
+        if (result.success) {
+            const totalScenes = result.scenesCreated.length + result.scenesUpdated.length;
+            const hasRecipes = recipesCreated.length > 0;
+            const hasWorkflows = workflowsCreated.length > 0;
+            // Build summary line
+            const summaryParts = [];
+            if (totalScenes > 0)
+                summaryParts.push(`${totalScenes} scene${totalScenes > 1 ? 's' : ''}`);
+            if (hasRecipes)
+                summaryParts.push(`${recipesCreated.length} recipe${recipesCreated.length > 1 ? 's' : ''}`);
+            if (hasWorkflows)
+                summaryParts.push(`${workflowsCreated.length} workflow${workflowsCreated.length > 1 ? 's' : ''}`);
+            // Show completion box
+            console.log(chalk.green('┌' + '─'.repeat(48) + '┐'));
+            if (summaryParts.length > 0) {
+                const summaryText = summaryParts.join(', ');
+                console.log(chalk.green('│') + chalk.green.bold(` ✓ Done!`) + chalk.gray(` (${summaryText} in ${totalElapsed})`.padEnd(39).slice(0, 39)) + chalk.green('│'));
+            }
+            else {
+                console.log(chalk.green('│') + chalk.green.bold(` ✓ Agent completed`) + chalk.gray(` in ${totalElapsed}`.padEnd(29)) + chalk.green('│'));
+            }
+            console.log(chalk.green('└' + '─'.repeat(48) + '┘'));
+            // Show details
+            if (scenesCreatedNames.length > 0) {
+                console.log(chalk.gray(`  Scenes created: ${scenesCreatedNames.join(', ')}`));
+            }
+            if (scenesUpdatedNames.length > 0) {
+                console.log(chalk.gray(`  Scenes updated: ${scenesUpdatedNames.join(', ')}`));
+            }
+            if (recipesCreated.length > 0) {
+                console.log(chalk.magenta(`  Recipes: ${recipesCreated.join(', ')}`));
+            }
+            if (workflowsCreated.length > 0) {
+                console.log(chalk.cyan(`  Workflows: ${workflowsCreated.join(', ')}`));
+            }
+            if (result.summary) {
+                console.log();
+                console.log(chalk.dim(result.summary));
+            }
+        }
+        else {
+            // Show error box
+            console.log(chalk.red('┌' + '─'.repeat(48) + '┐'));
+            console.log(chalk.red('│') + chalk.red.bold(` ✗ Agent failed`) + chalk.gray(` after ${totalElapsed}`.padEnd(32)) + chalk.red('│'));
+            console.log(chalk.red('└' + '─'.repeat(48) + '┘'));
+            if (result.errors.length > 0) {
+                console.log(chalk.dim('Errors:'));
+                result.errors.forEach(e => console.log(chalk.red(`  • ${e}`)));
+            }
+            process.exit(1); // Fatal error - generation failed
+        }
+    }
+    catch (err) {
+        if (currentSpinner)
+            currentSpinner.fail();
+        if (spinner)
+            spinner.stop();
+        error(err.message);
+        process.exit(1);
+    }
+});

package/dist/commands/recipe.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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';
+export declare const recipeCommand: Command;