bazaar.it 0.1.0 → 0.2.0

package/dist/lib/banner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Display the startup banner
+ */
+export declare function showBanner(version: string, configInfo?: {
+    hasApiKey: boolean;
+    apiUrl: string;
+    activeProject?: string;
+}): void;
+/**
+ * Show a compact banner for subcommands
+ */
+export declare function showCompactBanner(): void;

package/dist/lib/banner.js

@@ -0,0 +1,69 @@
+import chalk from 'chalk';
+// Big chunky ASCII art for "BAZ"
+const BAZ_ASCII = `
+██████╗  █████╗ ███████╗
+██╔══██╗██╔══██╗╚══███╔╝
+██████╔╝███████║  ███╔╝
+██╔══██╗██╔══██║ ███╔╝
+██████╔╝██║  ██║███████╗
+╚═════╝ ╚═╝  ╚═╝╚══════╝
+`.trim();
+// Gradient colors (purple -> magenta -> cyan)
+const gradientColors = [
+    '#a855f7', // purple
+    '#c084fc', // light purple
+    '#e879f9', // magenta
+    '#f0abfc', // pink
+    '#67e8f9', // cyan
+];
+/**
+ * Apply gradient colors to each line of ASCII art
+ */
+function applyGradient(text) {
+    const lines = text.split('\n');
+    return lines.map((line, lineIndex) => {
+        // Color varies by line for vertical gradient effect
+        const colorIndex = Math.min(lineIndex, gradientColors.length - 1);
+        const color = gradientColors[colorIndex];
+        return chalk.hex(color)(line);
+    }).join('\n');
+}
+/**
+ * Display the startup banner
+ */
+export function showBanner(version, configInfo) {
+    console.log();
+    console.log(applyGradient(BAZ_ASCII));
+    console.log();
+    console.log(chalk.gray('  Bazaar CLI'), chalk.white(`v${version}`), chalk.gray('·'), chalk.gray('AI-Powered Video Generation'));
+    // Show config status if available
+    if (configInfo) {
+        const parts = [];
+        if (configInfo.hasApiKey) {
+            parts.push(chalk.green('✓') + chalk.gray(' authenticated'));
+        }
+        else {
+            parts.push(chalk.yellow('○') + chalk.gray(' not authenticated'));
+        }
+        if (configInfo.activeProject) {
+            // Truncate long UUIDs to first 8 chars
+            const shortId = configInfo.activeProject.length > 12
+                ? configInfo.activeProject.slice(0, 8)
+                : configInfo.activeProject;
+            parts.push(chalk.cyan('▸') + chalk.gray(` project: ${shortId}`));
+        }
+        if (configInfo.apiUrl !== 'https://bazaar.it') {
+            parts.push(chalk.gray(`→ ${configInfo.apiUrl}`));
+        }
+        if (parts.length > 0) {
+            console.log(chalk.gray('  ') + parts.join(chalk.gray('  |  ')));
+        }
+    }
+    console.log();
+}
+/**
+ * Show a compact banner for subcommands
+ */
+export function showCompactBanner() {
+    console.log(chalk.hex('#a855f7')('▸'), chalk.bold('baz'), chalk.gray('—'), chalk.gray('bazaar.it'));
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,33 @@
+export interface Config {
+    apiKey?: string;
+    apiUrl: string;
+    activeProjectId?: string;
+    defaults?: {
+        mode?: 'agent' | 'agent-max' | 'multi-scene';
+        outputFormat?: 'pretty' | 'json';
+    };
+}
+/**
+ * Load config from file, environment, and CLI options
+ */
+export declare function loadConfig(options?: {
+    configPath?: string;
+    apiUrl?: string;
+    projectId?: string;
+}): Config;
+/**
+ * Save config to file
+ */
+export declare function saveConfig(updates: Partial<Config>): void;
+/**
+ * Get active project ID or throw if not set
+ */
+export declare function getProjectId(config: Config, override?: string): string;
+/**
+ * Check if config has valid API key
+ */
+export declare function hasAuth(config: Config): boolean;
+/**
+ * Get config file path for display
+ */
+export declare function getConfigPath(): string;

package/dist/lib/config.js

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const DEFAULT_CONFIG = {
+    apiUrl: 'https://bazaar.it',
+    defaults: {
+        mode: 'agent',
+        outputFormat: 'pretty',
+    },
+};
+const CONFIG_DIR = join(homedir(), '.bazaar');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+/**
+ * Load config from file, environment, and CLI options
+ */
+export function loadConfig(options) {
+    // Start with defaults
+    let config = { ...DEFAULT_CONFIG };
+    // Load from file
+    const configPath = options?.configPath || CONFIG_FILE;
+    if (existsSync(configPath)) {
+        try {
+            const fileContent = readFileSync(configPath, 'utf-8');
+            const fileConfig = JSON.parse(fileContent);
+            config = { ...config, ...fileConfig };
+        }
+        catch (err) {
+            // Ignore parse errors, use defaults
+        }
+    }
+    // Override with environment variables
+    if (process.env.BAZ_API_KEY) {
+        config.apiKey = process.env.BAZ_API_KEY;
+    }
+    if (process.env.BAZ_API_URL) {
+        config.apiUrl = process.env.BAZ_API_URL;
+    }
+    if (process.env.BAZ_PROJECT_ID) {
+        config.activeProjectId = process.env.BAZ_PROJECT_ID;
+    }
+    if (process.env.BAZ_JSON === '1') {
+        config.defaults = { ...config.defaults, outputFormat: 'json' };
+    }
+    // Override with CLI options
+    if (options?.apiUrl) {
+        config.apiUrl = options.apiUrl;
+    }
+    if (options?.projectId) {
+        config.activeProjectId = options.projectId;
+    }
+    return config;
+}
+/**
+ * Save config to file
+ */
+export function saveConfig(updates) {
+    // Ensure directory exists
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    // Load existing config
+    let config = { ...DEFAULT_CONFIG };
+    if (existsSync(CONFIG_FILE)) {
+        try {
+            const fileContent = readFileSync(CONFIG_FILE, 'utf-8');
+            config = { ...config, ...JSON.parse(fileContent) };
+        }
+        catch {
+            // Ignore
+        }
+    }
+    // Apply updates
+    config = { ...config, ...updates };
+    // Write back
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+/**
+ * Get active project ID or throw if not set
+ */
+export function getProjectId(config, override) {
+    const projectId = override || config.activeProjectId;
+    if (!projectId) {
+        throw new Error('No active project. Run: baz project use <id>\n' +
+            'Or pass --project-id <id>');
+    }
+    return projectId;
+}
+/**
+ * Check if config has valid API key
+ */
+export function hasAuth(config) {
+    return Boolean(config.apiKey);
+}
+/**
+ * Get config file path for display
+ */
+export function getConfigPath() {
+    return CONFIG_FILE;
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,52 @@
+export interface OutputOptions {
+    json?: boolean;
+    verbose?: boolean;
+    compact?: boolean;
+}
+/**
+ * Output data in JSON or pretty format
+ * When compact=true, outputs minified JSON (saves tokens for agents)
+ */
+export declare function output(data: unknown, options: OutputOptions): void;
+/**
+ * Output NDJSON line (for streaming)
+ * Always compact - no pretty printing for streams
+ */
+export declare function outputNDJSON(data: unknown): void;
+/**
+ * Pretty print any data structure
+ */
+export declare function prettyPrint(data: unknown): void;
+/**
+ * Print success message
+ */
+export declare function success(message: string): void;
+/**
+ * Print error message
+ */
+export declare function error(message: string, suggestion?: string): void;
+/**
+ * Print warning message
+ */
+export declare function warn(message: string): void;
+/**
+ * Print info message
+ */
+export declare function info(message: string): void;
+/**
+ * Print a table
+ */
+export declare function table(headers: string[], rows: string[][]): void;
+/**
+ * Format duration in mm:ss
+ */
+export declare function formatDuration(seconds: number): string;
+/**
+ * Format relative time (e.g., "2 hours ago")
+ */
+/**
+ * Prompt the user for confirmation before a destructive action.
+ * In non-interactive (piped/agent) mode, returns false — callers must use --force.
+ */
+export declare function confirmAction(message: string): Promise<boolean>;
+export declare function formatRelativeTime(date: Date | string): string;

package/dist/lib/output.js

@@ -0,0 +1,162 @@
+import chalk from 'chalk';
+import * as readline from 'readline';
+/**
+ * Output data in JSON or pretty format
+ * When compact=true, outputs minified JSON (saves tokens for agents)
+ */
+export function output(data, options) {
+    if (options.json) {
+        // Compact mode: no whitespace (token-efficient for agents)
+        // Normal JSON mode: pretty-printed with 2-space indent
+        const indent = options.compact ? undefined : 2;
+        console.log(JSON.stringify(data, null, indent));
+    }
+    else {
+        prettyPrint(data);
+    }
+}
+/**
+ * Output NDJSON line (for streaming)
+ * Always compact - no pretty printing for streams
+ */
+export function outputNDJSON(data) {
+    console.log(JSON.stringify(data));
+}
+/**
+ * Pretty print any data structure
+ */
+export function prettyPrint(data) {
+    if (data === null || data === undefined) {
+        return;
+    }
+    if (typeof data === 'string') {
+        console.log(data);
+        return;
+    }
+    if (Array.isArray(data)) {
+        data.forEach((item, i) => {
+            console.log(`${chalk.gray(`${i + 1}.`)} ${formatValue(item)}`);
+        });
+        return;
+    }
+    if (typeof data === 'object') {
+        for (const [key, value] of Object.entries(data)) {
+            console.log(`${chalk.cyan(key)}: ${formatValue(value)}`);
+        }
+        return;
+    }
+    console.log(String(data));
+}
+function formatValue(value) {
+    if (value === null || value === undefined) {
+        return chalk.gray('null');
+    }
+    if (typeof value === 'boolean') {
+        return value ? chalk.green('✓') : chalk.red('✗');
+    }
+    if (typeof value === 'number') {
+        return chalk.yellow(String(value));
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.length} items]`;
+    }
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+/**
+ * Print success message
+ */
+export function success(message) {
+    console.log(chalk.green('✓'), message);
+}
+/**
+ * Print error message
+ */
+export function error(message, suggestion) {
+    console.error(chalk.red('Error:'), message);
+    if (suggestion) {
+        console.error(chalk.gray('Suggestion:'), suggestion);
+    }
+}
+/**
+ * Print warning message
+ */
+export function warn(message) {
+    console.warn(chalk.yellow('⚠'), message);
+}
+/**
+ * Print info message
+ */
+export function info(message) {
+    console.log(chalk.blue('ℹ'), message);
+}
+/**
+ * Print a table
+ */
+export function table(headers, rows) {
+    // Calculate column widths
+    const widths = headers.map((h, i) => {
+        const colValues = [h, ...rows.map(r => r[i] || '')];
+        return Math.max(...colValues.map(v => v.length));
+    });
+    // Print header
+    const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join('  ');
+    console.log(chalk.bold(headerLine));
+    console.log(chalk.gray('─'.repeat(headerLine.length)));
+    // Print rows
+    for (const row of rows) {
+        const rowLine = row.map((cell, i) => (cell || '').padEnd(widths[i])).join('  ');
+        console.log(rowLine);
+    }
+}
+/**
+ * Format duration in mm:ss
+ */
+export function formatDuration(seconds) {
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${mins}:${secs.toString().padStart(2, '0')}`;
+}
+/**
+ * Format relative time (e.g., "2 hours ago")
+ */
+/**
+ * Prompt the user for confirmation before a destructive action.
+ * In non-interactive (piped/agent) mode, returns false — callers must use --force.
+ */
+export async function confirmAction(message) {
+    if (!process.stdin.isTTY) {
+        return false;
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(`${chalk.yellow('⚠')} ${message} ${chalk.gray('[y/N]')} `, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}
+export function formatRelativeTime(date) {
+    const now = new Date();
+    const then = new Date(date);
+    const diffMs = now.getTime() - then.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffMins < 1)
+        return 'just now';
+    if (diffMins < 60)
+        return `${diffMins} minute${diffMins > 1 ? 's' : ''} ago`;
+    if (diffHours < 24)
+        return `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`;
+    if (diffDays === 1)
+        return 'yesterday';
+    if (diffDays < 7)
+        return `${diffDays} days ago`;
+    return then.toLocaleDateString();
+}

package/dist/lib/project-state.d.ts

@@ -0,0 +1,52 @@
+export interface NormalizedScene {
+    id: string;
+    name: string;
+    order: number;
+    track: number;
+    startFrame: number;
+    durationFrames: number;
+    endFrame: number;
+    hasCode: boolean;
+    hasCompilationError: boolean;
+    compilationError?: string;
+}
+export interface LayoutIssue {
+    code: string;
+    message: string;
+    sceneId?: string;
+    track?: number;
+    startFrame?: number;
+    endFrame?: number;
+}
+export interface ProjectValidationResult {
+    valid: boolean;
+    errors: LayoutIssue[];
+    warnings: LayoutIssue[];
+    summary: {
+        sceneCount: number;
+        trackCount: number;
+        totalFrames: number;
+        totalDurationSeconds: number;
+        compilationErrorCount: number;
+    };
+}
+type ProjectMeta = {
+    format?: string;
+    width?: number;
+    height?: number;
+} | undefined;
+export declare function normalizeScenes(rawScenes: unknown[], options?: {
+    codeOmitted?: boolean;
+}): NormalizedScene[];
+export declare function validateProjectStructure(scenes: NormalizedScene[], options?: {
+    fps?: number;
+    meta?: ProjectMeta;
+}): ProjectValidationResult;
+export declare function buildSearchCorpus(scenes: NormalizedScene[], options?: {
+    projectTitle?: string;
+    projectFormat?: string;
+    recipePrompts?: string[];
+    voiceovers?: string[];
+    sceneCodeById?: Record<string, string | undefined>;
+}): string;
+export {};

package/dist/lib/project-state.js

@@ -0,0 +1,178 @@
+const FORMAT_DIMENSIONS = {
+    landscape: { width: 1920, height: 1080 },
+    portrait: { width: 1080, height: 1920 },
+    square: { width: 1080, height: 1080 },
+};
+export function normalizeScenes(rawScenes, options) {
+    return rawScenes.map((scene, index) => {
+        const id = String(scene.id ?? `scene-${index + 1}`);
+        const name = String(scene.name ?? scene.data?.name ?? `Scene ${index + 1}`);
+        const startFrame = Number(scene.start ?? scene.props?.start ?? scene.startFrame ?? 0);
+        const durationFrames = Number(scene.duration ?? scene.durationInFrames ?? 0);
+        const order = Number(scene.order ?? index);
+        const track = Number(scene.track ?? 0);
+        // When code is omitted from the response, tsxCode will be undefined --
+        // but the schema is NOT NULL, so every scene always has code.
+        const hasCode = options?.codeOmitted
+            ? true
+            : Boolean(scene.tsxCode || scene.code || scene.data?.code);
+        const compilationError = scene.compilationError ?? scene.compilation_error;
+        return {
+            id,
+            name,
+            order,
+            track,
+            startFrame,
+            durationFrames,
+            endFrame: startFrame + durationFrames,
+            hasCode,
+            hasCompilationError: Boolean(compilationError),
+            compilationError: typeof compilationError === "string" ? compilationError : undefined,
+        };
+    });
+}
+export function validateProjectStructure(scenes, options) {
+    const fps = options?.fps ?? 30;
+    const errors = [];
+    const warnings = [];
+    if (scenes.length === 0) {
+        warnings.push({
+            code: "NO_SCENES",
+            message: "Project has no scenes.",
+        });
+    }
+    for (const scene of scenes) {
+        if (!Number.isFinite(scene.startFrame) || scene.startFrame < 0) {
+            errors.push({
+                code: "INVALID_START",
+                message: `Scene "${scene.name}" has invalid start frame (${scene.startFrame}).`,
+                sceneId: scene.id,
+                track: scene.track,
+                startFrame: scene.startFrame,
+            });
+        }
+        if (!Number.isFinite(scene.durationFrames) || scene.durationFrames <= 0) {
+            errors.push({
+                code: "INVALID_DURATION",
+                message: `Scene "${scene.name}" has invalid duration (${scene.durationFrames}).`,
+                sceneId: scene.id,
+                track: scene.track,
+                startFrame: scene.startFrame,
+            });
+        }
+        if (!scene.hasCode) {
+            warnings.push({
+                code: "MISSING_CODE",
+                message: `Scene "${scene.name}" has no TSX code.`,
+                sceneId: scene.id,
+                track: scene.track,
+            });
+        }
+        if (scene.hasCompilationError) {
+            errors.push({
+                code: "COMPILATION_ERROR",
+                message: `Scene "${scene.name}" has a compilation error.`,
+                sceneId: scene.id,
+                track: scene.track,
+            });
+        }
+    }
+    // Overlap detection per track.
+    const scenesByTrack = new Map();
+    for (const scene of scenes) {
+        if (!scenesByTrack.has(scene.track))
+            scenesByTrack.set(scene.track, []);
+        scenesByTrack.get(scene.track).push(scene);
+    }
+    for (const [track, trackScenes] of scenesByTrack.entries()) {
+        const ordered = [...trackScenes].sort((a, b) => a.startFrame - b.startFrame || a.order - b.order);
+        for (let i = 1; i < ordered.length; i += 1) {
+            const prev = ordered[i - 1];
+            const curr = ordered[i];
+            if (curr.startFrame < prev.endFrame) {
+                errors.push({
+                    code: "OVERLAP",
+                    message: `Scenes "${prev.name}" and "${curr.name}" overlap on track ${track}.`,
+                    sceneId: curr.id,
+                    track,
+                    startFrame: curr.startFrame,
+                    endFrame: prev.endFrame,
+                });
+            }
+            else if (track === 0 && curr.startFrame > prev.endFrame) {
+                warnings.push({
+                    code: "GAP",
+                    message: `Gap detected on track 0 between "${prev.name}" and "${curr.name}".`,
+                    sceneId: curr.id,
+                    track,
+                    startFrame: prev.endFrame,
+                    endFrame: curr.startFrame,
+                });
+            }
+        }
+        if (track === 0 && ordered.length > 0 && ordered[0].startFrame > 0) {
+            warnings.push({
+                code: "LEADING_GAP",
+                message: `Track 0 starts at frame ${ordered[0].startFrame} instead of 0.`,
+                sceneId: ordered[0].id,
+                track,
+                startFrame: 0,
+                endFrame: ordered[0].startFrame,
+            });
+        }
+    }
+    const format = options?.meta?.format;
+    const width = options?.meta?.width;
+    const height = options?.meta?.height;
+    if (format && FORMAT_DIMENSIONS[format]) {
+        const expected = FORMAT_DIMENSIONS[format];
+        if (width && height && (width !== expected.width || height !== expected.height)) {
+            warnings.push({
+                code: "FORMAT_DIMENSION_MISMATCH",
+                message: `Project format "${format}" expects ${expected.width}x${expected.height}, got ${width}x${height}.`,
+            });
+        }
+    }
+    else if (format) {
+        warnings.push({
+            code: "UNKNOWN_FORMAT",
+            message: `Project format "${format}" is not recognized.`,
+        });
+    }
+    const totalFrames = scenes.reduce((max, scene) => Math.max(max, scene.endFrame), 0);
+    const trackCount = scenesByTrack.size || 0;
+    const compilationErrorCount = scenes.filter((scene) => scene.hasCompilationError).length;
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        summary: {
+            sceneCount: scenes.length,
+            trackCount,
+            totalFrames,
+            totalDurationSeconds: totalFrames / fps,
+            compilationErrorCount,
+        },
+    };
+}
+export function buildSearchCorpus(scenes, options) {
+    const parts = [];
+    if (options?.projectTitle)
+        parts.push(options.projectTitle);
+    if (options?.projectFormat)
+        parts.push(`format:${options.projectFormat}`);
+    for (const scene of scenes) {
+        parts.push(scene.name);
+        parts.push(`track:${scene.track}`);
+        if (options?.sceneCodeById?.[scene.id]) {
+            parts.push(options.sceneCodeById[scene.id] || "");
+        }
+    }
+    for (const prompt of options?.recipePrompts ?? []) {
+        parts.push(prompt);
+    }
+    for (const voiceover of options?.voiceovers ?? []) {
+        parts.push(voiceover);
+    }
+    return parts.join("\n").toLowerCase();
+}