bazaar.it 0.1.0 → 0.2.1

package/dist/index.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { loadConfig } from './lib/config.js';
+import { showBanner } from './lib/banner.js';
+import { projectCommand } from './commands/project.js';
+import { promptCommand } from './commands/prompt.js';
+import { scenesCommand } from './commands/scenes.js';
+import { authCommand } from './commands/auth.js';
+import { exportCommand } from './commands/export.js';
+import { statusCommand } from './commands/status.js';
+import { mediaCommand } from './commands/media.js';
+import { logsCommand } from './commands/logs.js';
+import { recipeCommand } from './commands/recipe.js';
+import { reviewCommand } from './commands/review.js';
+import { contextCommand } from './commands/context.js';
+import { capabilitiesCommand } from './commands/capabilities.js';
+import { loopCommand } from './commands/loop.js';
+import { stateCommand } from './commands/state.js';
+import { verifyCommand } from './commands/verify.js';
+import { mcpCommand } from './commands/mcp.js';
+import { templateCommand } from './commands/template.js';
+import { shareCommand } from './commands/share.js';
+import { startRepl } from './repl.js';
+import { CLI_VERSION } from './lib/version.js';
+// Check for interactive mode
+const args = process.argv.slice(2);
+const agentModeEnv = process.env.BAZ_AGENT === '1';
+const isInteractive = args.includes('-i') || args.includes('--interactive') || args.length === 0;
+// Agent auto-mode: default to JSON + compact + events-only in non-interactive mode
+if (agentModeEnv && !isInteractive) {
+    if (!args.includes('--json')) {
+        process.argv.push('--json');
+    }
+    if (!args.includes('--compact')) {
+        process.argv.push('--compact');
+    }
+    // Auto-enable events-only for streaming commands (skip text/thinking token firehose)
+    // Note: prompt.ts also checks agentModeEnv directly as a fallback
+    if (!args.includes('--events-only') && !args.includes('--no-events-only')) {
+        process.argv.push('--events-only');
+    }
+}
+// If interactive mode (no args or -i flag), start REPL
+if (isInteractive && !args.includes('--help') && !args.includes('-h') && !args.includes('--version') && !args.includes('-v')) {
+    startRepl().catch((err) => {
+        console.error(chalk.red(`Fatal error: ${err.message}`));
+        process.exit(1);
+    });
+}
+else {
+    // Command mode - show banner for help
+    const showHelp = args.includes('--help') || args.includes('-h');
+    if (showHelp) {
+        try {
+            const config = loadConfig();
+            showBanner(CLI_VERSION, {
+                hasApiKey: Boolean(config.apiKey),
+                apiUrl: config.apiUrl,
+                activeProject: config.activeProjectId,
+            });
+        }
+        catch {
+            showBanner(CLI_VERSION);
+        }
+    }
+    runCommandMode();
+}
+function runCommandMode() {
+    const program = new Command();
+    program
+        .name('baz')
+        .description('AI-powered video generation from your terminal')
+        .version(CLI_VERSION, '-v, --version', 'Show version')
+        .option('-i, --interactive', 'Start interactive REPL mode')
+        .option('--json', 'Output as JSON')
+        .option('--compact', 'Compact JSON output (no whitespace, saves tokens)')
+        .option('--verbose', 'Show detailed output')
+        .option('--config <path>', 'Custom config file path')
+        .option('--api-url <url>', 'Override API URL')
+        .option('--project-id <id>', 'Override active project');
+    // Register commands
+    program.addCommand(authCommand);
+    program.addCommand(projectCommand);
+    program.addCommand(promptCommand);
+    program.addCommand(scenesCommand);
+    program.addCommand(exportCommand);
+    program.addCommand(mediaCommand);
+    program.addCommand(logsCommand);
+    program.addCommand(statusCommand);
+    program.addCommand(recipeCommand);
+    program.addCommand(reviewCommand);
+    program.addCommand(contextCommand);
+    program.addCommand(capabilitiesCommand);
+    program.addCommand(loopCommand);
+    program.addCommand(stateCommand);
+    program.addCommand(verifyCommand);
+    program.addCommand(mcpCommand);
+    program.addCommand(templateCommand);
+    program.addCommand(shareCommand);
+    // Global error handler
+    program.exitOverride((err) => {
+        // Handle help display - commander throws with various codes
+        if (err.code === 'commander.help' ||
+            err.code === 'commander.helpDisplayed' ||
+            err.message?.includes('outputHelp')) {
+            process.exit(0);
+        }
+        // Handle version display
+        if (err.code === 'commander.version') {
+            process.exit(0);
+        }
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+    });
+    // Parse and run
+    program.parseAsync(process.argv).catch((err) => {
+        console.error(chalk.red(`Fatal error: ${err.message}`));
+        if (program.opts().verbose) {
+            console.error(err.stack);
+        }
+        process.exit(1);
+    });
+}

package/dist/lib/api.d.ts

