bazaar.it 0.1.0 → 0.2.1

package/dist/commands/loop.js

@@ -0,0 +1,538 @@
+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, apiRequest } from '../lib/api.js';
+import { success, error, output } from '../lib/output.js';
+function collect(value, previous) {
+    return previous.concat([value]);
+}
+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`;
+}
+function normalizeRequirements(input) {
+    if (!input)
+        return [];
+    return input.split(',').map(r => r.trim()).filter(Boolean);
+}
+function getStartFrame(scene) {
+    return scene.start ?? scene.props?.start ?? 0;
+}
+function buildRequirementsCheck(requirements, data) {
+    const haystackParts = [];
+    for (const scene of data.scenes) {
+        if (scene.name)
+            haystackParts.push(scene.name);
+    }
+    if (data.recipe) {
+        haystackParts.push(data.recipe.title || '');
+        data.recipe.scenes?.forEach(s => haystackParts.push(s.prompt || '', s.name || ''));
+        data.recipe.voiceovers?.forEach(v => haystackParts.push(v.text || ''));
+    }
+    const haystack = haystackParts.join('\n').toLowerCase();
+    const missing = [];
+    const satisfied = [];
+    for (const req of requirements) {
+        if (haystack.includes(req.toLowerCase())) {
+            satisfied.push(req);
+        }
+        else {
+            missing.push(req);
+        }
+    }
+    return { satisfied, missing, total: requirements.length };
+}
+function parseBudgetMs(input) {
+    if (!input)
+        return undefined;
+    const value = input.trim().toLowerCase();
+    const match = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+    if (!match)
+        return undefined;
+    const amount = parseFloat(match[1] ?? '0');
+    const unit = match[2] || 's';
+    if (!Number.isFinite(amount) || amount <= 0)
+        return undefined;
+    switch (unit) {
+        case 'ms':
+            return amount;
+        case 'm':
+            return amount * 60_000;
+        case 'h':
+            return amount * 3_600_000;
+        case 's':
+        default:
+            return amount * 1_000;
+    }
+}
+export const loopCommand = new Command('loop')
+    .description('Iterate prompt → review in a basic OODA loop')
+    .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('--max-iterations <n>', 'Maximum iterations (default: 3)', '3')
+    .option('--budget <time>', 'Total time budget (e.g., 45s, 2m, 1h)')
+    .option('--stop-on-fail', 'Stop the loop on generation failure')
+    .option('--requirements <list>', 'Requirements to verify against (comma-separated)')
+    .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('--stream-json', 'Output events as newline-delimited JSON')
+    .option('--plan', 'Create a recipe/plan without executing (handshake protocol)')
+    .action(async (text, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const agentModeEnv = process.env.BAZ_AGENT === '1';
+    const jsonOutput = globalOpts.json || agentModeEnv;
+    const streamJson = options.streamJson === true || agentModeEnv;
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        if (streamJson || jsonOutput) {
+            console.log(JSON.stringify({
+                type: 'error',
+                code: 'AUTH_MISSING',
+                message: 'Not authenticated',
+                category: 'auth',
+                retryable: false,
+                continue: false,
+            }));
+        }
+        else {
+            error('Not authenticated', 'Run: baz auth login <api-key>');
+        }
+        process.exit(13);
+    }
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        if (streamJson || jsonOutput) {
+            console.log(JSON.stringify({
+                type: 'error',
+                code: 'VALIDATION',
+                message: err.message,
+                category: 'validation',
+                retryable: false,
+                continue: false,
+            }));
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(64);
+    }
+    // Get prompt text
+    let promptText = text;
+    if (options.file) {
+        try {
+            promptText = readFileSync(options.file, 'utf-8').trim();
+        }
+        catch {
+            error(`Failed to read file: ${options.file}`);
+            process.exit(1);
+        }
+    }
+    if (!promptText) {
+        error('No prompt provided');
+        process.exit(1);
+    }
+    const mode = options.max ? 'agent-max' : options.mode;
+    const requirements = normalizeRequirements(options.requirements);
+    const budgetMs = parseBudgetMs(options.budget);
+    const stopOnFail = options.stopOnFail === true;
+    let maxIterations = parseInt(options.maxIterations, 10);
+    if (!Number.isFinite(maxIterations) || maxIterations < 1)
+        maxIterations = 1;
+    if (options.plan)
+        maxIterations = 1;
+    if (budgetMs !== undefined && budgetMs <= 0) {
+        error('Budget must be a positive duration (e.g., 30s, 2m)');
+        process.exit(64);
+    }
+    // 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),
+                });
+            }
+            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);
+        }
+        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}`;
+        }
+    }
+    const toolNames = {
+        add_scene: '🎬 Creating scene',
+        edit_scene: '✏️  Editing scene',
+        delete_scene: '🗑️  Deleting scene',
+        addScene: '🎬 Creating scene',
+        editScene: '✏️  Editing scene',
+        deleteScene: '🗑️  Deleting scene',
+        trimScene: '⏱️  Adjusting timing',
+        generateImage: '🖼️  Generating image',
+        generateVideo: '🎥 Generating video',
+        generateVoiceover: '🎙️  Generating voiceover',
+        generateMusic: '🎵 Generating music',
+        fetch_url: '🌐 Fetching URL',
+        take_screenshot: '📸 Taking screenshot',
+        removeBackground: '✂️  Removing background',
+        summarize: '📝 Summarizing content',
+        str_replace_based_edit_tool: '✏️  Editing code',
+        browse_composition: '👀 Analyzing composition',
+        create_video_plan: '📋 Planning video',
+        create_recipe: '🧪 Creating recipe',
+        workflow: '🔄 Running workflow',
+        execute_workflow: '⚡ Executing workflow',
+        addAudio: '🔊 Adding audio',
+        embedAudio: '🎧 Embedding audio',
+        generateVeo3: '🎬 Generating Veo video',
+        nanoBanana: '🍌 Running Nano Banana',
+        NanoBananaService: '🍌 Nano Banana generation',
+        seedance: '💃 Generating Seedance video',
+    };
+    const basePrompt = promptText;
+    let currentPrompt = basePrompt;
+    const results = [];
+    const loopStart = Date.now();
+    const emit = (payload) => {
+        if (streamJson) {
+            console.log(JSON.stringify(payload));
+        }
+    };
+    emit({
+        type: 'loop_start',
+        mode,
+        projectId,
+        maxIterations,
+        budgetMs: budgetMs ?? null,
+        requirements,
+        planOnly: options.plan === true,
+    });
+    for (let iteration = 1; iteration <= maxIterations; iteration++) {
+        const iterStart = Date.now();
+        const elapsedTotal = Date.now() - loopStart;
+        if (budgetMs !== undefined && elapsedTotal > budgetMs) {
+            emit({
+                type: 'loop_budget_exceeded',
+                iteration,
+                budgetMs,
+                elapsedMs: elapsedTotal,
+                continue: false,
+            });
+            break;
+        }
+        emit({
+            type: 'loop_iteration_start',
+            iteration,
+            maxIterations,
+            mode,
+            projectId,
+            requirements,
+            planOnly: options.plan === true,
+        });
+        emit({
+            type: 'ooda_act',
+            iteration,
+            prompt: currentPrompt,
+        });
+        if (!streamJson && !jsonOutput) {
+            console.log(chalk.cyan(`\nIteration ${iteration}/${maxIterations}`));
+        }
+        let stepCount = 0;
+        let lastPhase = '';
+        let currentSpinner = null;
+        const startTime = Date.now();
+        const spinner = options.stream !== false ? null : ora('Processing...').start();
+        let result = null;
+        try {
+            result = await streamGeneration(config, {
+                projectId,
+                prompt: currentPrompt,
+                mode,
+                imageUrls: imageUrls.length > 0 ? imageUrls : undefined,
+                includeRaw: streamJson,
+                planOnly: options.plan,
+                requirements: options.requirements,
+                onEvent: options.stream !== false ? (event) => {
+                    if (streamJson) {
+                        console.log(JSON.stringify({ ...event, iteration }));
+                        return;
+                    }
+                    if (jsonOutput) {
+                        return;
+                    }
+                    const currentPhase = event.type;
+                    if (currentPhase !== lastPhase && currentPhase !== 'text') {
+                        if (['tool_use', 'code_gen', 'compile'].includes(currentPhase)) {
+                            stepCount++;
+                        }
+                        lastPhase = currentPhase;
+                    }
+                    const elapsed = formatElapsed(Date.now() - startTime);
+                    const stepPrefix = chalk.dim(`[${elapsed}]`);
+                    switch (event.type) {
+                        case 'thinking':
+                            if (currentSpinner)
+                                currentSpinner.stop();
+                            currentSpinner = ora(`${stepPrefix} ${chalk.blue('🧠 Thinking...')}`).start();
+                            break;
+                        case 'tool_use':
+                            if (currentSpinner)
+                                currentSpinner.succeed();
+                            currentSpinner = ora(`${stepPrefix} ${chalk.yellow(toolNames[event.tool || ''] || `🔧 ${event.tool}`)}`).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...')}`).start();
+                            break;
+                        case 'scene_created':
+                            if (currentSpinner)
+                                currentSpinner.succeed();
+                            currentSpinner = null;
+                            break;
+                        case 'scene_updated':
+                            if (currentSpinner)
+                                currentSpinner.succeed();
+                            currentSpinner = null;
+                            break;
+                        case 'error':
+                            if (currentSpinner)
+                                currentSpinner.fail();
+                            currentSpinner = null;
+                            break;
+                        case 'complete':
+                            if (currentSpinner)
+                                currentSpinner.succeed();
+                            currentSpinner = null;
+                            break;
+                    }
+                } : undefined,
+            });
+        }
+        catch (err) {
+            if (currentSpinner)
+                currentSpinner.fail();
+            if (spinner)
+                spinner.stop();
+            const message = err instanceof Error ? err.message : String(err);
+            if (streamJson || jsonOutput) {
+                console.log(JSON.stringify({
+                    type: 'error',
+                    message,
+                    iteration,
+                    category: 'fatal',
+                    retryable: false,
+                    continue: false,
+                }));
+            }
+            else {
+                error(message);
+            }
+            break;
+        }
+        if (!result) {
+            break;
+        }
+        if (currentSpinner)
+            currentSpinner.stop();
+        if (spinner)
+            spinner.stop();
+        const totalElapsed = formatElapsed(Date.now() - startTime);
+        const elapsedMs = Date.now() - startTime;
+        // Observe: fetch summary state
+        const project = await apiRequest(config, 'project.getFullProject', {
+            id: projectId,
+            include: ['scenes'],
+            includeSceneCode: false,
+        });
+        const recipeResult = await apiRequest(config, 'recipe.getByProject', {
+            projectId,
+        });
+        const scenes = project.scenes || [];
+        const totalFrames = scenes.reduce((max, s) => {
+            const start = getStartFrame(s);
+            return Math.max(max, start + (s.duration || 0));
+        }, 0);
+        const totalDuration = totalFrames / 30;
+        const requirementsCheck = requirements.length > 0
+            ? buildRequirementsCheck(requirements, { scenes, recipe: recipeResult?.recipe })
+            : { satisfied: [], missing: [], total: 0 };
+        const reviewSummary = {
+            iteration,
+            success: result.success,
+            elapsed: totalElapsed,
+            elapsedMs,
+            steps: stepCount,
+            scenesCreated: result.scenesCreated,
+            scenesUpdated: result.scenesUpdated,
+            errors: result.errors,
+            project: {
+                sceneCount: scenes.length,
+                totalDuration,
+            },
+            recipe: recipeResult?.recipe ? {
+                title: recipeResult.recipe.title,
+                sceneCount: recipeResult.recipe.scenes.length,
+                voiceoverCount: recipeResult.recipe.voiceovers.length,
+            } : null,
+            requirements: requirementsCheck,
+        };
+        results.push(reviewSummary);
+        emit({
+            type: 'ooda_observe',
+            iteration,
+            scenes: scenes.length,
+            duration: totalDuration,
+        });
+        emit({
+            type: 'ooda_orient',
+            iteration,
+            requirements: requirementsCheck,
+        });
+        emit({
+            type: 'loop_review',
+            ...reviewSummary,
+        });
+        if (!jsonOutput && !streamJson) {
+            if (result.success) {
+                success(`Iteration ${iteration} complete (${totalElapsed})`);
+            }
+            else {
+                error(`Iteration ${iteration} failed`);
+            }
+            console.log(chalk.gray(`Scenes: ${scenes.length} | Duration: ${totalDuration.toFixed(1)}s`));
+            if (requirements.length > 0) {
+                const missing = requirementsCheck.missing;
+                if (missing.length === 0) {
+                    console.log(chalk.green('Requirements satisfied'));
+                }
+                else {
+                    console.log(chalk.yellow(`Missing requirements: ${missing.join(', ')}`));
+                }
+            }
+        }
+        const satisfied = requirements.length === 0 || requirementsCheck.missing.length === 0;
+        const shouldStopOnFail = stopOnFail && !result.success;
+        if (shouldStopOnFail) {
+            emit({
+                type: 'ooda_decide',
+                iteration,
+                decision: 'stop',
+                reason: 'generation_failed',
+            });
+            break;
+        }
+        const elapsedAfter = Date.now() - loopStart;
+        if (budgetMs !== undefined && elapsedAfter > budgetMs) {
+            emit({
+                type: 'ooda_decide',
+                iteration,
+                decision: 'stop',
+                reason: 'budget_exceeded',
+                elapsedMs: elapsedAfter,
+                budgetMs,
+            });
+            break;
+        }
+        if (satisfied || iteration === maxIterations) {
+            emit({
+                type: 'ooda_decide',
+                iteration,
+                decision: 'stop',
+                reason: satisfied ? 'requirements_satisfied' : 'max_iterations',
+            });
+            break;
+        }
+        // Decide: re-run with a fix instruction
+        const missing = requirementsCheck.missing.join(', ');
+        const failureNote = !result.success && !stopOnFail
+            ? `The previous attempt failed with errors: ${(result.errors || []).join('; ')}.\n`
+            : '';
+        currentPrompt = `${basePrompt}\n\n${failureNote}The previous attempt did not satisfy these requirements: ${missing}.\nPlease update the scenes to satisfy them.`;
+        const iterElapsed = formatElapsed(Date.now() - iterStart);
+        emit({
+            type: 'ooda_decide',
+            iteration,
+            decision: 'continue',
+            reason: 'requirements_missing',
+            nextPrompt: currentPrompt,
+            elapsed: iterElapsed,
+        });
+    }
+    if (jsonOutput && !streamJson) {
+        output({
+            type: 'loop_summary',
+            projectId,
+            mode,
+            iterations: results.length,
+            results,
+        }, { json: true, compact: globalOpts.compact || agentModeEnv });
+    }
+    emit({
+        type: 'loop_complete',
+        iterations: results.length,
+        projectId,
+        mode,
+    });
+});

