bazaar.it 0.1.0 → 0.2.1

package/dist/commands/review.js

@@ -0,0 +1,345 @@
+/**
+ * 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';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, hasAuth, getProjectId } from '../lib/config.js';
+import { apiRequest, ApiError } from '../lib/api.js';
+import { error, output } from '../lib/output.js';
+const FPS = 30;
+export const reviewCommand = new Command('review')
+    .description('Get full project state for external agent evaluation')
+    .option('--include-code', 'Include full TSX code for each scene (default: true)')
+    .option('--no-code', 'Exclude TSX code (smaller payload)')
+    .option('--summary', 'Compact summary (no TSX code or full context)')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const summary = options.summary === true;
+    const includeCode = summary ? false : options.code !== false; // Default true unless --no-code
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        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>',
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error('Not authenticated', 'Run: baz auth login <api-key>');
+        }
+        process.exit(13);
+    }
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'VALIDATION',
+                message: err.message,
+                category: 'validation',
+                retryable: false,
+                transient: false,
+                exitCode: 64,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(64);
+    }
+    const spinner = globalOpts.json ? null : ora('Gathering project state...').start();
+    try {
+        // Fetch full project with scenes
+        const project = await apiRequest(config, 'project.getFullProject', {
+            id: projectId,
+            include: ['scenes'],
+            includeSceneCode: includeCode,
+        });
+        // Fetch recipe (contains original plan, prompts, voiceovers)
+        const recipeResult = await apiRequest(config, 'recipe.getByProject', {
+            projectId,
+        });
+        // Fetch generated assets (includes AI prompts)
+        let generatedAssets = [];
+        try {
+            generatedAssets = await apiRequest(config, 'recipe.getGeneratedAssets', {
+                projectId,
+            });
+        }
+        catch {
+            // Assets may not exist yet
+        }
+        // Fetch project context (goals, requirements, references)
+        let projectContextData = {};
+        try {
+            const contextResult = await apiRequest(config, 'context.getForAI', {
+                projectId,
+            });
+            projectContextData = contextResult.context;
+        }
+        catch {
+            // Context may not exist yet
+        }
+        spinner?.stop();
+        const scenes = project.scenes || [];
+        const recipe = recipeResult?.recipe;
+        // Helper to get start frame (may be in props.start or start)
+        const getStartFrame = (s) => {
+            return s.start ?? s.props?.start ?? 0;
+        };
+        // Helper to detect scene type from code patterns
+        const detectSceneType = (scene, recipeScene) => {
+            if (scene.type)
+                return scene.type;
+            if (scene.props?.type)
+                return scene.props.type;
+            if (recipeScene?.type)
+                return recipeScene.type;
+            // Try to detect from TSX code patterns
+            const code = scene.tsxCode || '';
+            if (code.includes('background') || code.includes('gradient'))
+                return 'background';
+            if (code.includes('IconifyIcon') || code.includes('button'))
+                return 'ui';
+            if (code.includes('text') || code.includes('Typography'))
+                return 'text';
+            return 'motion_graphics';
+        };
+        // Calculate timing info
+        const totalFrames = scenes.reduce((max, s) => {
+            const start = getStartFrame(s);
+            return Math.max(max, start + (s.duration || 0));
+        }, 0);
+        const totalDuration = totalFrames / FPS;
+        // Build scene data with code and linked prompts
+        const sceneData = scenes.map(scene => {
+            // Find the recipe scene that generated this (by sceneId match or name)
+            const recipeScene = recipe?.scenes.find(rs => rs.sceneId === scene.id || rs.name === scene.name);
+            // Find linked voiceover
+            const linkedVoiceover = recipeScene?.voiceoverRef
+                ? recipe?.voiceovers.find(v => v.id === recipeScene.voiceoverRef)
+                : undefined;
+            const startFrame = getStartFrame(scene);
+            const durationFrames = scene.duration || 0;
+            const base = {
+                id: scene.id,
+                name: scene.name,
+                type: detectSceneType(scene, recipeScene),
+                track: scene.track ?? 0,
+                start: startFrame / FPS, // Convert to seconds
+                duration: durationFrames / FPS, // Convert to seconds
+                order: scene.order,
+            };
+            if (summary) {
+                return base;
+            }
+            return {
+                ...base,
+                // The actual code - this is what's really being rendered
+                ...(includeCode && scene.tsxCode && { tsxCode: scene.tsxCode }),
+                // The original prompt that was used to generate this scene
+                ...(recipeScene?.prompt && { originalPrompt: recipeScene.prompt }),
+                // Linked voiceover text (for sync evaluation)
+                ...(linkedVoiceover && {
+                    linkedVoiceover: {
+                        id: linkedVoiceover.id,
+                        text: linkedVoiceover.text,
+                        duration: linkedVoiceover.duration,
+                    }
+                }),
+            };
+        });
+        const contextSummary = summary
+            ? Object.fromEntries(Object.entries(projectContextData).map(([label, items]) => {
+                const typeCounts = {};
+                for (const item of items) {
+                    const key = item.contentType || 'text';
+                    typeCounts[key] = (typeCounts[key] || 0) + 1;
+                }
+                return [label, { count: items.length, types: typeCounts }];
+            }))
+            : projectContextData;
+        const generatedAssetsSummary = summary
+            ? generatedAssets.reduce((acc, asset) => {
+                acc[asset.type] = (acc[asset.type] || 0) + 1;
+                return acc;
+            }, {})
+            : undefined;
+        // Build the full state dump
+        const reviewData = {
+            type: summary ? 'review_summary' : 'review_state',
+            projectId,
+            projectName: project.name,
+            // Timing overview
+            timing: {
+                totalDuration,
+                sceneCount: scenes.length,
+                fps: FPS,
+            },
+            // The original plan (if recipe exists)
+            ...(recipe && {
+                originalPlan: summary
+                    ? {
+                        title: recipe.title,
+                        sceneCount: recipe.scenes.length,
+                        voiceoverCount: recipe.voiceovers.length,
+                        hasMusic: Boolean(recipe.music),
+                    }
+                    : {
+                        title: recipe.title,
+                        style: recipe.style,
+                        // Music prompt if any
+                        ...(recipe.music && { musicPrompt: recipe.music.prompt }),
+                    },
+            }),
+            // Original URL if this was URL-to-video
+            ...(recipeResult?.sourceUrl && { sourceUrl: recipeResult.sourceUrl }),
+            // Voiceovers (the script)
+            voiceovers: recipe?.voiceovers.map(v => summary ? ({
+                id: v.id,
+                duration: v.duration,
+                hasAudio: Boolean(v.audioUrl),
+                textPreview: v.text.slice(0, 80),
+            }) : ({
+                id: v.id,
+                text: v.text,
+                voiceId: v.voiceId,
+                duration: v.duration,
+                hasAudio: Boolean(v.audioUrl),
+            })) || [],
+            // All scenes with code and prompts
+            scenes: sceneData,
+            // AI-generated assets with their prompts
+            ...(summary
+                ? { generatedAssetsSummary }
+                : {
+                    generatedAssets: generatedAssets.map(a => ({
+                        assetId: a.assetId,
+                        type: a.type,
+                        name: a.name,
+                        duration: a.duration,
+                        // The prompt sent to Seedance, image gen, etc.
+                        ...(a.prompt && { aiPrompt: a.prompt }),
+                    })),
+                }),
+            // Recipe scene prompts (in case scene linking didn't work)
+            ...(!summary && recipe && {
+                recipeScenePrompts: recipe.scenes.map(rs => ({
+                    id: rs.id,
+                    name: rs.name,
+                    type: rs.type,
+                    prompt: rs.prompt,
+                    track: rs.track,
+                })),
+            }),
+            // Project context (goals, requirements, references)
+            // External agent can compare this against the actual output
+            ...(Object.keys(contextSummary).length > 0 && { context: contextSummary }),
+            // Signal to external agent: evaluate this and decide
+            continue: true,
+        };
+        if (globalOpts.json) {
+            output(reviewData, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        // Human-readable output
+        console.log();
+        console.log(chalk.bold(`📋 Project State for Review`));
+        console.log(chalk.gray(`Project: ${project.name} (${projectId.slice(0, 8)}...)`));
+        console.log(chalk.gray(`Duration: ${totalDuration.toFixed(1)}s | Scenes: ${scenes.length}`));
+        console.log();
+        if (recipe) {
+            console.log(chalk.bold('Original Plan:'));
+            console.log(chalk.gray(`  Title: ${recipe.title}`));
+            if (!summary && recipe.style?.mood) {
+                console.log(chalk.gray(`  Mood: ${recipe.style.mood}`));
+            }
+            console.log();
+        }
+        if (recipe?.voiceovers && recipe.voiceovers.length > 0) {
+            console.log(chalk.bold('Voiceovers:'));
+            recipe.voiceovers.forEach((v, i) => {
+                const dur = v.duration ? ` (${v.duration.toFixed(1)}s)` : '';
+                const preview = summary ? `${v.text.slice(0, 40)}...` : `${v.text.slice(0, 60)}...`;
+                console.log(chalk.gray(`  ${i + 1}. "${preview}"${dur}`));
+            });
+            console.log();
+        }
+        console.log(chalk.bold('Scenes:'));
+        sceneData.forEach((s, i) => {
+            const timing = `${s.start.toFixed(1)}s - ${(s.start + s.duration).toFixed(1)}s`;
+            console.log(`  ${i + 1}. ${s.name} (${s.type}, track ${s.track})`);
+            console.log(chalk.gray(`     ${timing} | ${s.duration.toFixed(1)}s`));
+            if (!summary && s.originalPrompt) {
+                console.log(chalk.gray(`     Prompt: "${s.originalPrompt.slice(0, 50)}..."`));
+            }
+            if (!summary && includeCode && s.tsxCode) {
+                console.log(chalk.gray(`     Code: ${s.tsxCode.length} chars`));
+            }
+        });
+        console.log();
+        if (!summary && generatedAssets.length > 0) {
+            console.log(chalk.bold('AI-Generated Assets:'));
+            generatedAssets.forEach(a => {
+                console.log(chalk.gray(`  • ${a.name} (${a.type})`));
+                if (a.prompt) {
+                    console.log(chalk.gray(`    Prompt: "${a.prompt.slice(0, 50)}..."`));
+                }
+            });
+            console.log();
+        }
+        if (summary && generatedAssets.length > 0) {
+            const typeCounts = generatedAssets.reduce((acc, asset) => {
+                acc[asset.type] = (acc[asset.type] || 0) + 1;
+                return acc;
+            }, {});
+            console.log(chalk.bold('AI-Generated Assets:'));
+            Object.entries(typeCounts).forEach(([type, count]) => {
+                console.log(chalk.gray(`  • ${type}: ${count}`));
+            });
+            console.log();
+        }
+        console.log(chalk.cyan('For JSON output: baz review --json'));
+        console.log(chalk.gray('External agent evaluates this state against original goal.'));
+    }
+    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/scenes.d.ts

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