@@ -0,0 +1,188 @@
+import type { Config } from './config.js';
+import { type StopReason } from './sse.js';
+/**
+ * Error codes for better CLI error handling
+ * These map to semantic exit codes for agent consumption
+ */
+export declare const ErrorCodes: {
+    readonly AUTH_MISSING: "AUTH_MISSING";
+    readonly AUTH_INVALID: "AUTH_INVALID";
+    readonly AUTH_EXPIRED: "AUTH_EXPIRED";
+    readonly FORBIDDEN: "FORBIDDEN";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly VALIDATION: "VALIDATION";
+    readonly RATE_LIMIT: "RATE_LIMIT";
+    readonly BALANCE: "BALANCE";
+    readonly CAPACITY: "CAPACITY";
+    readonly CONTENT_FILTER: "CONTENT_FILTER";
+    readonly SERVER: "SERVER";
+    readonly NETWORK: "NETWORK";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly UNKNOWN: "UNKNOWN";
+};
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
+/**
+ * Error categories for agent decision-making
+ */
+export type ErrorCategory = 'auth' | 'validation' | 'transient' | 'resource' | 'semantic' | 'fatal';
+/**
+ * Map error codes to categories
+ */
+export declare function getErrorCategory(code: ErrorCode): ErrorCategory;
+/**
+ * Map error codes to exit codes for agent consumption
+ * Based on research: 0=success, 10=transient, 11=capacity, 12=semantic, 13=auth, 64-66=validation, 1=fatal
+ */
+export declare function getExitCode(code: ErrorCode): number;
+/**
+ * Check if error is retryable
+ */
+export declare function isRetryable(code: ErrorCode): boolean;
+/**
+ * Check if error is transient (temporary)
+ */
+export declare function isTransient(code: ErrorCode): boolean;
+/**
+ * Custom API error with agent-friendly metadata
+ * Includes: code, category, retryable, transient, suggestion, retryAfter
+ */
+export declare class ApiError extends Error {
+    code: ErrorCode;
+    category: ErrorCategory;
+    retryable: boolean;
+    transient: boolean;
+    exitCode: number;
+    statusCode?: number;
+    details?: string;
+    suggestion?: string;
+    retryAfter?: number;
+    constructor(message: string, code: ErrorCode, options?: {
+        statusCode?: number;
+        details?: string;
+        suggestion?: string;
+        retryAfter?: number;
+    });
+    /**
+     * Convert to JSON for agent consumption
+     */
+    toJSON(): {
+        details?: string | undefined;
+        suggestion?: string | undefined;
+        retryAfter?: number | undefined;
+        type: string;
+        code: ErrorCode;
+        errorType: ErrorCode;
+        message: string;
+        category: ErrorCategory;
+        retryable: boolean;
+        transient: boolean;
+        exitCode: number;
+    };
+}
+/**
+ * Make a tRPC-style API request
+ *
+ * Since we're calling the server directly without the tRPC client,
+ * we use the HTTP batch format.
+ */
+export declare function apiRequest<T = unknown>(config: Config, procedure: string, input?: unknown): Promise<T>;
+/**
+ * Upload result type
+ */
+export interface UploadResult {
+    url: string;
+    key: string;
+    size: number;
+    type: string;
+    originalName: string;
+}
+/**
+ * Upload an image and return the URL (backward compatible)
+ */
+export declare function uploadImage(config: Config, options: {
+    projectId: string;
+    buffer: Buffer;
+    filename: string;
+}): Promise<string>;
+/**
+ * Upload any media file (image, video, audio) and return full result
+ */
+export declare function uploadMedia(config: Config, options: {
+    projectId: string;
+    buffer: Buffer;
+    filename: string;
+    mimeType: string;
+}): Promise<UploadResult>;
+/**
+ * Fetch a URL and extract content (for --url flag)
+ */
+export declare function fetchUrlContent(url: string): Promise<{
+    content: string;
+    title?: string;
+    type: 'html' | 'text' | 'json' | 'unknown';
+}>;
+/**
+ * Stream a generation request (SSE)
+ */
+export declare function streamGeneration(config: Config, options: {
+    projectId: string;
+    prompt: string;
+    mode?: 'agent' | 'agent-max' | 'multi-scene';
+    imageUrls?: string[];
+    onEvent?: (event: StreamEvent) => void;
+    /** Include raw SSE data and timestamps in events (for bots/debugging) */
+    includeRaw?: boolean;
+    /** Plan mode: create recipe without executing (for handshake protocol) */
+    planOnly?: boolean;
+    /** Requirements to verify against after execution */
+    requirements?: string;
+    /** Per-run budget in USD (default: server decides, typically $5) */
+    budgetUsd?: number;
+    /** Model override (default: claude-sonnet-4-5 for CLI) */
+    modelOverride?: string;
+}): Promise<StreamResult>;
+export interface StreamEvent {
+    type: 'thinking' | 'tool_use' | 'code_gen' | 'compile' | 'scene_created' | 'scene_updated' | 'error' | 'complete' | 'text' | 'recipe_created' | 'workflow_created' | 'video_plan_created' | 'awaiting_approval' | 'ready' | 'asset_generated' | 'raw';
+    message?: string;
+    sceneId?: string;
+    sceneName?: string;
+    tool?: string;
+    summary?: string;
+    stopReason?: StopReason;
+    action?: 'start' | 'complete';
+    budgetUsd?: number;
+    model?: string;
+    assetUrl?: string;
+    assetType?: string;
+    costUsd?: number;
+    budget?: {
+        budgetUsd: number;
+        totalBilledUsd: number;
+        remainingUsd: number;
+    };
+    recipeName?: string;
+    recipeDescription?: string;
+    recipeId?: string;
+    executionId?: string;
+    workflowName?: string;
+    workflowDescription?: string;
+    videoPlanSummary?: string;
+    timestamp?: string;
+    raw?: unknown;
+    continue?: boolean;
+    errorType?: string;
+    errorCategory?: ErrorCategory;
+    retryable?: boolean;
+    transient?: boolean;
+    retryAfter?: number;
+    suggestion?: string;
+}
+export interface StreamResult {
+    success: boolean;
+    scenesCreated: string[];
+    scenesUpdated: string[];
+    errors: string[];
+    summary?: string;
+    stopReason?: StopReason;
+    continue: boolean;
+}