package/dist/commands/mcp.d.ts

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

package/dist/commands/mcp.js

@@ -0,0 +1,143 @@
+import { Command } from 'commander';
+import { output } from '../lib/output.js';
+import { CLI_VERSION } from '../lib/version.js';
+function getMcpManifest() {
+    const tools = [
+        {
+            name: 'baz_prompt',
+            description: 'Generate or edit video scenes from a natural language prompt.',
+            command: 'baz prompt "<text>" --project-id <id> --stream-json',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    projectId: { type: 'string' },
+                    prompt: { type: 'string' },
+                    mode: { type: 'string', enum: ['agent', 'agent-max', 'multi-scene'] },
+                    streamJson: { type: 'boolean', default: true },
+                },
+                required: ['projectId', 'prompt'],
+            },
+        },
+        {
+            name: 'baz_state',
+            description: 'Get project state snapshot for agent context.',
+            command: 'baz state --project-id <id> --json',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    projectId: { type: 'string' },
+                    includeCode: { type: 'boolean', default: false },
+                    includeMessages: { type: 'boolean', default: false },
+                },
+                required: ['projectId'],
+            },
+        },
+        {
+            name: 'baz_verify',
+            description: 'Verify the current project against criteria.',
+            command: 'baz verify --project-id <id> --criteria "<c1,c2>" --json',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    projectId: { type: 'string' },
+                    criteria: { type: 'array', items: { type: 'string' } },
+                    sceneId: { type: 'string' },
+                },
+                required: ['projectId', 'criteria'],
+            },
+        },
+        {
+            name: 'baz_project_validate',
+            description: 'Run structural validation on project timeline.',
+            command: 'baz project validate --project-id <id> --json',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    projectId: { type: 'string' },
+                },
+                required: ['projectId'],
+            },
+        },
+        {
+            name: 'baz_export_start',
+            description: 'Start a video export.',
+            command: 'baz export start --project-id <id> --json',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    projectId: { type: 'string' },
+                    quality: { type: 'string', enum: ['1080p', '720p'] },
+                    wait: { type: 'boolean', default: false },
+                },
+                required: ['projectId'],
+            },
+        },
+        {
+            name: 'baz_scenes_code',
+            description: 'Read TSX source code for a scene. Use before set-code to get current code.',
+            command: 'baz scenes code <scene-id> --project-id <id> --json',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    projectId: { type: 'string' },
+                    sceneId: { type: 'string' },
+                    all: { type: 'boolean', default: false },
+                },
+                required: ['projectId'],
+            },
+        },
+        {
+            name: 'baz_scenes_set_code',
+            description: 'Replace scene TSX code directly. Read code first with baz_scenes_code, edit locally, then write back. No LLM in the middle — deterministic.',
+            command: 'baz scenes set-code <scene-id> --file <path> --project-id <id> --json',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    projectId: { type: 'string' },
+                    sceneId: { type: 'string' },
+                    file: { type: 'string', description: 'Path to file containing new TSX code' },
+                    code: { type: 'string', description: 'Inline TSX code (alternative to file)' },
+                    overwriteDuration: { type: 'boolean', default: false },
+                },
+                required: ['projectId', 'sceneId'],
+            },
+        },
+    ];
+    return {
+        protocol: 'mcp-manifest',
+        version: '1.0',
+        server: {
+            name: 'baz-cli',
+            cliVersion: CLI_VERSION,
+            transport: 'stdio-via-cli',
+        },
+        tools,
+    };
+}
+export const mcpCommand = new Command('mcp')
+    .description('Expose MCP-style tool manifest for agent integrations')
+    .action((options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    output(getMcpManifest(), { json: true, compact: globalOpts.compact });
+});
+mcpCommand
+    .command('schema')
+    .description('Print MCP-style manifest schema')
+    .action((options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    output(getMcpManifest(), { json: true, compact: globalOpts.compact });
+});
+mcpCommand
+    .command('tools')
+    .description('List MCP tool names')
+    .action((options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const manifest = getMcpManifest();
+    if (globalOpts.json) {
+        output(manifest.tools.map((tool) => tool.name), { json: true, compact: globalOpts.compact });
+        return;
+    }
+    for (const tool of manifest.tools) {
+        console.log(`${tool.name} - ${tool.description}`);
+    }
+});

package/dist/commands/media.d.ts

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