bazaar.it 0.1.0 → 0.2.1

package/dist/commands/project.js

@@ -0,0 +1,786 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, saveConfig, hasAuth, getProjectId } from '../lib/config.js';
+import { success, error, output, table, formatRelativeTime, formatDuration, confirmAction } from '../lib/output.js';
+import { apiRequest, ApiError } from '../lib/api.js';
+function normalizeProjectFormat(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.toLowerCase();
+    if (normalized === 'landscape' || normalized === 'portrait' || normalized === 'square') {
+        return normalized;
+    }
+    return null;
+}
+function handleProjectError(err, globalOpts) {
+    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);
+    }
+    if (globalOpts.json) {
+        output({
+            type: 'error',
+            code: 'UNKNOWN',
+            message: err.message || 'Unknown error',
+            category: 'fatal',
+            retryable: false,
+            transient: false,
+            exitCode: 1,
+        }, { json: true, compact: globalOpts.compact });
+    }
+    else {
+        error(err.message);
+    }
+    process.exit(1);
+}
+function exitProjectAuthError(globalOpts) {
+    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);
+}
+export const projectCommand = new Command('project')
+    .description('Manage projects');
+/**
+ * baz project create --name "My Video"
+ */
+projectCommand
+    .command('create')
+    .description('Create a new project')
+    .requiredOption('--name <name>', 'Project name')
+    .option('--description <text>', 'Project description')
+    .option('--format <format>', 'Video format: landscape, portrait, square', 'landscape')
+    .option('--no-activate', "Don't set as active project")
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+    });
+    if (!hasAuth(config)) {
+        exitProjectAuthError(globalOpts);
+    }
+    const spinner = globalOpts.json ? null : ora('Creating project...').start();
+    try {
+        const format = normalizeProjectFormat(options.format);
+        if (!format) {
+            spinner?.stop();
+            if (globalOpts.json) {
+                output({
+                    type: 'error',
+                    code: 'VALIDATION',
+                    message: `Invalid format "${options.format}". Use: landscape, portrait, square`,
+                    category: 'validation',
+                    retryable: false,
+                    transient: false,
+                    exitCode: 65,
+                }, { json: true, compact: globalOpts.compact });
+            }
+            else {
+                error(`Invalid format "${options.format}"`, 'Use: --format landscape|portrait|square');
+            }
+            process.exit(65);
+        }
+        const result = await apiRequest(config, 'project.create', {
+            title: options.name,
+            initialMessage: options.description || options.name,
+            format,
+        });
+        // API returns { projectId: "..." }
+        const projectId = result.projectId || result.id;
+        if (!projectId) {
+            spinner?.stop();
+            error('Failed to create project - no ID returned');
+            process.exit(1);
+        }
+        const finalTitle = result.title || result.name || options.name;
+        spinner?.stop();
+        // Set as active project unless --no-activate
+        if (options.activate !== false) {
+            saveConfig({ activeProjectId: projectId });
+        }
+        if (globalOpts.json) {
+            output({
+                ...result,
+                projectId,
+                title: finalTitle,
+                requestedTitle: options.name,
+                format,
+            }, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        success(`Created project: ${chalk.bold(finalTitle)}`);
+        console.log(`  ID: ${projectId}`);
+        console.log(`  Format: ${format}`);
+        if (finalTitle !== options.name) {
+            console.log(chalk.gray(`  Title adjusted to keep it unique for your account`));
+        }
+        if (options.activate !== false) {
+            console.log(chalk.gray('  Set as active project'));
+        }
+    }
+    catch (err) {
+        spinner?.stop();
+        handleProjectError(err, globalOpts);
+    }
+});
+/**
+ * baz project list
+ */
+projectCommand
+    .command('list')
+    .description('List all projects')
+    .option('--limit <n>', 'Number of projects to show', '20')
+    .option('--all', 'Show all projects (no limit)')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+    });
+    if (!hasAuth(config)) {
+        exitProjectAuthError(globalOpts);
+    }
+    const spinner = globalOpts.json ? null : ora('Fetching projects...').start();
+    try {
+        const result = await apiRequest(config, 'project.list', {
+            limit: options.all ? undefined : parseInt(options.limit, 10),
+        });
+        spinner?.stop();
+        // API returns array directly or { projects: [...] }
+        const projects = Array.isArray(result) ? result : (result.projects || []);
+        if (globalOpts.json) {
+            // Lean output: strip props (huge JSONB), keep only what agents need
+            const lean = projects.map((p) => ({
+                id: p.id,
+                title: p.title || p.name || 'Untitled',
+                format: p.props?.meta?.format || 'landscape',
+                sceneCount: p.activeSceneCount ?? p.sceneCount ?? 0,
+                isFavorite: Boolean(p.isFavorite),
+                updatedAt: p.updatedAt,
+                createdAt: p.createdAt,
+            }));
+            output(lean, { json: true });
+            return;
+        }
+        if (projects.length === 0) {
+            console.log(chalk.gray('No projects found.'));
+            console.log(chalk.gray('Create one with: baz project create --name "My Video"'));
+            return;
+        }
+        console.log(`Your Projects (${projects.length} total)`);
+        console.log();
+        const rows = projects.map((p) => {
+            const isActive = p.id === config.activeProjectId;
+            const marker = isActive ? chalk.green('*') : ' ';
+            // API returns 'title' not 'name'
+            const title = p.title || p.name || 'Untitled';
+            const displayName = isActive ? chalk.bold(title) : title;
+            // Use activeSceneCount from server JOIN (authoritative)
+            const sceneCount = p.activeSceneCount ?? p.sceneCount ?? 0;
+            const scenes = `${sceneCount} scenes`;
+            const time = formatRelativeTime(p.updatedAt);
+            return [marker, p.id.slice(0, 8) + '...', displayName, scenes, time];
+        });
+        table(['', 'ID', 'Name', 'Scenes', 'Updated'], rows);
+        console.log();
+        console.log(chalk.gray('* = active project'));
+    }
+    catch (err) {
+        spinner?.stop();
+        handleProjectError(err, globalOpts);
+    }
+});
+/**
+ * baz project use <id>
+ */
+projectCommand
+    .command('use <id>')
+    .description('Set active project')
+    .action(async (id, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+    });
+    if (!hasAuth(config)) {
+        exitProjectAuthError(globalOpts);
+    }
+    // Verify project exists
+    const spinner = globalOpts.json ? null : ora('Verifying project...').start();
+    try {
+        const result = await apiRequest(config, 'project.getById', { id });
+        spinner?.stop();
+        saveConfig({ activeProjectId: id });
+        if (globalOpts.json) {
+            output({ activeProjectId: id, project: result }, { json: true });
+            return;
+        }
+        success(`Active project: ${chalk.bold(result.title || result.name || 'Untitled')} (${id})`);
+    }
+    catch (err) {
+        spinner?.stop();
+        handleProjectError(err, globalOpts);
+    }
+});
+/**
+ * baz project current
+ */
+projectCommand
+    .command('current')
+    .description('Show active project')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!config.activeProjectId) {
+        if (globalOpts.json) {
+            output({ activeProjectId: null }, { json: true });
+            return;
+        }
+        console.log(chalk.gray('No active project set.'));
+        console.log(chalk.gray('Run: baz project use <id>'));
+        return;
+    }
+    if (!hasAuth(config)) {
+        exitProjectAuthError(globalOpts);
+    }
+    const spinner = globalOpts.json ? null : ora('Fetching project details...').start();
+    try {
+        const result = await apiRequest(config, 'project.getById', {
+            id: config.activeProjectId,
+        });
+        spinner?.stop();
+        if (globalOpts.json) {
+            output(result, { json: true });
+            return;
+        }
+        console.log(chalk.cyan('Active Project'));
+        console.log();
+        console.log(`Name: ${chalk.bold(result.title || result.name || 'Untitled')}`);
+        console.log(`ID: ${result.id}`);
+        console.log(`Scenes: ${result.props?.scenes?.length || result.sceneCount || 0}`);
+        console.log(`Duration: ${result.duration || '0:00'}`);
+        console.log(`Updated: ${result.updatedAt ? formatRelativeTime(result.updatedAt) : 'N/A'}`);
+    }
+    catch (err) {
+        spinner?.stop();
+        handleProjectError(err, globalOpts);
+    }
+});
+/**
+ * baz project format <format>
+ */
+projectCommand
+    .command('format <format>')
+    .description('Change project format by duplicating to a new project with target format')
+    .option('--source <id>', 'Source project ID (defaults to active project)')
+    .option('--no-activate', "Don't set duplicated project as active")
+    .action(async (formatArg, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        exitProjectAuthError(globalOpts);
+    }
+    const format = normalizeProjectFormat(formatArg);
+    if (!format) {
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'VALIDATION',
+                message: `Invalid format "${formatArg}". Use: landscape, portrait, square`,
+                category: 'validation',
+                retryable: false,
+                transient: false,
+                exitCode: 65,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(`Invalid format "${formatArg}"`, 'Use: baz project format landscape|portrait|square');
+        }
+        process.exit(65);
+    }
+    let sourceProjectId;
+    try {
+        sourceProjectId = options.source || 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(`Converting project to ${format}...`).start();
+    try {
+        const duplicateResult = await apiRequest(config, 'project.duplicate', {
+            projectId: sourceProjectId,
+            format,
+        });
+        const newProjectId = duplicateResult.projectId;
+        if (!newProjectId) {
+            spinner?.stop();
+            error('Failed to convert project format - no new project ID returned');
+            process.exit(1);
+        }
+        const duplicatedProject = await apiRequest(config, 'project.getById', { id: newProjectId }).catch(() => null);
+        const activated = options.activate !== false;
+        if (activated) {
+            saveConfig({ activeProjectId: newProjectId });
+        }
+        spinner?.stop();
+        const payload = {
+            type: 'project_format_changed',
+            sourceProjectId,
+            projectId: newProjectId,
+            format: duplicatedProject?.props?.meta?.format || format,
+            title: duplicatedProject?.title || 'Untitled',
+            activated,
+        };
+        if (globalOpts.json) {
+            output(payload, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        success(`Created ${format} duplicate`);
+        console.log(`  Source: ${sourceProjectId}`);
+        console.log(`  New project: ${newProjectId}`);
+        console.log(`  Title: ${payload.title}`);
+        console.log(`  Format: ${payload.format}`);
+        if (activated) {
+            console.log(chalk.gray('  Set as active project'));
+        }
+        console.log(chalk.gray('  Note: scenes and project context were copied to the new project'));
+    }
+    catch (err) {
+        spinner?.stop();
+        handleProjectError(err, globalOpts);
+    }
+});
+/**
+ * baz project duplicate [project-id]
+ */
+projectCommand
+    .command('duplicate [id]')
+    .description('Duplicate a project (optionally changing format)')
+    .option('--name <name>', 'Rename the duplicated project')
+    .option('--format <format>', 'Target format: landscape, portrait, square')
+    .option('--no-activate', "Don't set duplicated project as active")
+    .action(async (id, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        exitProjectAuthError(globalOpts);
+    }
+    // Resolve source project
+    let sourceProjectId;
+    try {
+        sourceProjectId = id || 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);
+    }
+    // Validate format if provided
+    let format;
+    if (options.format) {
+        format = normalizeProjectFormat(options.format) ?? undefined;
+        if (!format) {
+            if (globalOpts.json) {
+                output({
+                    type: 'error',
+                    code: 'VALIDATION',
+                    message: `Invalid format "${options.format}". Use: landscape, portrait, square`,
+                    category: 'validation',
+                    retryable: false,
+                    transient: false,
+                    exitCode: 65,
+                }, { json: true, compact: globalOpts.compact });
+            }
+            else {
+                error(`Invalid format "${options.format}"`, 'Use: --format landscape|portrait|square');
+            }
+            process.exit(65);
+        }
+    }
+    const spinner = globalOpts.json ? null : ora('Duplicating project...').start();
+    try {
+        const duplicateResult = await apiRequest(config, 'project.duplicate', {
+            projectId: sourceProjectId,
+            ...(format && { format }),
+        });
+        const newProjectId = duplicateResult.projectId;
+        if (!newProjectId) {
+            spinner?.stop();
+            error('Failed to duplicate project - no new project ID returned');
+            process.exit(1);
+        }
+        // Rename if requested
+        if (options.name) {
+            await apiRequest(config, 'project.rename', {
+                id: newProjectId,
+                title: options.name,
+            });
+        }
+        // Fetch the final state
+        const project = await apiRequest(config, 'project.getById', { id: newProjectId }).catch(() => null);
+        const activated = options.activate !== false;
+        if (activated) {
+            saveConfig({ activeProjectId: newProjectId });
+        }
+        spinner?.stop();
+        const payload = {
+            type: 'project_duplicated',
+            sourceProjectId,
+            projectId: newProjectId,
+            title: project?.title || options.name || 'Untitled',
+            format: project?.props?.meta?.format || format || 'unchanged',
+            activated,
+        };
+        if (globalOpts.json) {
+            output(payload, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        success(`Duplicated project`);
+        console.log(`  Source: ${sourceProjectId}`);
+        console.log(`  New project: ${newProjectId}`);
+        console.log(`  Title: ${payload.title}`);
+        if (format)
+            console.log(`  Format: ${payload.format}`);
+        if (activated)
+            console.log(chalk.gray('  Set as active project'));
+    }
+    catch (err) {
+        spinner?.stop();
+        handleProjectError(err, globalOpts);
+    }
+});
+/**
+ * baz project settings
+ */
+projectCommand
+    .command('settings')
+    .description('View or change project settings (format, dimensions)')
+    .option('--aspect <ratio>', 'Set aspect ratio: 16:9, 9:16, 1:1')
+    .option('--format <format>', 'Set format: landscape, portrait, square')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        exitProjectAuthError(globalOpts);
+    }
+    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);
+    }
+    // Map aspect ratio shortcuts to format
+    const ASPECT_MAP = {
+        '16:9': { format: 'landscape', width: 1920, height: 1080 },
+        '9:16': { format: 'portrait', width: 1080, height: 1920 },
+        '1:1': { format: 'square', width: 1080, height: 1080 },
+    };
+    let targetFormat;
+    let targetWidth;
+    let targetHeight;
+    if (options.aspect) {
+        const mapped = ASPECT_MAP[options.aspect];
+        if (!mapped) {
+            if (globalOpts.json) {
+                output({
+                    type: 'error',
+                    code: 'VALIDATION',
+                    message: `Invalid aspect ratio "${options.aspect}". Use: 16:9, 9:16, 1:1`,
+                    category: 'validation',
+                    retryable: false,
+                    transient: false,
+                    exitCode: 65,
+                }, { json: true, compact: globalOpts.compact });
+            }
+            else {
+                error(`Invalid aspect ratio "${options.aspect}"`, 'Use: --aspect 16:9|9:16|1:1');
+            }
+            process.exit(65);
+        }
+        targetFormat = mapped.format;
+        targetWidth = mapped.width;
+        targetHeight = mapped.height;
+    }
+    else if (options.format) {
+        const f = normalizeProjectFormat(options.format);
+        if (!f) {
+            if (globalOpts.json) {
+                output({
+                    type: 'error',
+                    code: 'VALIDATION',
+                    message: `Invalid format "${options.format}". Use: landscape, portrait, square`,
+                    category: 'validation',
+                    retryable: false,
+                    transient: false,
+                    exitCode: 65,
+                }, { json: true, compact: globalOpts.compact });
+            }
+            else {
+                error(`Invalid format "${options.format}"`, 'Use: --format landscape|portrait|square');
+            }
+            process.exit(65);
+        }
+        const dimensions = ASPECT_MAP[f === 'landscape' ? '16:9' : f === 'portrait' ? '9:16' : '1:1'];
+        targetFormat = f;
+        targetWidth = dimensions.width;
+        targetHeight = dimensions.height;
+    }
+    const isUpdate = targetFormat !== undefined;
+    const spinner = globalOpts.json ? null : ora(isUpdate ? 'Updating settings...' : 'Fetching settings...').start();
+    try {
+        if (isUpdate) {
+            // Use project.patch with JSON Patch ops
+            await apiRequest(config, 'project.patch', {
+                projectId,
+                operations: [
+                    { op: 'replace', path: '/meta/format', value: targetFormat },
+                    { op: 'replace', path: '/meta/width', value: targetWidth },
+                    { op: 'replace', path: '/meta/height', value: targetHeight },
+                ],
+            });
+        }
+        // Fetch current state
+        const project = await apiRequest(config, 'project.getById', { id: projectId });
+        spinner?.stop();
+        const meta = project.props?.meta || {};
+        const payload = {
+            type: isUpdate ? 'settings_updated' : 'settings',
+            projectId,
+            title: project.title || 'Untitled',
+            format: meta.format || 'landscape',
+            width: meta.width || 1920,
+            height: meta.height || 1080,
+            duration: meta.duration || 0,
+            fps: 30,
+        };
+        if (globalOpts.json) {
+            output(payload, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        if (isUpdate) {
+            success(`Updated project settings`);
+        }
+        else {
+            console.log(chalk.bold('Project Settings'));
+            console.log(chalk.gray('─'.repeat(40)));
+        }
+        console.log(`  Title:    ${payload.title}`);
+        console.log(`  Format:   ${payload.format}`);
+        console.log(`  Size:     ${payload.width}x${payload.height}`);
+        console.log(`  Duration: ${formatDuration(payload.duration)}`);
+        console.log(`  FPS:      ${payload.fps}`);
+    }
+    catch (err) {
+        spinner?.stop();
+        handleProjectError(err, globalOpts);
+    }
+});
+/**
+ * baz project validate
+ */
+projectCommand
+    .command('validate')
+    .description('Validate project timeline structure')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        exitProjectAuthError(globalOpts);
+    }
+    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('Validating project...').start();
+    try {
+        const result = await apiRequest(config, 'project.validate', { projectId });
+        spinner?.stop();
+        const payload = {
+            type: result.type || 'project_validation',
+            projectId,
+            projectTitle: result.projectTitle || 'Untitled',
+            valid: Boolean(result.valid),
+            summary: result.summary || {
+                sceneCount: 0,
+                trackCount: 0,
+                totalFrames: 0,
+                totalDurationSeconds: 0,
+                compilationErrorCount: 0,
+            },
+            errors: Array.isArray(result.errors) ? result.errors : [],
+            warnings: Array.isArray(result.warnings) ? result.warnings : [],
+        };
+        if (globalOpts.json) {
+            output(payload, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            console.log(chalk.bold('Project Validation'));
+            console.log(chalk.gray('─'.repeat(60)));
+            console.log(`Project: ${payload.projectTitle} (${projectId.slice(0, 8)}...)`);
+            console.log(`Scenes: ${payload.summary.sceneCount}`);
+            console.log(`Tracks: ${payload.summary.trackCount}`);
+            console.log(`Duration: ${formatDuration(payload.summary.totalDurationSeconds)}`);
+            console.log(`Compilation errors: ${payload.summary.compilationErrorCount}`);
+            console.log();
+            if (payload.errors.length === 0 && payload.warnings.length === 0) {
+                console.log(chalk.green('✓ No validation issues found.'));
+            }
+            else {
+                for (const issue of payload.errors) {
+                    console.log(`${chalk.red('✗')} [${issue.code}] ${issue.message}`);
+                }
+                for (const issue of payload.warnings) {
+                    console.log(`${chalk.yellow('!')} [${issue.code}] ${issue.message}`);
+                }
+            }
+        }
+        process.exit(payload.valid ? 0 : 65);
+    }
+    catch (err) {
+        spinner?.stop();
+        handleProjectError(err, globalOpts);
+    }
+});
+/**
+ * baz project delete <id>
+ */
+projectCommand
+    .command('delete <id>')
+    .description('Delete a project')
+    .option('--force', 'Skip confirmation')
+    .action(async (id, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+    });
+    if (!hasAuth(config)) {
+        exitProjectAuthError(globalOpts);
+    }
+    if (!options.force) {
+        const confirmed = await confirmAction(`Delete project ${id}? This cannot be undone.`);
+        if (!confirmed) {
+            if (globalOpts.json) {
+                output({ deleted: false, id, reason: 'cancelled' }, { json: true });
+                return;
+            }
+            console.log(chalk.gray('Cancelled. Use --force to skip confirmation.'));
+            return;
+        }
+    }
+    const spinner = globalOpts.json ? null : ora('Deleting project...').start();
+    try {
+        await apiRequest(config, 'project.delete', { id });
+        spinner?.stop();
+        // Clear active project if it was deleted
+        if (config.activeProjectId === id) {
+            saveConfig({ activeProjectId: undefined });
+        }
+        if (globalOpts.json) {
+            output({ deleted: true, id }, { json: true });
+            return;
+        }
+        success(`Deleted project: ${id}`);
+    }
+    catch (err) {
+        spinner?.stop();
+        handleProjectError(err, globalOpts);
+    }
+});