@vinaes/succ 1.3.19

package/dist/cli.js

@@ -0,0 +1,749 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import { logError } from './lib/fault-logger.js';
+// Read version from package.json
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+const VERSION = pkg.version;
+const program = new Command();
+program
+    .name('succ')
+    .version(VERSION)
+    .configureHelp({ sortSubcommands: true })
+    .addHelpText('beforeAll', `
+  \x1b[32m●\x1b[0m succ
+
+  Semantic Understanding for Code Contexts
+  Claude Code · Cursor · Windsurf · Continue.dev
+
+  ─────────────────────────────────────────────────────────
+`);
+program
+    .command('init')
+    .description('Initialize succ in current project')
+    .option('-f, --force', 'Overwrite existing configuration')
+    .option('-y, --yes', 'Non-interactive mode (skip prompts)')
+    .option('-v, --verbose', 'Show detailed output (created files, etc.)')
+    .option('-g, --global', 'Use global hooks (from succ package dir, not local copies)')
+    .option('--ai', 'Use AI-powered interactive onboarding instead of static wizard')
+    .action(async (...args) => {
+    const { init } = await import('./commands/init.js');
+    return init(...args);
+});
+program
+    .command('index [path]')
+    .description('Index files for semantic search (incremental by default)')
+    .option('-r, --recursive', 'Index recursively', true)
+    .option('--pattern <glob>', 'File pattern to match', '**/*.md')
+    .option('-f, --force', 'Force reindex all files (ignore cache)')
+    .option('-m, --memories', 'Re-embed all memories with current embedding model')
+    .action(async (...args) => {
+    const { index } = await import('./commands/index.js');
+    return index(...args);
+});
+program
+    .command('search <query>')
+    .description('Semantic search across indexed content')
+    .option('-n, --limit <number>', 'Number of results', '5')
+    .option('-t, --threshold <number>', 'Similarity threshold (0-1)', '0.2')
+    .action(async (query, options) => {
+    const { search } = await import('./commands/search.js');
+    return search(query, options);
+});
+program
+    .command('status')
+    .description('Show index statistics')
+    .action(async () => {
+    const { status } = await import('./commands/status.js');
+    return status();
+});
+program
+    .command('reindex')
+    .description('Re-index stale files and clean up deleted entries')
+    .action(async () => {
+    const { reindex } = await import('./commands/reindex.js');
+    return reindex();
+});
+program
+    .command('add <file>', { hidden: true })
+    .description('Add a single file to the index')
+    .action(async (file) => {
+    const { index } = await import('./commands/index.js');
+    await index(file, { recursive: false, pattern: '*' });
+});
+program
+    .command('analyze')
+    .description('Analyze project with Claude agents and generate brain vault')
+    .option('--sequential', 'Run agents sequentially instead of parallel')
+    .option('--api', 'Use API mode (OpenAI-compatible endpoint) instead of Claude CLI')
+    .option('--background', 'Run analysis in background (detached process)')
+    .option('--fast', 'Fast analysis (fewer agents, smaller context)')
+    .option('--force', 'Force full re-analysis (skip incremental cache)')
+    .action(async (options) => {
+    const { analyze } = await import('./commands/analyze.js');
+    return analyze({
+        parallel: !options.sequential,
+        api: options.api,
+        background: options.background,
+        fast: options.fast,
+        force: options.force,
+    });
+});
+program
+    .command('chat <query>')
+    .description('RAG chat - search context and ask Claude')
+    .option('-n, --limit <number>', 'Number of context chunks', '5')
+    .option('-t, --threshold <number>', 'Similarity threshold (0-1)', '0.2')
+    .option('-v, --verbose', 'Show search results before asking')
+    .action(async (query, options) => {
+    const { chat } = await import('./commands/chat.js');
+    return chat(query, {
+        limit: parseInt(options.limit, 10),
+        threshold: parseFloat(options.threshold),
+        verbose: options.verbose,
+    });
+});
+program
+    .command('watch [path]')
+    .description('Watch for file changes and auto-reindex (docs + code by default)')
+    .option('--pattern <glob>', 'File pattern to match for docs', '**/*.md')
+    .option('--ignore-code', 'Skip watching source code files (watch docs only)')
+    .option('--stop', 'Stop watch service')
+    .option('--status', 'Show watch service status')
+    .action(async (targetPath, options) => {
+    const { watch, stopWatchDaemon, watchDaemonStatus } = await import('./commands/watch.js');
+    if (options.stop) {
+        await stopWatchDaemon();
+        return;
+    }
+    if (options.status) {
+        await watchDaemonStatus();
+        return;
+    }
+    // Code watching is ON by default, --ignore-code turns it off
+    const includeCode = !options.ignoreCode;
+    return watch(targetPath, {
+        pattern: options.pattern,
+        includeCode,
+    });
+});
+const configCmd = program
+    .command('config')
+    .description('Show or edit succ configuration')
+    .option('-s, --show', 'Show current configuration (non-interactive)')
+    .option('--json', 'Output as JSON (with --show)')
+    .action(async (options) => {
+    const { config } = await import('./commands/config.js');
+    return config({
+        show: options.show,
+        json: options.json,
+    });
+});
+configCmd
+    .command('set <key> <value>')
+    .description('Set a configuration value (supports dot notation, e.g. error_reporting.level)')
+    .option('-p, --project', 'Save to project config (.succ/config.json) instead of global')
+    .action(async (key, value, options) => {
+    const { configSet } = await import('./commands/config.js');
+    return configSet(key, value, { project: options.project });
+});
+program
+    .command('memories')
+    .description('List and search memories')
+    .option('--recent <number>', 'Show N most recent memories')
+    .option('-s, --search <query>', 'Search memories semantically')
+    .option('--tags <tags>', 'Filter by tags (comma-separated)')
+    .option('-n, --limit <number>', 'Maximum number of results', '10')
+    .option('-g, --global', 'Use global memory (shared across projects)')
+    .option('--json', 'Output as JSON (for scripting)')
+    .action(async (options) => {
+    const { memories } = await import('./commands/memories.js');
+    return memories({
+        recent: options.recent ? parseInt(options.recent, 10) : undefined,
+        search: options.search,
+        tags: options.tags,
+        limit: parseInt(options.limit, 10),
+        global: options.global,
+        json: options.json,
+    });
+});
+program
+    .command('remember <content>')
+    .description('Save something to memory (uses LLM extraction by default)')
+    .option('--tags <tags>', 'Tags (comma-separated)')
+    .option('--source <source>', 'Source context')
+    .option('-g, --global', 'Save to global memory (shared across projects)')
+    .option('--skip-quality', 'Skip quality scoring and threshold check')
+    .option('--skip-sensitive', 'Skip sensitive info check (not recommended)')
+    .option('--redact-sensitive', 'Auto-redact sensitive info and save')
+    .option('--valid-from <date>', 'When fact becomes valid (e.g., "2024-01-01" or "7d")')
+    .option('--valid-until <date>', 'When fact expires (e.g., "2024-12-31" or "30d")')
+    .option('-e, --extract', 'Force LLM extraction (default: enabled)')
+    .option('--no-extract', 'Disable LLM extraction (save content as-is)')
+    .option('--api', 'Use API mode (OpenAI-compatible endpoint) for extraction')
+    .option('--model <model>', 'Model to use for extraction')
+    .option('--api-url <url>', 'API URL for LLM endpoint')
+    .action(async (content, options) => {
+    const { remember } = await import('./commands/memories.js');
+    return remember(content, {
+        tags: options.tags,
+        source: options.source,
+        global: options.global,
+        skipQuality: options.skipQuality,
+        skipSensitiveCheck: options.skipSensitive,
+        redactSensitive: options.redactSensitive,
+        validFrom: options.validFrom,
+        validUntil: options.validUntil,
+        extract: options.extract === true ? true : undefined,
+        noExtract: options.extract === false,
+        api: options.api,
+        model: options.model,
+        apiUrl: options.apiUrl,
+    });
+});
+program
+    .command('index-code [path]')
+    .description('Index source code for semantic search')
+    .option('--file <file>', 'Index a single file directly')
+    .option('--patterns <patterns>', 'File patterns (comma-separated)', '**/*.ts,**/*.tsx,**/*.js,**/*.jsx,**/*.py,**/*.go')
+    .option('--ignore <patterns>', 'Ignore patterns (comma-separated)')
+    .option('-f, --force', 'Force reindex all files')
+    .option('--max-size <kb>', 'Max file size in KB', '500')
+    .action(async (targetPath, options) => {
+    // Single file mode
+    if (options.file) {
+        const { indexCodeFile } = await import('./commands/index-code.js');
+        const result = await indexCodeFile(options.file, { force: options.force });
+        if (result.success) {
+            if (result.skipped) {
+                console.log(`Skipped: ${result.reason}`);
+            }
+            else {
+                console.log(`Indexed ${result.chunks} chunks from ${options.file}`);
+            }
+        }
+        else {
+            logError('cli', `Index error: ${result.error}`);
+            console.error(`Error: ${result.error}`);
+            process.exit(1);
+        }
+        return;
+    }
+    // Directory/pattern mode
+    const { indexCode } = await import('./commands/index-code.js');
+    return indexCode(targetPath, {
+        patterns: options.patterns?.split(','),
+        ignore: options.ignore?.split(','),
+        force: options.force,
+        maxFileSize: parseInt(options.maxSize, 10),
+    });
+});
+program
+    .command('forget')
+    .description('Delete memories')
+    .option('--id <id>', 'Delete memory by ID')
+    .option('--older-than <date>', 'Delete memories older than (e.g., "30d", "1w", "3m")')
+    .option('--tag <tag>', 'Delete memories with tag')
+    .option('--all', 'Delete ALL memories')
+    .action(async (options) => {
+    const { forget } = await import('./commands/memories.js');
+    return forget({
+        id: options.id ? parseInt(options.id, 10) : undefined,
+        olderThan: options.olderThan,
+        tag: options.tag,
+        all: options.all,
+    });
+});
+program
+    .command('benchmark')
+    .description('Run performance benchmarks')
+    .option('-n, --iterations <number>', 'Number of iterations per test', '10')
+    .option('--advanced', 'Run advanced IR metrics (Recall@K, Precision@K, F1@K, MRR, NDCG)')
+    .option('-k, --k <number>', 'K value for metrics', '5')
+    .option('--json', 'Output results as JSON')
+    .option('--existing', 'Benchmark on existing memories (latency only)')
+    .option('-m, --model <model>', 'Local embedding model (e.g., Xenova/bge-base-en-v1.5)')
+    .option('--size <size>', 'Dataset size: small (20), medium (64), large (all)', 'small')
+    .option('--save', 'Save results to benchmark history')
+    .option('--compare', 'Compare with previous benchmark')
+    .option('--hybrid', 'Include hybrid search comparison (semantic vs BM25 vs RRF)')
+    .option('--history', 'List benchmark history')
+    .option('--history-limit <n>', 'Number of history entries to show', '10')
+    .action(async (options) => {
+    const { benchmark, benchmarkExisting, benchmarkWithHistory, listBenchmarkHistory } = await import('./commands/benchmark.js');
+    if (options.history) {
+        return listBenchmarkHistory({
+            limit: parseInt(options.historyLimit, 10),
+            json: options.json,
+        });
+    }
+    else if (options.existing) {
+        return benchmarkExisting({
+            k: parseInt(options.k, 10),
+            json: options.json,
+        });
+    }
+    else if (options.save || options.compare || options.hybrid) {
+        return benchmarkWithHistory({
+            iterations: parseInt(options.iterations, 10),
+            advanced: options.advanced,
+            k: parseInt(options.k, 10),
+            json: options.json,
+            model: options.model,
+            size: options.size,
+            save: options.save,
+            compare: options.compare,
+            hybrid: options.hybrid,
+        });
+    }
+    else {
+        return benchmark({
+            iterations: parseInt(options.iterations, 10),
+            advanced: options.advanced,
+            k: parseInt(options.k, 10),
+            json: options.json,
+            model: options.model,
+            size: options.size,
+        });
+    }
+});
+program
+    .command('benchmark-quality', { hidden: true })
+    .description('Run quality scoring benchmark (heuristic vs ONNX vs Ollama vs OpenRouter)')
+    .option('--ollama', 'Include Ollama models in benchmark')
+    .option('--api', 'Include API models in benchmark')
+    .option('--models <models>', 'Models to test (comma-separated)')
+    .option('--ollama-url <url>', 'Ollama API URL', 'http://localhost:11434')
+    .action(async (options) => {
+    const { benchmarkQuality } = await import('./commands/benchmark-quality.js');
+    return benchmarkQuality({
+        ollama: options.ollama,
+        api: options.api,
+        models: options.models,
+        ollamaUrl: options.ollamaUrl,
+    });
+});
+program
+    .command('benchmark-vec', { hidden: true })
+    .description('Compare brute-force vs sqlite-vec indexed vector search')
+    .option('--sizes <sizes>', 'Vector counts to test (comma-separated)', '100,500,1000,5000')
+    .option('-q, --queries <number>', 'Number of queries per size', '50')
+    .option('-k <number>', 'Top-K results to retrieve', '10')
+    .option('-m, --model <model>', 'Local embedding model')
+    .option('--json', 'Output results as JSON')
+    .action(async (options) => {
+    const { benchmarkSqliteVec } = await import('./commands/benchmark-sqlite-vec.js');
+    return benchmarkSqliteVec({
+        sizes: options.sizes.split(',').map((s) => parseInt(s, 10)),
+        queries: parseInt(options.queries, 10),
+        k: parseInt(options.k, 10),
+        model: options.model,
+        json: options.json,
+    });
+});
+program
+    .command('clear')
+    .description('Clear index and/or memories')
+    .option('--index-only', 'Clear only document index')
+    .option('--memories-only', 'Clear only memories')
+    .option('--code-only', 'Clear only code index (keeps brain docs)')
+    .option('-f, --force', 'Confirm deletion (required)')
+    .action(async (options) => {
+    const { clear } = await import('./commands/clear.js');
+    return clear({
+        indexOnly: options.indexOnly,
+        memoriesOnly: options.memoriesOnly,
+        codeOnly: options.codeOnly,
+        force: options.force,
+    });
+});
+program
+    .command('soul')
+    .description('Generate personalized soul.md from project analysis')
+    .option('--api', 'Use API mode (OpenAI-compatible endpoint) instead of Claude CLI')
+    .action(async (options) => {
+    const { soul } = await import('./commands/soul.js');
+    return soul({
+        api: options.api,
+    });
+});
+program
+    .command('graph <action>')
+    .description('Knowledge graph: export, stats, auto-link, enrich-relations, proximity, communities, centrality, cleanup')
+    .option('-f, --format <format>', 'Export format: obsidian or json', 'obsidian')
+    .option('-t, --threshold <number>', 'Similarity threshold for auto-link/cleanup prune', '0.75')
+    .option('--orphan-threshold <number>', 'Similarity threshold for orphan reconnection', '0.60')
+    .option('-o, --output <path>', 'Output directory for export')
+    .option('--force', 'Force re-enrichment of already enriched links')
+    .option('-n, --limit <number>', 'Limit number of links to enrich')
+    .option('--min-count <number>', 'Min co-occurrence count for proximity', '2')
+    .option('--dry-run', 'Preview without making changes')
+    .option('--skip-enrich', 'Skip LLM enrichment step (cleanup)')
+    .option('--skip-orphans', 'Skip orphan reconnection (cleanup)')
+    .option('--skip-finalize', 'Skip communities + centrality rebuild (cleanup)')
+    .action(async (action, options) => {
+    const { graph } = await import('./commands/graph.js');
+    return graph({
+        action: action,
+        format: options.format,
+        threshold: parseFloat(options.threshold),
+        orphanThreshold: options.orphanThreshold ? parseFloat(options.orphanThreshold) : undefined,
+        output: options.output,
+        force: options.force,
+        limit: options.limit ? parseInt(options.limit) : undefined,
+        minCount: options.minCount ? parseInt(options.minCount) : undefined,
+        dryRun: options.dryRun,
+        skipEnrich: options.skipEnrich,
+        skipOrphans: options.skipOrphans,
+        skipFinalize: options.skipFinalize,
+    });
+});
+// Embedding management
+const embeddingCmd = program
+    .command('embedding')
+    .description('Embedding model management: info, migrate');
+embeddingCmd
+    .command('info')
+    .description('Show current embedding config, dimensions, and backend status')
+    .action(async () => {
+    const { embeddingInfo } = await import('./commands/embedding.js');
+    return embeddingInfo();
+});
+embeddingCmd
+    .command('migrate')
+    .description('Change embedding model/dimensions across all backends')
+    .option('--model <model>', 'Embedding model ID (e.g., qwen/qwen3-embedding-8b)')
+    .option('--dims <number>', 'Output dimensions (MRL truncation)')
+    .option('--mode <mode>', 'Embedding mode (local|api)')
+    .option('--api-url <url>', 'API endpoint URL')
+    .option('--api-key <key>', 'API key')
+    .option('--project', 'Apply to project config only (default: both global and project)')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (options) => {
+    const { embeddingMigrate } = await import('./commands/embedding.js');
+    return embeddingMigrate(options);
+});
+program
+    .command('consolidate')
+    .description('Consolidate memories: merge duplicates, soft-invalidate redundant')
+    .option('--dry-run', 'Preview changes without applying them')
+    .option('-t, --threshold <number>', 'Similarity threshold for consolidation (0-1)', '0.85')
+    .option('-n, --limit <number>', 'Maximum pairs to process', '50')
+    .option('--stats', 'Show consolidation statistics only')
+    .option('-v, --verbose', 'Show detailed output')
+    .option('--llm', 'Force LLM merge (default: enabled)')
+    .option('--no-llm', 'Disable LLM merge (use simple quality-based merge)')
+    .option('--undo <id>', 'Undo a consolidation by restoring original memories')
+    .option('--history', 'Show recent consolidation operations')
+    .action(async (options) => {
+    const { consolidate } = await import('./commands/consolidate.js');
+    return consolidate({
+        dryRun: options.dryRun,
+        threshold: options.threshold,
+        limit: options.limit,
+        stats: options.stats,
+        verbose: options.verbose,
+        llm: options.llm === true ? true : undefined,
+        noLlm: options.llm === false,
+        undo: options.undo,
+        history: options.history,
+    });
+});
+program
+    .command('session-summary <transcript>', { hidden: true })
+    .description('Extract facts from session transcript and save as memories')
+    .option('--dry-run', 'Preview facts without saving')
+    .option('-v, --verbose', 'Show detailed output')
+    .option('--api', 'Use API mode (OpenAI-compatible endpoint)')
+    .option('--api-url <url>', 'API URL for LLM endpoint')
+    .option('--model <model>', 'Model to use')
+    .action(async (transcript, options) => {
+    const { sessionSummary } = await import('./commands/session-summary.js');
+    return sessionSummary(transcript, {
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+        api: options.api,
+        apiUrl: options.apiUrl,
+        model: options.model,
+    });
+});
+program
+    .command('precompute-context <transcript>', { hidden: true })
+    .description('Generate context briefing for next session')
+    .option('--dry-run', 'Preview output without saving')
+    .option('-v, --verbose', 'Show detailed output')
+    .option('--api', 'Use API mode (OpenAI-compatible endpoint)')
+    .action(async (transcript, options) => {
+    const { precomputeContext } = await import('./commands/precompute-context.js');
+    return precomputeContext(transcript, {
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+        api: options.api,
+    });
+});
+program
+    .command('train-bpe', { hidden: true })
+    .description('Train BPE vocabulary from indexed code')
+    .option('--vocab-size <number>', 'Target vocabulary size', '5000')
+    .option('--min-frequency <number>', 'Minimum pair frequency to merge', '2')
+    .option('--stats', 'Show current BPE statistics only')
+    .action(async (options) => {
+    const { trainBPE } = await import('./commands/train-bpe.js');
+    return trainBPE({
+        vocabSize: parseInt(options.vocabSize, 10),
+        minFrequency: parseInt(options.minFrequency, 10),
+        showStats: options.stats,
+    });
+});
+program
+    .command('stats')
+    .description('Show succ usage statistics')
+    .option('--tokens', 'Show token savings statistics')
+    .option('--clear', 'Clear token statistics')
+    .option('--model <model>', 'Override model for cost recalculation (opus, sonnet, haiku)')
+    .action(async (options) => {
+    const { stats } = await import('./commands/stats.js');
+    return stats({
+        tokens: options.tokens,
+        clear: options.clear,
+        model: options.model,
+    });
+});
+program
+    .command('retention')
+    .description('Manage memory retention with decay-based cleanup')
+    .option('--dry-run', 'Preview what would be deleted')
+    .option('--apply', 'Actually delete low-score memories')
+    .option('--auto-cleanup', 'Soft-invalidate (not delete) low-score memories')
+    .option('-v, --verbose', 'Show detailed analysis')
+    .action(async (options) => {
+    const { retention } = await import('./commands/retention.js');
+    return retention({
+        dryRun: options.dryRun,
+        apply: options.apply,
+        autoCleanup: options.autoCleanup,
+        verbose: options.verbose,
+    });
+});
+program
+    .command('backfill')
+    .description('Sync existing SQL data (memories, documents) into Qdrant vector store')
+    .option('--memories', 'Only backfill project memories')
+    .option('--global', 'Only backfill global memories')
+    .option('--documents', 'Only backfill documents')
+    .option('--dry-run', 'Show counts without writing')
+    .action(async (options) => {
+    const { backfill } = await import('./commands/backfill.js');
+    return backfill({
+        memories: options.memories,
+        global: options.global,
+        documents: options.documents,
+        dryRun: options.dryRun,
+    });
+});
+program
+    .command('agents-md')
+    .description('Generate .claude/AGENTS.md from project memories (decisions, patterns, dead-ends)')
+    .option('--preview', 'Preview without writing to disk')
+    .option('--path <path>', 'Custom output path')
+    .action(async (options) => {
+    const { agentsMd } = await import('./commands/agents-md.js');
+    return agentsMd({
+        preview: options.preview,
+        path: options.path,
+    });
+});
+program
+    .command('progress')
+    .description('View session progress log (knowledge growth over time)')
+    .option('-n, --limit <number>', 'Number of entries to show', '20')
+    .option('--since <duration>', 'Show entries since (e.g., 7d, 1w, 1m)')
+    .action(async (options) => {
+    const { progress } = await import('./commands/progress.js');
+    return progress({
+        limit: parseInt(options.limit, 10),
+        since: options.since,
+    });
+});
+program
+    .command('checkpoint <action> [file]')
+    .description('Create, restore, or list checkpoints (full backup/restore)')
+    .option('-o, --output <path>', 'Output file path for create')
+    .option('--compress', 'Compress with gzip')
+    .option('--no-brain', 'Exclude brain vault from create')
+    .option('--no-documents', 'Exclude indexed documents from create')
+    .option('--no-config', 'Exclude config from create')
+    .option('--overwrite', 'Overwrite existing data on restore')
+    .option('--restore-config', 'Also restore config on restore')
+    .action(async (action, file, options) => {
+    const { checkpoint } = await import('./commands/checkpoint.js');
+    return checkpoint({
+        action: action,
+        file,
+        output: options.output,
+        compress: options.compress,
+        includeBrain: options.brain,
+        includeDocuments: options.documents,
+        includeConfig: options.config,
+        overwrite: options.overwrite,
+        restoreBrain: options.brain,
+        restoreDocuments: options.documents,
+        restoreConfig: options.restoreConfig,
+    });
+});
+program
+    .command('score')
+    .description('Show AI-readiness score for the project')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const { score } = await import('./commands/score.js');
+    return score({
+        json: options.json,
+    });
+});
+program
+    .command('daemon [subcommand]')
+    .description('Manage the succ daemon (status, sessions, start, stop, logs)')
+    .option('--json', 'Output as JSON')
+    .option('--force', 'Force stop even if sessions active')
+    .option('--lines <number>', 'Number of log lines to show', '50')
+    .option('--all', 'Include service sessions in list')
+    .action(async (subcommand, options) => {
+    const { daemon } = await import('./commands/daemon.js');
+    return daemon(subcommand || 'status', {
+        json: options.json,
+        force: options.force,
+        lines: parseInt(options.lines, 10),
+        all: options.all,
+    });
+});
+program
+    .command('migrate')
+    .description('Migrate data between storage backends (SQLite, PostgreSQL)')
+    .option('--to <backend>', 'Target backend (sqlite or postgresql)')
+    .option('--export <file>', 'Export data to JSON file')
+    .option('--import <file>', 'Import data from JSON file')
+    .option('--dry-run', 'Preview without making changes')
+    .option('--force', 'Confirm destructive operations')
+    .action(async (options) => {
+    const { migrate } = await import('./commands/migrate.js');
+    return migrate({
+        to: options.to,
+        export: options.export,
+        import: options.import,
+        dryRun: options.dryRun,
+        force: options.force,
+    });
+});
+program
+    .command('setup [editor]')
+    .description('Configure succ MCP server for an editor (claude, cursor, windsurf, continue)')
+    .option('--detect', 'Auto-detect installed editors and configure all')
+    .action(async (editor, options) => {
+    const { setup } = await import('./commands/setup.js');
+    return setup({
+        editor,
+        detect: options.detect,
+    });
+});
+// PRD Pipeline
+const prdCmd = program
+    .command('prd')
+    .description('PRD-to-Task pipeline — generate, parse, and manage PRDs');
+prdCmd
+    .command('generate <description>')
+    .description('Generate a PRD from a feature description')
+    .option('--mode <mode>', 'Execution mode (loop or team)', 'loop')
+    .option('--gates <gates>', 'Quality gates (comma-separated, e.g. "typecheck,test")')
+    .option('--model <model>', 'LLM model override')
+    .option('--auto-parse', 'Automatically parse PRD into tasks')
+    .action(async (description, options) => {
+    const { prdGenerate } = await import('./commands/prd.js');
+    return prdGenerate(description, {
+        mode: options.mode,
+        gates: options.gates,
+        model: options.model,
+        autoParse: options.autoParse,
+    });
+});
+prdCmd
+    .command('parse <file-or-id>')
+    .description('Parse a PRD markdown into executable tasks')
+    .option('--prd-id <id>', 'Add tasks to an existing PRD')
+    .option('--dry-run', 'Show tasks without saving')
+    .action(async (fileOrId, options) => {
+    const { prdParse } = await import('./commands/prd.js');
+    return prdParse(fileOrId, {
+        prdId: options.prdId,
+        dryRun: options.dryRun,
+    });
+});
+prdCmd
+    .command('run [prd-id]')
+    .description('Execute PRD tasks with Claude Code agent')
+    .option('--resume', 'Resume from previous execution')
+    .option('--task <task-id>', 'Run a specific task only')
+    .option('--dry-run', 'Show execution plan without running')
+    .option('--max-iterations <num>', 'Max full-PRD retries (default: 3)')
+    .option('--no-branch', 'Execute in current branch (no isolation)')
+    .option('--model <model>', 'Claude model override (default: sonnet)')
+    .option('--force', 'Force resume even if another runner may be active')
+    .option('--mode <mode>', 'Execution mode: loop (sequential) or team (parallel)', 'loop')
+    .option('--concurrency <num>', 'Max parallel workers in team mode (default: 3)')
+    .action(async (prdId, options) => {
+    const { prdRun } = await import('./commands/prd.js');
+    return prdRun(prdId, {
+        resume: options.resume,
+        task: options.task,
+        dryRun: options.dryRun,
+        maxIterations: options.maxIterations,
+        noBranch: options.noBranch,
+        model: options.model,
+        force: options.force,
+        mode: options.mode,
+        concurrency: options.concurrency,
+    });
+});
+prdCmd
+    .command('list')
+    .description('List all PRDs')
+    .option('--all', 'Include archived PRDs')
+    .action(async (options) => {
+    const { prdList } = await import('./commands/prd.js');
+    return prdList({ all: options.all });
+});
+prdCmd
+    .command('status [prd-id]')
+    .description('Show PRD status and tasks')
+    .option('--json', 'Output as JSON')
+    .option('--verbose', 'Show detailed task info')
+    .action(async (prdId, options) => {
+    const { prdStatus } = await import('./commands/prd.js');
+    return prdStatus(prdId, {
+        json: options.json,
+        verbose: options.verbose,
+    });
+});
+prdCmd
+    .command('archive [prd-id]')
+    .description('Archive a PRD (set status to archived)')
+    .option('--prd-id <id>', 'PRD ID to archive (or use positional argument)')
+    .action(async (prdId, options) => {
+    const { prdArchive } = await import('./commands/prd.js');
+    return prdArchive(prdId || options.prdId);
+});
+prdCmd
+    .command('export [prd-id]')
+    .description('Export PRD execution to Obsidian-compatible markdown with Mermaid diagrams')
+    .option('--output <dir>', 'Output directory (default: .succ/brain/prd)')
+    .option('--all', 'Export all PRDs')
+    .action(async (prdId, options) => {
+    const { prdExport } = await import('./commands/prd.js');
+    return prdExport(prdId, {
+        output: options.output,
+        all: options.all,
+    });
+});
+program.parse();
+//# sourceMappingURL=cli.js.map