bazaar.it 0.1.0 → 0.2.0

package/dist/repl.js

@@ -0,0 +1,764 @@
+import * as readline from 'readline';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, saveConfig, hasAuth, getConfigPath } from './lib/config.js';
+import { showBanner } from './lib/banner.js';
+import { CLI_VERSION } from './lib/version.js';
+import { apiRequest, streamGeneration } from './lib/api.js';
+import { success, error, table, formatDuration, formatRelativeTime } from './lib/output.js';
+// Simple status indicator for REPL (avoids ora terminal conflicts)
+function status(text) {
+    process.stdout.write(chalk.gray(`${text}...`));
+    return {
+        done: () => {
+            process.stdout.write(chalk.green(' ✓\n'));
+        },
+        fail: () => {
+            process.stdout.write(chalk.red(' ✗\n'));
+        },
+    };
+}
+// Commands for tab completion
+const COMMANDS = [
+    'project list', 'project create', 'project use', 'project current', 'project delete',
+    'scenes list', 'scenes code', 'scenes delete',
+    'auth login', 'auth logout', 'auth status',
+    'help', 'exit', 'quit',
+    '/help', '/status', '/use', '/clear', '/history', '/exit',
+];
+/**
+ * Tab completion function
+ */
+function completer(line) {
+    const hits = COMMANDS.filter((c) => c.startsWith(line.toLowerCase()));
+    return [hits.length ? hits : COMMANDS, line];
+}
+/**
+ * Start the interactive REPL
+ */
+export async function startRepl() {
+    // Load config
+    const config = loadConfig();
+    // Show banner
+    showBanner(CLI_VERSION, {
+        hasApiKey: Boolean(config.apiKey),
+        apiUrl: config.apiUrl,
+        activeProject: config.activeProjectId,
+    });
+    // Initialize state
+    const state = {
+        config,
+        history: [],
+        running: true,
+    };
+    // Create readline interface with tab completion
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk.hex('#a855f7')('baz') + chalk.gray('> '),
+        historySize: 100,
+        completer,
+    });
+    // Welcome message
+    console.log(chalk.gray('Type commands or prompts. Use /help for available commands.'));
+    console.log();
+    rl.prompt();
+    // Track if we're processing a command
+    let processing = false;
+    // Handle input
+    rl.on('line', (line) => {
+        const input = line.trim();
+        if (!input) {
+            rl.prompt();
+            return;
+        }
+        // Add to history
+        state.history.push(input);
+        // Mark as processing to prevent premature exit
+        processing = true;
+        // Execute command (async, but we don't await at the event handler level)
+        executeInput(input, state)
+            .catch((err) => {
+            // Catch ALL errors to prevent REPL from crashing
+            const message = err instanceof Error ? err.message : String(err);
+            error(message);
+            if (process.env.DEBUG) {
+                console.error(err);
+            }
+        })
+            .finally(() => {
+            processing = false;
+            // Prompt again if still running
+            if (state.running) {
+                console.log();
+                rl.prompt();
+            }
+        });
+    });
+    // Prevent unhandled rejections from crashing
+    process.on('unhandledRejection', (reason) => {
+        error(`Unexpected error: ${reason}`);
+        rl.prompt();
+    });
+    // Handle close - but don't exit while command is running
+    rl.on('close', () => {
+        console.log();
+        console.log(chalk.gray('Goodbye!'));
+        state.running = false;
+        // Don't force exit - let the event loop drain naturally
+    });
+    // Handle errors on readline
+    rl.on('error', (err) => {
+        console.error(chalk.red('Readline error:'), err.message);
+    });
+    // Keep the process alive
+    process.stdin.resume();
+    // Handle SIGINT (Ctrl+C)
+    rl.on('SIGINT', () => {
+        console.log();
+        console.log(chalk.gray('(Use /exit or Ctrl+D to quit)'));
+        rl.prompt();
+    });
+}
+/**
+ * Execute user input (command or prompt)
+ */
+async function executeInput(input, state) {
+    // Slash commands
+    if (input.startsWith('/')) {
+        await executeSlashCommand(input, state);
+        return;
+    }
+    // Regular commands (project list, scenes code, etc.)
+    const words = input.split(/\s+/);
+    const cmd = words[0]?.toLowerCase();
+    // Route to handlers
+    switch (cmd) {
+        case 'project':
+        case 'projects':
+            await handleProject(words.slice(1), state);
+            break;
+        case 'scenes':
+        case 'scene':
+            await handleScenes(words.slice(1), state);
+            break;
+        case 'auth':
+            await handleAuth(words.slice(1), state);
+            break;
+        case 'help':
+            showHelp();
+            break;
+        case 'status':
+            await showProjectStatus(state);
+            break;
+        case 'exit':
+        case 'quit':
+        case 'q':
+            state.running = false;
+            console.log(chalk.gray('Goodbye!'));
+            process.exit(0);
+            break;
+        default:
+            // Treat as a prompt to the AI agent
+            await handlePrompt(input, state);
+    }
+}
+/**
+ * Execute slash commands
+ */
+async function executeSlashCommand(input, state) {
+    const [cmd, ...args] = input.slice(1).split(/\s+/);
+    switch (cmd.toLowerCase()) {
+        case 'help':
+        case 'h':
+            showHelp();
+            break;
+        case 'exit':
+        case 'quit':
+        case 'q':
+            state.running = false;
+            console.log(chalk.gray('Goodbye!'));
+            process.exit(0);
+            break;
+        case 'clear':
+        case 'cls':
+            console.clear();
+            showBanner(CLI_VERSION, {
+                hasApiKey: Boolean(state.config.apiKey),
+                apiUrl: state.config.apiUrl,
+                activeProject: state.config.activeProjectId,
+            });
+            break;
+        case 'status':
+            showStatus(state);
+            break;
+        case 'history':
+            showHistory(state);
+            break;
+        case 'use':
+            if (args[0]) {
+                await setActiveProject(args[0], state);
+            }
+            else {
+                error('Usage: /use <project-id>');
+            }
+            break;
+        default:
+            error(`Unknown command: /${cmd}`, 'Type /help for available commands');
+    }
+}
+/**
+ * Handle project commands
+ */
+async function handleProject(args, state) {
+    const subcmd = args[0]?.toLowerCase();
+    if (!hasAuth(state.config)) {
+        error('Not authenticated', 'Run: auth login <api-key>');
+        return;
+    }
+    switch (subcmd) {
+        case 'list':
+        case 'ls':
+            await listProjects(state);
+            break;
+        case 'create':
+            const formatIdx = args.indexOf('--format');
+            const formatValue = formatIdx >= 0 ? args[formatIdx + 1] : undefined;
+            const nameIdx = args.indexOf('--name');
+            const nameEnd = formatIdx > 0 ? formatIdx : undefined;
+            const name = nameIdx >= 0 ? args.slice(nameIdx + 1, nameEnd).join(' ') : args.slice(1, nameEnd).join(' ');
+            if (!name) {
+                error('Usage: project create <name> or project create --name "My Project"');
+                return;
+            }
+            await createProject(name, state, formatValue);
+            break;
+        case 'use':
+            if (args[1]) {
+                await setActiveProject(args[1], state);
+            }
+            else {
+                error('Usage: project use <id>');
+            }
+            break;
+        case 'current':
+        case 'info':
+            await showCurrentProject(state);
+            break;
+        case 'delete':
+        case 'rm':
+            if (args[1]) {
+                await deleteProject(args[1], state);
+            }
+            else {
+                error('Usage: project delete <id>');
+            }
+            break;
+        default:
+            console.log('Project commands:');
+            console.log('  project list          List all projects');
+            console.log('  project create <name> [--format portrait|landscape|square]  Create a new project');
+            console.log('  project use <id>      Set active project');
+            console.log('  project current       Show active project');
+            console.log('  project delete <id>   Delete a project');
+    }
+}
+/**
+ * Handle scenes commands
+ */
+async function handleScenes(args, state) {
+    const subcmd = args[0]?.toLowerCase();
+    if (!hasAuth(state.config)) {
+        error('Not authenticated', 'Run: auth login <api-key>');
+        return;
+    }
+    if (!state.config.activeProjectId) {
+        error('No active project', 'Run: project use <id>');
+        return;
+    }
+    switch (subcmd) {
+        case 'list':
+        case 'ls':
+            await listScenes(state);
+            break;
+        case 'code':
+            const sceneId = args[1];
+            await showSceneCode(sceneId, state);
+            break;
+        case 'delete':
+        case 'rm':
+            if (args[1]) {
+                await deleteScene(args[1], state);
+            }
+            else {
+                error('Usage: scenes delete <scene-id>');
+            }
+            break;
+        case 'set-code':
+            if (args[1]) {
+                console.log(chalk.gray('set-code is best used from the CLI directly:'));
+                console.log(chalk.cyan(`  baz scenes set-code ${args[1]} --file <path>`));
+                console.log(chalk.cyan(`  baz scenes set-code ${args[1]} --code "<tsx>"`));
+                console.log(chalk.gray('  Or pipe: cat scene.tsx | baz scenes set-code ' + args[1]));
+            }
+            else {
+                error('Usage: scenes set-code <scene-id> --file <path>');
+            }
+            break;
+        default:
+            console.log('Scene commands:');
+            console.log('  scenes list              List all scenes');
+            console.log('  scenes code <id>         Show scene code');
+            console.log('  scenes code --all        Show all scene code');
+            console.log('  scenes set-code <id>     Replace scene code (use from CLI)');
+            console.log('  scenes delete <id>       Delete a scene');
+    }
+}
+/**
+ * Handle auth commands
+ */
+async function handleAuth(args, state) {
+    const subcmd = args[0]?.toLowerCase();
+    switch (subcmd) {
+        case 'login':
+            const apiKey = args[1];
+            if (!apiKey) {
+                error('Usage: auth login <api-key>');
+                return;
+            }
+            if (!apiKey.startsWith('baz_sk_')) {
+                error('Invalid API key format', 'API keys should start with "baz_sk_"');
+                return;
+            }
+            saveConfig({ apiKey });
+            state.config.apiKey = apiKey;
+            success('API key saved');
+            break;
+        case 'logout':
+            saveConfig({ apiKey: undefined });
+            state.config.apiKey = undefined;
+            success('Logged out');
+            break;
+        case 'status':
+            showStatus(state);
+            break;
+        default:
+            console.log('Auth commands:');
+            console.log('  auth login <key>  Configure API key');
+            console.log('  auth logout       Clear credentials');
+            console.log('  auth status       Show auth status');
+    }
+}
+/**
+ * Handle prompt (send to AI agent)
+ */
+async function handlePrompt(prompt, state) {
+    if (!hasAuth(state.config)) {
+        error('Not authenticated', 'Run: auth login <api-key>');
+        return;
+    }
+    if (!state.config.activeProjectId) {
+        error('No active project', 'Run: project use <id> or project create <name>');
+        return;
+    }
+    console.log(chalk.gray(`Project: ${state.config.activeProjectId.slice(0, 8)}`));
+    console.log();
+    let currentSpinner = null;
+    try {
+        const result = await streamGeneration(state.config, {
+            projectId: state.config.activeProjectId,
+            prompt,
+            mode: 'agent',
+            onEvent: (event) => {
+                switch (event.type) {
+                    case 'thinking':
+                        if (currentSpinner)
+                            currentSpinner.stop();
+                        currentSpinner = ora(chalk.blue('Thinking...')).start();
+                        break;
+                    case 'tool_use':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        currentSpinner = ora(chalk.yellow(`Using: ${event.tool}`)).start();
+                        break;
+                    case 'code_gen':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        currentSpinner = ora(chalk.magenta('Generating code...')).start();
+                        break;
+                    case 'compile':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        currentSpinner = ora(chalk.cyan('Compiling...')).start();
+                        break;
+                    case 'scene_created':
+                        if (currentSpinner)
+                            currentSpinner.succeed(chalk.green(`✓ Created: ${event.sceneName || event.sceneId}`));
+                        currentSpinner = null;
+                        break;
+                    case 'scene_updated':
+                        if (currentSpinner)
+                            currentSpinner.succeed(chalk.green(`✓ Updated: ${event.sceneName || event.sceneId}`));
+                        currentSpinner = null;
+                        break;
+                    case 'error':
+                        if (currentSpinner)
+                            currentSpinner.fail(chalk.red(event.message));
+                        currentSpinner = null;
+                        break;
+                    case 'complete':
+                        if (currentSpinner)
+                            currentSpinner.succeed();
+                        currentSpinner = null;
+                        break;
+                }
+            },
+        });
+        if (currentSpinner)
+            currentSpinner.stop();
+        if (result.success) {
+            console.log();
+            success('Done');
+            if (result.scenesCreated.length > 0) {
+                console.log(`  Created: ${result.scenesCreated.length} scene(s)`);
+            }
+            if (result.scenesUpdated.length > 0) {
+                console.log(`  Updated: ${result.scenesUpdated.length} scene(s)`);
+            }
+            if (result.summary) {
+                console.log();
+                console.log(chalk.gray(result.summary));
+            }
+        }
+        else {
+            error('Agent failed');
+            if (result.errors?.length > 0) {
+                result.errors.forEach((e) => console.log(chalk.red(`  - ${e}`)));
+            }
+        }
+    }
+    catch (err) {
+        if (currentSpinner)
+            currentSpinner.fail();
+        throw err;
+    }
+}
+// ============================================
+// Command implementations
+// ============================================
+async function listProjects(state) {
+    const s = status('Loading projects');
+    try {
+        const result = await apiRequest(state.config, 'project.list', { limit: 20 });
+        s.done();
+        const projects = Array.isArray(result) ? result : (result.projects || []);
+        if (projects.length === 0) {
+            console.log(chalk.gray('No projects. Create one with: project create <name>'));
+            return;
+        }
+        const rows = projects.map((p) => {
+            const isActive = p.id === state.config.activeProjectId;
+            const marker = isActive ? chalk.green('→') : ' ';
+            const title = p.title || p.name || 'Untitled';
+            const displayName = isActive ? chalk.bold(title) : title;
+            const sceneCount = p.props?.scenes?.length || p.sceneCount || 0;
+            return [marker, p.id.slice(0, 8), displayName, `${sceneCount}`, formatRelativeTime(p.updatedAt)];
+        });
+        table(['', 'ID', 'Name', 'Scenes', 'Updated'], rows);
+    }
+    catch (err) {
+        s.fail();
+        throw err;
+    }
+}
+async function createProject(name, state, format) {
+    const s = status('Creating project');
+    const normalizedFormat = format?.toLowerCase();
+    const validFormat = normalizedFormat && ['landscape', 'portrait', 'square'].includes(normalizedFormat)
+        ? normalizedFormat
+        : undefined;
+    const result = await apiRequest(state.config, 'project.create', {
+        title: name,
+        initialMessage: name,
+        ...(validFormat ? { format: validFormat } : {}),
+    });
+    s.done();
+    const projectId = result.projectId || result.id;
+    if (!projectId) {
+        error('Failed to create project');
+        return;
+    }
+    const finalTitle = result?.title || name;
+    // Auto-activate
+    saveConfig({ activeProjectId: projectId });
+    state.config.activeProjectId = projectId;
+    success(`Created: ${chalk.bold(finalTitle)}`);
+    console.log(`  ID: ${projectId}`);
+    if (validFormat) {
+        console.log(`  Format: ${validFormat}`);
+    }
+    if (finalTitle !== name) {
+        console.log(chalk.gray('  Title adjusted to keep it unique for your account'));
+    }
+    console.log(chalk.gray('  Set as active project'));
+}
+async function setActiveProject(id, state) {
+    // Expand short IDs
+    let projectId = id;
+    // If it looks like a short ID, try to find the full one
+    if (id.length < 20) {
+        const s = status('Finding project');
+        try {
+            const result = await apiRequest(state.config, 'project.list', { limit: 100 });
+            const projects = Array.isArray(result) ? result : (result.projects || []);
+            const match = projects.find((p) => p.id.startsWith(id));
+            if (match) {
+                projectId = match.id;
+            }
+            s.done();
+        }
+        catch {
+            s.fail();
+        }
+    }
+    // Verify project exists
+    const s = status('Verifying');
+    try {
+        const result = await apiRequest(state.config, 'project.getById', { id: projectId });
+        s.done();
+        saveConfig({ activeProjectId: projectId });
+        state.config.activeProjectId = projectId;
+        success(`Active: ${chalk.bold(result.title || result.name || 'Untitled')} (${projectId.slice(0, 8)})`);
+    }
+    catch (err) {
+        s.fail();
+        error(`Project not found: ${id}`);
+    }
+}
+async function showCurrentProject(state) {
+    if (!state.config.activeProjectId) {
+        console.log(chalk.gray('No active project.'));
+        return;
+    }
+    const s = status('Fetching');
+    const result = await apiRequest(state.config, 'project.getById', { id: state.config.activeProjectId });
+    s.done();
+    console.log(chalk.cyan('Active Project'));
+    console.log(`  Name: ${chalk.bold(result.title || result.name || 'Untitled')}`);
+    console.log(`  ID: ${result.id}`);
+    console.log(`  Scenes: ${result.props?.scenes?.length || 0}`);
+    console.log(`  Updated: ${formatRelativeTime(result.updatedAt)}`);
+}
+async function deleteProject(id, state) {
+    const s = status('Deleting');
+    await apiRequest(state.config, 'project.delete', { id });
+    s.done();
+    if (state.config.activeProjectId === id) {
+        saveConfig({ activeProjectId: undefined });
+        state.config.activeProjectId = undefined;
+    }
+    success(`Deleted: ${id}`);
+}
+async function listScenes(state) {
+    const s = status('Fetching scenes');
+    const project = await apiRequest(state.config, 'project.getById', { id: state.config.activeProjectId });
+    s.done();
+    const scenes = project.props?.scenes || [];
+    if (scenes.length === 0) {
+        console.log(chalk.gray('No scenes. Create one by typing a prompt.'));
+        return;
+    }
+    const fps = 30;
+    let totalFrames = 0;
+    scenes.forEach((s) => totalFrames += s.durationInFrames || 0);
+    console.log(chalk.gray(`${scenes.length} scenes, ${formatDuration(totalFrames / fps)} total`));
+    console.log();
+    const rows = scenes.map((s, i) => {
+        const dur = (s.durationInFrames || 0) / fps;
+        const status = s.compilationError ? chalk.red('✗') : chalk.green('✓');
+        return [String(i + 1), s.id?.slice(0, 8) || '?', s.name || 'Untitled', formatDuration(dur), status];
+    });
+    table(['#', 'ID', 'Name', 'Duration', ''], rows);
+}
+async function showSceneCode(sceneId, state) {
+    const s = status('Fetching');
+    const project = await apiRequest(state.config, 'project.getById', { id: state.config.activeProjectId });
+    s.done();
+    const scenes = project.props?.scenes || [];
+    if (!sceneId || sceneId === '--all') {
+        // Show all
+        for (const scene of scenes) {
+            console.log(chalk.cyan(`// === ${scene.name || 'Untitled'} (${scene.id?.slice(0, 8)}) ===`));
+            console.log(scene.tsxCode || '// No code');
+            console.log();
+        }
+    }
+    else {
+        // Find by ID or index
+        let scene = scenes.find((s) => s.id === sceneId || s.id?.startsWith(sceneId));
+        if (!scene && !isNaN(parseInt(sceneId))) {
+            scene = scenes[parseInt(sceneId) - 1]; // 1-indexed
+        }
+        if (!scene) {
+            error(`Scene not found: ${sceneId}`);
+            return;
+        }
+        console.log(chalk.cyan(`// ${scene.name || 'Untitled'}`));
+        console.log(scene.tsxCode || '// No code');
+    }
+}
+async function deleteScene(sceneId, state) {
+    if (!state.config.activeProjectId) {
+        error('No active project', 'Run: project use <id>');
+        return;
+    }
+    const s = status('Deleting');
+    await apiRequest(state.config, 'scenes.deleteScene', {
+        projectId: state.config.activeProjectId,
+        sceneId,
+    });
+    s.done();
+    success(`Deleted scene: ${sceneId}`);
+}
+// ============================================
+// UI helpers
+// ============================================
+function showHelp() {
+    console.log(chalk.cyan('Bazaar CLI - Interactive Mode'));
+    console.log();
+    console.log(chalk.bold('Prompts:'));
+    console.log('  Just type to send a prompt to the AI agent');
+    console.log('  Example: "Add a title scene with my logo"');
+    console.log();
+    console.log(chalk.bold('Commands:'));
+    console.log('  project list          List projects');
+    console.log('  project create <name> Create project');
+    console.log('  project use <id>      Set active project');
+    console.log('  project current       Show active project');
+    console.log();
+    console.log('  scenes list           List scenes');
+    console.log('  scenes code <id>      Show scene code');
+    console.log('  scenes delete <id>    Delete scene');
+    console.log();
+    console.log('  auth login <key>      Set API key');
+    console.log('  auth status           Show auth status');
+    console.log();
+    console.log(chalk.bold('Slash Commands:'));
+    console.log('  /help                 Show this help');
+    console.log('  /status               Show current status');
+    console.log('  /use <id>             Quick set project');
+    console.log('  /clear                Clear screen');
+    console.log('  /history              Show command history');
+    console.log('  /exit                 Exit (or Ctrl+D)');
+}
+function showStatus(state) {
+    console.log(chalk.cyan('Status'));
+    console.log();
+    if (hasAuth(state.config)) {
+        console.log(chalk.green('✓'), 'Authenticated');
+        console.log(`  Key: baz_sk_****${state.config.apiKey?.slice(-4) || ''}`);
+    }
+    else {
+        console.log(chalk.yellow('○'), 'Not authenticated');
+    }
+    console.log();
+    console.log(`API: ${state.config.apiUrl}`);
+    console.log(`Project: ${state.config.activeProjectId?.slice(0, 8) || chalk.gray('none')}`);
+    console.log(`Config: ${getConfigPath()}`);
+}
+function showHistory(state) {
+    if (state.history.length === 0) {
+        console.log(chalk.gray('No history yet.'));
+        return;
+    }
+    console.log(chalk.cyan('History'));
+    state.history.slice(-20).forEach((cmd, i) => {
+        console.log(chalk.gray(`${i + 1}.`), cmd);
+    });
+}
+/**
+ * Show full project status with timeline
+ */
+async function showProjectStatus(state) {
+    if (!hasAuth(state.config)) {
+        error('Not authenticated', 'Run: auth login <api-key>');
+        return;
+    }
+    if (!state.config.activeProjectId) {
+        error('No active project', 'Run: project use <id>');
+        return;
+    }
+    const s = status('Fetching project');
+    const project = await apiRequest(state.config, 'project.getById', { id: state.config.activeProjectId });
+    s.done();
+    const scenes = project.props?.scenes || [];
+    const fps = 30;
+    // Calculate stats
+    let totalFrames = 0;
+    let errorCount = 0;
+    const trackSet = new Set();
+    scenes.forEach((scene) => {
+        const end = (scene.startFrame || 0) + (scene.durationInFrames || 0);
+        if (end > totalFrames)
+            totalFrames = end;
+        if (scene.compilationError)
+            errorCount++;
+        trackSet.add(scene.track ?? 0);
+    });
+    const totalDuration = totalFrames / fps;
+    const trackCount = trackSet.size || 1;
+    // Print status
+    console.log();
+    console.log(chalk.bold('Project Status'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log();
+    console.log(`  ${chalk.dim('Project:')}  ${project.title || 'Untitled'}`);
+    console.log(`  ${chalk.dim('ID:')}       ${state.config.activeProjectId.slice(0, 8)}...`);
+    console.log();
+    // Stats
+    const statsLine = `Scenes: ${chalk.bold(scenes.length)}  |  Tracks: ${chalk.bold(trackCount)}  |  Duration: ${chalk.bold(formatDuration(totalDuration))}`;
+    const errorPart = errorCount > 0 ? chalk.red(`  |  Errors: ${errorCount}`) : chalk.green('  |  ✓ OK');
+    console.log(`  ${statsLine}${errorPart}`);
+    console.log();
+    // Simple ASCII timeline
+    if (scenes.length > 0 && totalFrames > 0) {
+        const width = 40;
+        const sortedTracks = Array.from(trackSet).sort((a, b) => a - b);
+        console.log(chalk.dim('  Timeline:'));
+        for (const trackNum of sortedTracks) {
+            const trackScenes = scenes.filter((s) => (s.track ?? 0) === trackNum);
+            let bar = '·'.repeat(width);
+            for (const scene of trackScenes) {
+                const startFrame = scene.startFrame || 0;
+                const duration = scene.durationInFrames || 0;
+                const startPos = Math.floor((startFrame / totalFrames) * width);
+                const endPos = Math.min(Math.ceil(((startFrame + duration) / totalFrames) * width), width);
+                const sceneWidth = Math.max(1, endPos - startPos);
+                const char = scene.compilationError ? '!' : '█';
+                const block = char.repeat(sceneWidth);
+                bar = bar.slice(0, startPos) + block + bar.slice(startPos + sceneWidth);
+            }
+            const coloredBar = bar.replace(/!/g, chalk.red('!')).replace(/█/g, chalk.green('█'));
+            console.log(`  T${trackNum} │${coloredBar}│`);
+        }
+        console.log(`     └${'─'.repeat(width)}┘`);
+        console.log(`      ${chalk.dim('0:00')}${' '.repeat(width - 8)}${chalk.dim(formatDuration(totalDuration))}`);
+        console.log();
+    }
+    // Scene list (abbreviated)
+    if (scenes.length > 0) {
+        console.log(chalk.dim('  Scenes:'));
+        const maxShow = 5;
+        const showScenes = scenes.slice(0, maxShow);
+        showScenes.forEach((scene, i) => {
+            const dur = (scene.durationInFrames || 0) / fps;
+            const status = scene.compilationError ? chalk.red('✗') : chalk.green('✓');
+            const track = scene.track ?? 0;
+            console.log(`    ${status} ${(scene.name || 'Untitled').padEnd(20).slice(0, 20)} ${chalk.dim(`${formatDuration(dur)} T${track}`)}`);
+        });
+        if (scenes.length > maxShow) {
+            console.log(chalk.dim(`    ... and ${scenes.length - maxShow} more`));
+        }
+        console.log();
+    }
+}