@phantom-pm/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1627 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { basename, join, resolve } from 'path';
+import { Command } from 'commander';
+import { PHANTOM_ASCII, PHANTOM_VERSION, TAGLINE, FRAMEWORKS, getConfig, getContextEngine, getModuleManager, getSwarm, KNOWN_INTEGRATION_TARGETS, isKnownIntegrationTarget, scanIntegrations as scanIntegrationTargets, connectIntegration as connectIntegrationTarget, doctorIntegrations, analyzeScreenPath, auditScreensPath, generateRealDocumentation, getRealProducts, getRuntimeHealth, runDeterministicSimulation, } from '@phantom-pm/core';
+import { registerConfigCommands } from './commands/config.js';
+import { registerStoriesCommands } from './commands/stories.js';
+import { PhantomMCPServer, runStdioServer, PhantomDiscovery } from '@phantom-pm/mcp-server';
+import { theme, box, runBootSequence, showFirstRunSetup, renderModuleInstall, renderModuleStore, renderSwarmResult, renderHealthDashboard, } from '@phantom-pm/tui';
+const program = new Command();
+function printJson(payload) {
+    console.log(JSON.stringify(payload, null, 2));
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function failNotImplemented(command) {
+    console.error('');
+    console.error(theme.error(`  ${command} is not implemented in real runtime mode.`));
+    console.error(theme.secondary('  Use implemented commands: status, doctor, context, swarm, screen, health, docs, integrate, mcp.'));
+    console.error('');
+    process.exitCode = 1;
+}
+program
+    .name('phantom')
+    .description(TAGLINE)
+    .version(PHANTOM_VERSION, '-v, --version')
+    .action(async () => {
+    const config = getConfig();
+    if (config.isFirstRun()) {
+        await runBootSequence();
+        await showFirstRunSetup();
+        config.completeFirstRun();
+        return;
+    }
+    const cfg = config.get();
+    const stats = getContextEngine().getStats();
+    const lines = [
+        '',
+        `  ${theme.secondary('Version:')} ${PHANTOM_VERSION}`,
+        `  ${theme.secondary('Active project:')} ${cfg.activeProject || 'none'}`,
+        `  ${theme.secondary('Context files:')} ${stats.totalFiles}`,
+        `  ${theme.secondary('Installed modules:')} ${cfg.installedModules.length}`,
+        `  ${theme.secondary('Integrations:')} ${cfg.integrations.length}`,
+        '',
+        `  ${theme.dim('Try: phantom --help')}`,
+        '',
+    ];
+    console.log('');
+    console.log(theme.green(PHANTOM_ASCII));
+    console.log(box(lines.join('\n'), TAGLINE, 60));
+});
+const contextCommand = program.command('context').description('Manage product context');
+contextCommand
+    .command('add <path>')
+    .description('Add project files into deterministic local context index')
+    .option('--json', 'Output as JSON')
+    .action(async (targetPath, options) => {
+    const resolvedPath = resolve(targetPath);
+    const contextEngine = getContextEngine();
+    try {
+        const stats = await contextEngine.addPath(resolvedPath);
+        const config = getConfig();
+        config.addProject({
+            name: basename(resolvedPath) || 'project',
+            path: resolvedPath,
+            contextPaths: [resolvedPath],
+            createdAt: new Date().toISOString(),
+            lastAccessed: new Date().toISOString(),
+        });
+        if (options.json) {
+            printJson({ path: resolvedPath, stats });
+            return;
+        }
+        console.log('');
+        console.log(theme.success('  Context ingested successfully.'));
+        console.log(`  ${theme.secondary('Path:')} ${resolvedPath}`);
+        console.log(`  ${theme.secondary('Files indexed:')} ${stats.totalFiles}`);
+        console.log(`  ${theme.secondary('Total size:')} ${formatSize(stats.totalSize)}`);
+        console.log(`  ${theme.secondary('Health score:')} ${stats.healthScore}%`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown context indexing error';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+contextCommand
+    .description('Show active project context')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const config = getConfig();
+    const project = config.getActiveProject();
+    const stats = getContextEngine().getStats();
+    const payload = {
+        activeProject: project || null,
+        contextStats: stats,
+    };
+    if (options.json) {
+        printJson(payload);
+        return;
+    }
+    console.log('');
+    if (!project) {
+        console.log(theme.warning('  No active project. Add context first: phantom context add ./path'));
+        console.log('');
+        return;
+    }
+    console.log(theme.title('  PRODUCT CONTEXT'));
+    console.log(`  ${theme.secondary('Project:')} ${project.name}`);
+    console.log(`  ${theme.secondary('Path:')} ${project.path}`);
+    console.log(`  ${theme.secondary('Indexed files:')} ${stats.totalFiles}`);
+    console.log(`  ${theme.secondary('Health score:')} ${stats.healthScore}%`);
+    console.log('');
+});
+program
+    .command('install <module>')
+    .description('Install a built-in Phantom module')
+    .option('--json', 'Output as JSON')
+    .action(async (moduleName, options) => {
+    try {
+        const mm = getModuleManager();
+        const mod = await mm.install(moduleName);
+        if (options.json) {
+            printJson({ status: 'ok', module: mod });
+            return;
+        }
+        await renderModuleInstall(mod);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to install module';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+program
+    .command('modules')
+    .alias('store')
+    .description('Browse built-in module registry')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const mm = getModuleManager();
+    const config = getConfig();
+    const payload = {
+        available: mm.getAvailableModules(),
+        installed: config.get().installedModules,
+    };
+    if (options.json) {
+        printJson(payload);
+        return;
+    }
+    console.log(renderModuleStore(payload.available, payload.installed));
+});
+const integrateCommand = program.command('integrate').description('Integration operations');
+function connectIntegrationAndPrint(target, options) {
+    const normalized = target.toLowerCase();
+    if (!isKnownIntegrationTarget(normalized)) {
+        const error = `Unsupported integration target: ${target}`;
+        if (options.json) {
+            printJson({ status: 'error', error, supported: KNOWN_INTEGRATION_TARGETS });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${error}`));
+            console.log(`  ${theme.secondary(`Supported: ${KNOWN_INTEGRATION_TARGETS.join(', ')}`)}`);
+            console.log('');
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const connected = connectIntegrationTarget(normalized, process.cwd());
+    if (options.json) {
+        printJson({ status: 'ok', integration: connected });
+        return;
+    }
+    console.log('');
+    console.log(theme.success(`  Integration connected: ${connected.name}`));
+    if (connected.detectedPath) {
+        console.log(`  ${theme.secondary('Detected at:')} ${connected.detectedPath}`);
+    }
+    console.log('');
+}
+integrateCommand
+    .command('scan')
+    .description('Scan workspace for integration signals')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const scan = scanIntegrationTargets(process.cwd());
+    if (options.json) {
+        printJson({ integrations: scan });
+        return;
+    }
+    console.log('');
+    console.log(theme.title('  INTEGRATION SCAN'));
+    console.log('');
+    for (const item of scan) {
+        const mark = item.detected ? theme.check : theme.warning_icon;
+        console.log(`  ${mark} ${item.target} ${theme.dim(`(${item.reason})`)}`);
+        if (item.detectedPath)
+            console.log(`    ${theme.dim(item.detectedPath)}`);
+    }
+    console.log('');
+});
+integrateCommand
+    .command('doctor')
+    .description('Validate configured integrations')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const checks = doctorIntegrations(process.cwd());
+    if (options.json) {
+        printJson({ checks });
+        return;
+    }
+    console.log('');
+    console.log(theme.title('  INTEGRATION DOCTOR'));
+    console.log('');
+    for (const check of checks.filter(c => c.configured || c.detected)) {
+        const mark = check.healthy ? theme.check : theme.warning_icon;
+        console.log(`  ${mark} ${check.target} ${theme.dim(`(${check.reason})`)}`);
+        if (check.detectedPath)
+            console.log(`    ${theme.dim(check.detectedPath)}`);
+    }
+    if (!checks.some(c => c.configured || c.detected)) {
+        console.log(theme.warning('  No integration signals or configured targets yet.'));
+    }
+    console.log('');
+});
+integrateCommand
+    .command('connect <target>')
+    .description('Connect a specific integration target')
+    .option('--json', 'Output as JSON')
+    .action((target, options) => {
+    connectIntegrationAndPrint(target, options);
+});
+integrateCommand
+    .description('Show integration usage')
+    .action(() => {
+    console.log('');
+    console.log(`  ${theme.secondary('Usage:')}`);
+    console.log(`  ${theme.accent('phantom integrate scan --json')}`);
+    console.log(`  ${theme.accent('phantom integrate connect github --json')}`);
+    console.log(`  ${theme.accent('phantom integrate doctor --json')}`);
+    console.log(`  ${theme.accent('phantom integrate github --json')}`);
+    console.log('');
+});
+const mcpCommand = program.command('mcp').description('MCP server commands');
+mcpCommand
+    .command('tools')
+    .description('List supported MCP tools')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const server = new PhantomMCPServer();
+    const tools = server.listTools();
+    if (options.json) {
+        printJson({ tools });
+        return;
+    }
+    console.log('');
+    console.log(theme.title('  MCP TOOLS'));
+    console.log('');
+    for (const tool of tools) {
+        console.log(`  ${theme.check} ${tool.name}`);
+        console.log(`    ${theme.dim(tool.description)}`);
+    }
+    console.log('');
+});
+mcpCommand
+    .command('serve')
+    .description('Run MCP server over stdio')
+    .option('--mode <mode>', 'transport mode', 'stdio')
+    .action(async (options) => {
+    if (options.mode !== 'stdio') {
+        console.log('');
+        console.log(theme.warning(`  Unsupported mode '${options.mode}', using stdio.`));
+        console.log('');
+    }
+    await runStdioServer();
+});
+program
+    .command('status')
+    .description('Show Phantom runtime status')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const cfgMgr = getConfig();
+    const cfg = cfgMgr.get();
+    const payload = {
+        version: PHANTOM_VERSION,
+        firstRun: cfg.firstRun,
+        activeProject: cfgMgr.getActiveProject() || null,
+        installedModules: cfg.installedModules,
+        integrations: cfg.integrations,
+        dataMode: cfg.dataMode,
+        permissionLevel: cfg.permissionLevel,
+        theme: cfg.theme,
+        installation: cfg.installation,
+        mcp: cfg.mcp,
+        security: cfg.security,
+    };
+    if (options.json) {
+        printJson(payload);
+        return;
+    }
+    console.log('');
+    console.log(theme.title('  PHANTOM STATUS'));
+    console.log(`  ${theme.secondary('Version:')} ${payload.version}`);
+    console.log(`  ${theme.secondary('Active Project:')} ${payload.activeProject?.name || 'none'}`);
+    console.log(`  ${theme.secondary('Installed Modules:')} ${payload.installedModules.length}`);
+    console.log(`  ${theme.secondary('Integrations:')} ${payload.integrations.length}`);
+    console.log('');
+});
+program
+    .command('doctor')
+    .description('Run local environment and Phantom health checks')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const cfgMgr = getConfig();
+    const cfg = cfgMgr.get();
+    const checks = [
+        {
+            name: 'Config directory',
+            ok: existsSync(cfgMgr.getConfigDir()),
+            detail: cfgMgr.getConfigDir(),
+        },
+        {
+            name: 'Context entries present',
+            ok: getContextEngine().getEntries().length > 0,
+            detail: `${getContextEngine().getEntries().length}`,
+        },
+        {
+            name: 'CLI build artifact',
+            ok: existsSync(join(process.cwd(), 'packages/cli/dist/index.js')),
+            detail: 'packages/cli/dist/index.js',
+        },
+        {
+            name: 'Config schema keys',
+            ok: typeof cfg.installation.channel === 'string' &&
+                typeof cfg.installation.version === 'string' &&
+                typeof cfg.mcp.enabled === 'boolean' &&
+                typeof cfg.mcp.server_mode === 'string' &&
+                Array.isArray(cfg.integrations) &&
+                typeof cfg.security.audit_log_path === 'string',
+            detail: 'installation/mcp/integrations/security',
+        },
+    ];
+    const passCount = checks.filter(c => c.ok).length;
+    const payload = {
+        checks,
+        summary: {
+            passing: passCount,
+            total: checks.length,
+            healthy: passCount === checks.length,
+        },
+    };
+    if (options.json) {
+        printJson(payload);
+        return;
+    }
+    console.log('');
+    console.log(theme.title('  PHANTOM DOCTOR'));
+    console.log('');
+    for (const check of checks) {
+        const icon = check.ok ? theme.check : theme.warning_icon;
+        console.log(`  ${icon} ${check.name.padEnd(26)} ${theme.dim(check.detail)}`);
+    }
+    console.log('');
+    if (payload.summary.healthy) {
+        console.log(theme.success(`  All checks passed (${passCount}/${checks.length}).`));
+    }
+    else {
+        console.log(theme.warning(`  Some checks need attention (${passCount}/${checks.length}).`));
+    }
+    console.log('');
+});
+const prdCommand = program.command('prd').description('PRD operations');
+// Register config commands
+registerConfigCommands(program);
+// Register stories commands
+registerStoriesCommands(program);
+prdCommand
+    .command('create <title>')
+    .description('Generate AI-powered PRD from title + local context')
+    .option('--out <path>', 'Output file path')
+    .option('--json', 'Output as JSON')
+    .option('--technical', 'Include technical requirements')
+    .option('--ux', 'Include UX wireframe descriptions')
+    .option('--metrics', 'Include metrics framework')
+    .action(async (title, options) => {
+    try {
+        const moduleManager = getModuleManager();
+        // Ensure prd-forge module is installed
+        if (!moduleManager.isInstalled('prd-forge')) {
+            console.log('');
+            console.log(theme.warning('  PRD Forge module not installed. Installing...'));
+            await moduleManager.install('prd-forge');
+        }
+        const result = await moduleManager.executeCommand('prd-forge', 'prd create', {
+            title,
+            technical: options.technical,
+            ux: options.ux,
+            metrics: options.metrics,
+            output: options.out || './phantom-output/prds',
+        });
+        const outputPath = result.prd.filePath || './phantom-output/prds';
+        const payload = {
+            status: 'ok',
+            module: 'prd-forge',
+            prd: result.prd,
+            metadata: result.metadata,
+        };
+        if (options.json) {
+            printJson(payload);
+            return;
+        }
+        console.log('');
+        console.log(theme.success(`  PRD generated: ${result.prd.title}`));
+        console.log(`  ${theme.secondary('ID:')} ${result.prd.id}`);
+        console.log(`  ${theme.secondary('Sections:')} ${result.prd.sections.length}`);
+        console.log(`  ${theme.secondary('Model:')} ${result.metadata.model}`);
+        console.log(`  ${theme.secondary('Tokens:')} ${result.metadata.tokenCount}`);
+        console.log(`  ${theme.secondary('Output:')} ${outputPath}`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to generate PRD';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+prdCommand
+    .command('list')
+    .description('List generated PRDs from phantom-output directory')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const outDir = join(process.cwd(), 'phantom-output');
+    const items = existsSync(outDir)
+        ? readdirSync(outDir)
+            .filter(file => file.endsWith('.md'))
+            .map(file => {
+            const path = join(outDir, file);
+            return {
+                name: file,
+                path,
+                sizeBytes: statSync(path).size,
+            };
+        })
+            .sort((a, b) => a.name.localeCompare(b.name))
+        : [];
+    if (options.json) {
+        printJson({ files: items });
+        return;
+    }
+    console.log('');
+    console.log(theme.title('  PRD LIBRARY'));
+    console.log('');
+    if (items.length === 0) {
+        console.log(theme.warning('  No PRDs found in phantom-output/.'));
+    }
+    else {
+        for (const item of items) {
+            console.log(`  ${theme.check} ${item.name} ${theme.dim(`(${formatSize(item.sizeBytes)})`)}`);
+        }
+    }
+    console.log('');
+});
+program
+    .command('swarm <question>')
+    .description('Run deterministic multi-agent product analysis')
+    .option('--json', 'Output as JSON')
+    .action(async (question, options) => {
+    try {
+        const result = await getSwarm().runSwarm(question);
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        console.log(renderSwarmResult(result));
+        console.log(`  ${theme.dim(`Evidence count: ${result.evidence.length}`)}`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Swarm analysis failed';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+const screenCommand = program.command('screen').description('Screen analysis commands');
+screenCommand
+    .command('analyze <path>')
+    .description('Analyze a single screenshot with deterministic UX checks')
+    .option('--json', 'Output as JSON')
+    .action((targetPath, options) => {
+    try {
+        const analysis = analyzeScreenPath(targetPath);
+        if (options.json) {
+            printJson(analysis);
+            return;
+        }
+        console.log('');
+        console.log(theme.title(`  SCREEN ANALYSIS: ${analysis.filename}`));
+        console.log(`  ${theme.secondary('Path:')} ${analysis.path}`);
+        console.log(`  ${theme.secondary('Score:')} ${analysis.score}/100`);
+        console.log(`  ${theme.secondary('Components detected:')} ${analysis.componentsDetected}`);
+        for (const issue of analysis.issues) {
+            console.log(`  ${theme.warning_icon} ${issue.severity} ${issue.message}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Screen analysis failed';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+screenCommand
+    .command('audit [path]')
+    .description('Audit one image or image directory')
+    .option('--json', 'Output as JSON')
+    .action((targetPath, options) => {
+    try {
+        const audit = auditScreensPath(targetPath || join(process.cwd(), 'screenshots'));
+        if (options.json) {
+            printJson(audit);
+            return;
+        }
+        console.log('');
+        console.log(theme.title('  SCREEN AUDIT'));
+        console.log(`  ${theme.secondary('Files analyzed:')} ${audit.filesAnalyzed}`);
+        console.log(`  ${theme.secondary('Overall score:')} ${audit.overallScore}/100`);
+        console.log(`  ${theme.secondary('Issues:')} HIGH=${audit.issuesBySeverity.HIGH} MED=${audit.issuesBySeverity.MED} LOW=${audit.issuesBySeverity.LOW}`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Screen audit failed';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+program
+    .command('health')
+    .description('Show real runtime health metrics')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const data = getRuntimeHealth(process.cwd());
+    if (options.json) {
+        printJson(data);
+        return;
+    }
+    console.log('');
+    console.log(renderHealthDashboard(data));
+    console.log('');
+});
+program
+    .command('simulate <scenario>')
+    .description('Run deterministic simulation for a product scenario')
+    .option('--json', 'Output as JSON')
+    .action((scenario, options) => {
+    const result = runDeterministicSimulation(scenario);
+    if (options.json) {
+        printJson(result);
+        return;
+    }
+    console.log('');
+    console.log(theme.title('  DETERMINISTIC SIMULATION'));
+    console.log(`  ${theme.secondary('Scenario:')} ${result.scenario}`);
+    console.log(`  ${theme.secondary('Seed:')} ${result.seed}`);
+    console.log(`  ${theme.secondary('Baseline:')} ${result.metrics.baseline}`);
+    console.log(`  ${theme.secondary('Projected:')} ${result.metrics.projected}`);
+    console.log(`  ${theme.secondary('Delta (%):')} ${result.metrics.deltaPercent}`);
+    console.log(`  ${theme.secondary('Confidence:')} ${result.metrics.confidence}%`);
+    console.log('');
+});
+program
+    .command('nudge')
+    .description('Show intelligent nudges and suggestions')
+    .option('--json', 'Output as JSON')
+    .option('--dismiss <id>', 'Dismiss a specific nudge')
+    .option('--snooze <id>', 'Snooze a nudge (minutes)')
+    .option('--refresh', 'Generate new nudges based on current context')
+    .action(async (options) => {
+    try {
+        const { NudgeEngine, getConfig, getContextEngine, getModuleManager } = await import('@phantom/core');
+        const engine = new NudgeEngine();
+        // Handle dismiss/snooze actions
+        if (options.dismiss) {
+            const success = engine.dismissNudge(options.dismiss);
+            if (options.json) {
+                printJson({ status: success ? 'ok' : 'error', action: 'dismiss', id: options.dismiss });
+            }
+            else if (success) {
+                console.log(theme.success(`  Nudge dismissed: ${options.dismiss}`));
+            }
+            else {
+                console.log(theme.error(`  Failed to dismiss nudge: ${options.dismiss}`));
+            }
+            return;
+        }
+        if (options.snooze) {
+            const [id, minutesStr] = options.snooze.split(':');
+            const minutes = parseInt(minutesStr || '60');
+            const success = engine.snoozeNudge(id, minutes);
+            if (options.json) {
+                printJson({ status: success ? 'ok' : 'error', action: 'snooze', id, minutes });
+            }
+            else if (success) {
+                console.log(theme.success(`  Nudge snoozed for ${minutes} minutes: ${id}`));
+            }
+            else {
+                console.log(theme.error(`  Failed to snooze nudge: ${id}`));
+            }
+            return;
+        }
+        // Generate new nudges if requested
+        if (options.refresh) {
+            const config = getConfig();
+            const cfg = config.get();
+            const context = getContextEngine();
+            const modules = getModuleManager();
+            const userContext = {
+                activeProject: cfg.activeProject || null,
+                installedModules: cfg.installedModules,
+                connectedAgents: [], // TODO: Get from registry
+                recentActions: [], // TODO: Track recent actions
+                currentDirectory: process.cwd(),
+                timeOfDay: new Date().getHours().toString(),
+                dayOfWeek: new Date().getDay().toString()
+            };
+            await engine.generateNudges(userContext);
+        }
+        // Get current nudges
+        const nudges = engine.getCurrentNudges();
+        const stats = engine.getNudgeStats();
+        if (options.json) {
+            printJson({ nudges, stats });
+            return;
+        }
+        console.log('');
+        console.log(theme.title('  INTELLIGENT NUDGES'));
+        console.log(theme.secondary(`  Active: ${stats.active} | Total Generated: ${stats.totalGenerated}`));
+        console.log('');
+        if (nudges.length === 0) {
+            console.log(theme.success('  🎉 No active nudges. Everything looks good!'));
+            console.log(theme.dim('  Run with --refresh to generate new contextual suggestions'));
+            console.log('');
+            return;
+        }
+        // Display nudges by priority
+        const priorityOrder = ['critical', 'high', 'medium', 'low'];
+        for (const priority of priorityOrder) {
+            const priorityNudges = nudges.filter(n => n.priority === priority);
+            if (priorityNudges.length === 0)
+                continue;
+            const priorityTitle = {
+                'critical': '🚨 CRITICAL ALERTS',
+                'high': '⚠️  HIGH PRIORITY',
+                'medium': '💡 RECOMMENDATIONS',
+                'low': '📢 SUGGESTIONS'
+            }[priority];
+            console.log(theme.title(`  ${priorityTitle}`));
+            console.log('');
+            for (const nudge of priorityNudges) {
+                const typeIcon = {
+                    'suggestion': '💡',
+                    'warning': '⚠️',
+                    'opportunity': '✨',
+                    'insight': '🔮',
+                    'alert': '🚨'
+                }[nudge.type] || '📋';
+                console.log(`  ${typeIcon} ${theme.accent(nudge.title)}`);
+                console.log(`     ${nudge.message}`);
+                if (nudge.command) {
+                    console.log(`     ${theme.dim(`Command: ${nudge.command}`)}`);
+                }
+                if (nudge.suggestions.length > 0) {
+                    console.log(`     ${theme.dim('Suggestions:')} ${nudge.suggestions.join(' • ')}`);
+                }
+                console.log(`     ${theme.dim(`ID: ${nudge.id} | ${new Date(nudge.timestamp).toLocaleString()}`)}`);
+                console.log('');
+            }
+        }
+        console.log(theme.dim('  Use: phantom nudge --dismiss <id> to dismiss a nudge'));
+        console.log(theme.dim('  Use: phantom nudge --snooze <id>:<minutes> to snooze'));
+        console.log(theme.dim('  Use: phantom nudge --refresh to generate new suggestions'));
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Nudge system error';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+program
+    .command('products')
+    .description('Show persisted project/product portfolio')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const products = getRealProducts(process.cwd());
+    if (options.json) {
+        printJson({ products });
+        return;
+    }
+    if (products.length === 0) {
+        console.log('');
+        console.log(theme.warning('  No products found. Add context with: phantom context add ./project'));
+        console.log('');
+        return;
+    }
+    const lines = products.map((p) => {
+        const status = p.active ? theme.success('active') : p.paused ? theme.warning('paused') : theme.dim('tracked');
+        return `  ${p.name.padEnd(28)} ${status}  health=${p.health}%  context_files=${p.contextFiles}`;
+    });
+    console.log('');
+    console.log(box(lines.join('\n'), 'PRODUCT PORTFOLIO', 80));
+    console.log('');
+});
+const docsCommand = program.command('docs').description('Documentation operations');
+const sprintCommand = program.command('sprint').description('Sprint planning operations');
+sprintCommand
+    .command('plan')
+    .description('Plan a new sprint')
+    .option('--goal <string>', 'Sprint goal')
+    .option('--duration <days>', 'Sprint duration in days', '14')
+    .option('--velocity <points>', 'Team velocity in story points')
+    .option('--backlog <path>', 'Path to backlog file')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const moduleManager = getModuleManager();
+        // Ensure sprint-planner module is installed
+        if (!moduleManager.isInstalled('sprint-planner')) {
+            console.log('');
+            console.log(theme.warning('  Sprint Planner module not installed. Installing...'));
+            await moduleManager.install('sprint-planner');
+        }
+        const result = await moduleManager.executeCommand('sprint-planner', 'sprint plan', {
+            goal: options.goal,
+            duration: options.duration ? parseInt(options.duration) : undefined,
+            velocity: options.velocity ? parseInt(options.velocity) : undefined,
+            backlog: options.backlog,
+            _: ['plan'],
+        });
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        console.log('');
+        console.log(theme.success('  Sprint plan generated successfully!'));
+        console.log(`  ${theme.secondary('Sprint:')} ${result.sprint.name}`);
+        console.log(`  ${theme.secondary('Goal:')} ${result.sprint.goal}`);
+        console.log(`  ${theme.secondary('Stories:')} ${result.sprint.stories}`);
+        console.log(`  ${theme.secondary('Total Points:')} ${result.sprint.totalPoints}`);
+        console.log(`  ${theme.secondary('Dates:')} ${result.sprint.startDate} to ${result.sprint.endDate}`);
+        console.log(`  ${theme.secondary('Output:')} ${result.filePath}`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to generate sprint plan';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+sprintCommand
+    .command('retro')
+    .description('Generate sprint retrospective')
+    .option('--sprint <path>', 'Path to sprint data file')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const moduleManager = getModuleManager();
+        // Ensure sprint-planner module is installed
+        if (!moduleManager.isInstalled('sprint-planner')) {
+            console.log('');
+            console.log(theme.warning('  Sprint Planner module not installed. Installing...'));
+            await moduleManager.install('sprint-planner');
+        }
+        const result = await moduleManager.executeCommand('sprint-planner', 'sprint retro', {
+            sprint: options.sprint,
+            _: ['retro'],
+        });
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        console.log('');
+        console.log(theme.success('  Sprint retrospective generated successfully!'));
+        console.log(`  ${theme.secondary('Type:')} ${result.type}`);
+        if (result.filePath) {
+            console.log(`  ${theme.secondary('Output:')} ${result.filePath}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to generate sprint retrospective';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+sprintCommand
+    .description('Show sprint planning usage')
+    .action(() => {
+    console.log('');
+    console.log(theme.title('  SPRINT PLANNING'));
+    console.log(theme.secondary('  AI-powered sprint planning with velocity tracking'));
+    console.log('');
+    console.log(`  ${theme.accent('phantom sprint plan --goal "Sprint Goal"')}`);
+    console.log(`  ${theme.accent('phantom sprint plan --duration 10 --velocity 15')}`);
+    console.log(`  ${theme.accent('phantom sprint retro --sprint ./sprint-data.json')}`);
+    console.log('');
+});
+const bridgeCommand = program.command('bridge').description('PM ↔ Dev translation operations');
+bridgeCommand
+    .command('translate <intent>')
+    .description('Translate PM intent to technical tasks')
+    .option('--constraints <constraints>', 'Comma-separated constraints')
+    .option('--json', 'Output as JSON')
+    .action(async (intent, options) => {
+    try {
+        const moduleManager = getModuleManager();
+        // Ensure bridge module is installed
+        if (!moduleManager.isInstalled('bridge')) {
+            console.log('');
+            console.log(theme.warning('  Bridge module not installed. Installing...'));
+            await moduleManager.install('bridge');
+        }
+        const result = await moduleManager.executeCommand('bridge', 'bridge translate', {
+            intent,
+            constraints: options.constraints,
+            _: ['translate', intent],
+        });
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        console.log('');
+        console.log(theme.success('  Translation completed successfully!'));
+        console.log(`  ${theme.secondary('Technical Tasks:')} ${result.translation.technicalTasks.length}`);
+        console.log(`  ${theme.secondary('Acceptance Criteria:')} ${result.translation.acceptanceCriteria.length}`);
+        console.log(`  ${theme.secondary('Risks Identified:')} ${result.translation.risks.length}`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to translate PM intent';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+bridgeCommand
+    .command('spec <requirements>')
+    .description('Generate technical specification from requirements')
+    .option('--json', 'Output as JSON')
+    .action(async (requirements, options) => {
+    try {
+        const moduleManager = getModuleManager();
+        // Ensure bridge module is installed
+        if (!moduleManager.isInstalled('bridge')) {
+            console.log('');
+            console.log(theme.warning('  Bridge module not installed. Installing...'));
+            await moduleManager.install('bridge');
+        }
+        const result = await moduleManager.executeCommand('bridge', 'bridge spec', {
+            requirements,
+            _: ['spec', requirements],
+        });
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        console.log('');
+        console.log(theme.success('  Technical specification generated successfully!'));
+        console.log(`  ${theme.secondary('Architecture:')} ${result.specification.architecture}`);
+        console.log(`  ${theme.secondary('API Endpoints:')} ${result.specification.apiEndpoints.length}`);
+        console.log(`  ${theme.secondary('Dependencies:')} ${result.specification.dependencies.length}`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to generate technical specification';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+bridgeCommand
+    .description('Show bridge usage')
+    .action(() => {
+    console.log('');
+    console.log(theme.title('  BRIDGE TRANSLATION'));
+    console.log(theme.secondary('  Bidirectional PM ↔ Dev translation engine'));
+    console.log('');
+    console.log(`  ${theme.accent('phantom bridge translate "Implement user authentication"')}`);
+    console.log(`  ${theme.accent('phantom bridge spec "Authentication system with OAuth support"')}`);
+    console.log('');
+});
+// Add the new commands to the existing command structure
+const competitiveCommand = program.command('competitive').description('Competitive analysis operations');
+competitiveCommand
+    .command('analyze <subject>')
+    .description('Analyze competitors in a market space')
+    .option('--depth <level>', 'Analysis depth (brief|detailed|comprehensive)', 'detailed')
+    .option('--trends', 'Include market trends')
+    .option('--json', 'Output as JSON')
+    .action(async (subject, options) => {
+    try {
+        const moduleManager = getModuleManager();
+        // Ensure competitive module is installed
+        if (!moduleManager.isInstalled('competitive')) {
+            console.log('');
+            console.log(theme.warning('  Competitive Analysis module not installed. Installing...'));
+            await moduleManager.install('competitive');
+        }
+        const result = await moduleManager.executeCommand('competitive', 'competitive analyze', {
+            subject,
+            depth: options.depth,
+            trends: options.trends,
+            _: ['analyze', subject],
+        });
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        console.log('');
+        console.log(theme.success('  Competitive analysis completed successfully!'));
+        console.log(`  ${theme.secondary('Subject:')} ${result.analysis.subject}`);
+        console.log(`  ${theme.secondary('Competitors Found:')} ${result.analysis.competitorCount}`);
+        console.log(`  ${theme.secondary('Output:')} ${result.filePath}`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to run competitive analysis';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+competitiveCommand
+    .command('watch <competitor>')
+    .description('Watch a competitor for updates')
+    .option('--json', 'Output as JSON')
+    .action(async (competitor, options) => {
+    try {
+        const moduleManager = getModuleManager();
+        // Ensure competitive module is installed
+        if (!moduleManager.isInstalled('competitive')) {
+            console.log('');
+            console.log(theme.warning('  Competitive Analysis module not installed. Installing...'));
+            await moduleManager.install('competitive');
+        }
+        const result = await moduleManager.executeCommand('competitive', 'competitive watch', {
+            competitor,
+            _: ['watch', competitor],
+        });
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        console.log('');
+        console.log(theme.success('  Competitor watch initiated!'));
+        console.log(`  ${theme.secondary('Competitor:')} ${result.competitor}`);
+        console.log(`  ${theme.secondary('Report:')} ${result.report}`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to initiate competitor watch';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+competitiveCommand
+    .description('Show competitive analysis usage')
+    .action(() => {
+    console.log('');
+    console.log(theme.title('  COMPETITIVE ANALYSIS'));
+    console.log(theme.secondary('  Monitor competitors and analyze market positioning'));
+    console.log('');
+    console.log(`  ${theme.accent('phantom competitive analyze "project management software"')}`);
+    console.log(`  ${theme.accent('phantom competitive watch "Notion"')}`);
+    console.log(`  ${theme.accent('phantom competitive analyze "AI tools" --depth comprehensive')}`);
+    console.log('');
+});
+const analyticsCommand = program.command('analytics').description('Analytics operations');
+analyticsCommand
+    .command('dashboard')
+    .description('Generate analytics dashboard')
+    .option('--period <days>', 'Analysis period', 'last 30 days')
+    .option('--categories <list>', 'Comma-separated metric categories')
+    .option('--format <type>', 'Output format (json|markdown)', 'json')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const moduleManager = getModuleManager();
+        // Ensure analytics-lens module is installed
+        if (!moduleManager.isInstalled('analytics-lens')) {
+            console.log('');
+            console.log(theme.warning('  Analytics Lens module not installed. Installing...'));
+            await moduleManager.install('analytics-lens');
+        }
+        const result = await moduleManager.executeCommand('analytics-lens', 'analytics dashboard', {
+            period: options.period,
+            categories: options.categories,
+            format: options.format,
+            _: ['dashboard'],
+        });
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        console.log('');
+        console.log(theme.success('  Analytics dashboard generated successfully!'));
+        console.log(`  ${theme.secondary('Dashboard:')} ${result.dashboard.name}`);
+        console.log(`  ${theme.secondary('Period:')} ${result.dashboard.period}`);
+        console.log(`  ${theme.secondary('Metrics:')} ${result.dashboard.metricCount}`);
+        console.log(`  ${theme.secondary('Output:')} ${result.filePath}`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to generate analytics dashboard';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+analyticsCommand
+    .command('report')
+    .description('Generate analytics report')
+    .option('--period <days>', 'Analysis period', 'last quarter')
+    .option('--focus <area>', 'Report focus area')
+    .option('--format <type>', 'Output format (json|markdown)', 'json')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const moduleManager = getModuleManager();
+        // Ensure analytics-lens module is installed
+        if (!moduleManager.isInstalled('analytics-lens')) {
+            console.log('');
+            console.log(theme.warning('  Analytics Lens module not installed. Installing...'));
+            await moduleManager.install('analytics-lens');
+        }
+        const result = await moduleManager.executeCommand('analytics-lens', 'analytics report', {
+            period: options.period,
+            focus: options.focus,
+            format: options.format,
+            _: ['report'],
+        });
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        console.log('');
+        console.log(theme.success('  Analytics report generated successfully!'));
+        console.log(`  ${theme.secondary('Report:')} ${result.report.title}`);
+        console.log(`  ${theme.secondary('Period:')} ${result.report.period}`);
+        console.log(`  ${theme.secondary('Metrics:')} ${result.report.metricCount}`);
+        console.log(`  ${theme.secondary('Output:')} ${result.filePath}`);
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to generate analytics report';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+analyticsCommand
+    .description('Show analytics usage')
+    .action(() => {
+    console.log('');
+    console.log(theme.title('  ANALYTICS LENS'));
+    console.log(theme.secondary('  Connect to analytics platforms and surface actionable insights'));
+    console.log('');
+    console.log(`  ${theme.accent('phantom analytics dashboard')}`);
+    console.log(`  ${theme.accent('phantom analytics report --period "last quarter"')}`);
+    console.log(`  ${theme.accent('phantom analytics dashboard --categories "user-engagement,revenue"')}`);
+    console.log('');
+});
+docsCommand
+    .command('generate')
+    .description('Generate deterministic documentation artifacts')
+    .option('--out <path>', 'Output directory path')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    try {
+        const files = generateRealDocumentation(process.cwd(), options.out);
+        if (options.json) {
+            printJson({ files });
+            return;
+        }
+        console.log('');
+        console.log(theme.success('  Documentation generated:'));
+        for (const file of files) {
+            console.log(`  ${theme.check} ${file}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Documentation generation failed';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+program
+    .command('frameworks [action] [framework]')
+    .description('List built-in PM frameworks')
+    .option('--json', 'Output as JSON')
+    .action((action, framework, options) => {
+    if (!action || action === 'list') {
+        if (options.json) {
+            printJson({ frameworks: FRAMEWORKS });
+            return;
+        }
+        console.log('');
+        console.log(theme.title('  PM FRAMEWORKS'));
+        console.log('');
+        for (const fw of FRAMEWORKS) {
+            console.log(`  ${theme.check} ${fw.name} ${theme.dim(`— ${fw.desc}`)}`);
+        }
+        console.log('');
+        return;
+    }
+    if (action === 'apply') {
+        const payload = {
+            status: 'not_implemented',
+            message: 'Framework auto-apply is not implemented in real runtime mode.',
+            framework: framework || null,
+        };
+        if (options.json) {
+            printJson(payload);
+        }
+        else {
+            console.log('');
+            console.log(theme.warning(`  ${payload.message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+        return;
+    }
+    process.exitCode = 1;
+});
+program
+    .command('dashboard')
+    .alias('dash')
+    .description('Show concise runtime summary')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+    const cfg = getConfig().get();
+    const stats = getContextEngine().getStats();
+    const health = getRuntimeHealth(process.cwd());
+    const payload = {
+        activeProject: cfg.activeProject || null,
+        contextFiles: stats.totalFiles,
+        contextHealth: stats.healthScore,
+        installedModules: cfg.installedModules.length,
+        connectedIntegrations: health.integrations.filter(i => i.connected).length,
+        primaryModel: health.primaryModel,
+    };
+    if (options.json) {
+        printJson(payload);
+        return;
+    }
+    console.log('');
+    console.log(box([
+        '',
+        `  Active Project: ${payload.activeProject || 'none'}`,
+        `  Context Files: ${payload.contextFiles} (health ${payload.contextHealth}%)`,
+        `  Installed Modules: ${payload.installedModules}`,
+        `  Connected Integrations: ${payload.connectedIntegrations}`,
+        `  Primary Model: ${payload.primaryModel.provider}/${payload.primaryModel.model} (${payload.primaryModel.status})`,
+        '',
+    ].join('\n'), 'PHANTOM DASHBOARD', 78));
+    console.log('');
+});
+// Agent Matrix Commands
+const agentsCommand = program.command('agents').description('Agent Matrix - Connect and coordinate all AI agents');
+agentsCommand
+    .command('register')
+    .description('Register PHANTOM with all detected AI agents')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        if (options.json) {
+            // JSON output for programmatic use
+            const agents = PhantomDiscovery.detectInstalledAgents();
+            const installed = agents.filter((a) => a.installed);
+            const results = [];
+            for (const agent of installed) {
+                const success = await PhantomDiscovery.registerWithAgent(agent.type);
+                results.push({
+                    agent: agent.name,
+                    type: agent.type,
+                    success,
+                    status: success ? 'registered' : 'failed'
+                });
+            }
+            printJson({
+                timestamp: new Date().toISOString(),
+                total_agents: installed.length,
+                successful_registrations: results.filter(r => r.success).length,
+                results
+            });
+            return;
+        }
+        // Interactive output
+        await PhantomDiscovery.autoRegisterAll();
+    }
+    catch (error) {
+        console.error(theme.error('  Failed to register agents:'), error);
+        process.exitCode = 1;
+    }
+});
+agentsCommand
+    .command('health')
+    .description('Check PHANTOM and agent connection health')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        if (options.json) {
+            // Implement JSON health check
+            const mcpRunning = await PhantomDiscovery.detectPhantom();
+            const agents = PhantomDiscovery.detectInstalledAgents();
+            const healthData = {
+                timestamp: new Date().toISOString(),
+                mcp_server: {
+                    status: mcpRunning ? 'running' : 'not_responding',
+                    version: '1.0.0'
+                },
+                agents: agents.map((agent) => {
+                    const configPath = PhantomDiscovery.AGENT_CONFIG_PATHS[agent.type];
+                    let registered = false;
+                    if (configPath && existsSync(configPath)) {
+                        try {
+                            const config = JSON.parse(readFileSync(configPath, 'utf8'));
+                            registered = config.mcpServers?.phantom !== undefined;
+                        }
+                        catch {
+                            registered = false;
+                        }
+                    }
+                    return {
+                        name: agent.name,
+                        type: agent.type,
+                        installed: agent.installed,
+                        registered,
+                        status: agent.installed ? (registered ? 'connected' : 'detected_not_registered') : 'not_installed'
+                    };
+                })
+            };
+            printJson(healthData);
+            return;
+        }
+        // Interactive health check
+        await PhantomDiscovery.healthCheck();
+    }
+    catch (error) {
+        console.error(theme.error('  Health check failed:'), error);
+        process.exitCode = 1;
+    }
+});
+agentsCommand
+    .command('scan')
+    .description('Scan system for installed AI agents and LLMs')
+    .option('--register', 'Automatically register detected agents')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const { AgentDiscovery, AgentRegistry } = await import('@phantom/core');
+        const discovery = new AgentDiscovery();
+        const agents = await discovery.scanSystem();
+        if (options.register) {
+            const registry = new AgentRegistry();
+            const registered = await registry.scanAndRegister();
+            if (options.json) {
+                printJson({ detected: agents, registered: registered.map(r => r.id) });
+                return;
+            }
+            console.log('');
+            console.log(theme.success(`  Registered ${registered.length} new agents:`));
+            for (const agent of registered) {
+                console.log(`    • ${agent.signature.name}`);
+            }
+            console.log('');
+        }
+        if (options.json && !options.register) {
+            printJson({ agents });
+            return;
+        }
+        if (!options.register) {
+            console.log('');
+            console.log(theme.title('  DETECTED AGENTS'));
+            console.log('');
+            if (agents.length === 0) {
+                console.log(theme.warning('  No AI agents detected in your system.'));
+                console.log(theme.dim('  Supported: Claude Code, Cursor, Codex, Gemini, ChatGPT, VS Code, Zed'));
+                console.log('');
+                return;
+            }
+            for (const agent of agents) {
+                const statusIcon = agent.status === 'running' ? '🟢' : '🔵';
+                const confidenceColor = agent.confidence > 80 ? theme.success :
+                    agent.confidence > 60 ? theme.warning : theme.dim;
+                console.log(`  ${statusIcon} ${theme.accent(agent.signature.name)}`);
+                console.log(`     ${theme.secondary(agent.signature.description)}`);
+                console.log(`     ${confidenceColor(`Confidence: ${agent.confidence}%`)} | Status: ${agent.status}`);
+                if (agent.detectedPaths.length > 0) {
+                    console.log(`     ${theme.dim(`Paths: ${agent.detectedPaths.join(', ')}`)}`);
+                }
+                console.log('');
+            }
+            console.log(theme.dim('  Run with --register to automatically register detected agents'));
+            console.log('');
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Agent scan failed';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+agentsCommand
+    .command('list')
+    .description('List registered agents and their integration status')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const { AgentRegistry } = await import('@phantom/core');
+        const registry = new AgentRegistry();
+        const agents = registry.getAllAgents();
+        if (options.json) {
+            printJson({ agents });
+            return;
+        }
+        console.log('');
+        console.log(theme.title('  REGISTERED AGENTS'));
+        console.log('');
+        if (agents.length === 0) {
+            console.log(theme.warning('  No agents registered yet.'));
+            console.log(theme.dim('  Run: phantom agents scan'));
+            console.log('');
+            return;
+        }
+        for (const agent of agents) {
+            const statusIcon = {
+                'connected': '🟢',
+                'running': '🟢',
+                'available': '🔵',
+                'installed': '🔵',
+                'offline': '🔴',
+                'unknown': '⚪'
+            }[agent.status] || '⚪';
+            const integrationLevel = agent.phantomIntegration.level;
+            const levelColor = integrationLevel === 'full' ? theme.success :
+                integrationLevel === 'enhanced' ? theme.warning :
+                    theme.dim;
+            console.log(`  ${statusIcon} ${theme.accent(agent.signature.name)}`);
+            console.log(`     Integration: ${levelColor(integrationLevel)}`);
+            console.log(`     Features: ${agent.phantomIntegration.featuresEnabled.join(', ') || 'None'}`);
+            console.log(`     Reliability: ${agent.performance.reliability}%`);
+            console.log(`     Last seen: ${new Date(agent.lastDetection).toLocaleString()}`);
+            console.log('');
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to list agents';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+agentsCommand
+    .command('integrate <agentId>')
+    .description('Enable Phantom integration for an agent')
+    .option('--level <level>', 'Integration level: integrated, enhanced, full', 'enhanced')
+    .option('--json', 'Output as JSON')
+    .action(async (agentId, options) => {
+    try {
+        const { AgentRegistry } = await import('@phantom/core');
+        const registry = new AgentRegistry();
+        const validLevels = ['integrated', 'enhanced', 'full'];
+        if (!validLevels.includes(options.level)) {
+            throw new Error(`Invalid integration level. Choose from: ${validLevels.join(', ')}`);
+        }
+        const success = registry.enableIntegration(agentId, options.level);
+        if (!success) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        if (options.json) {
+            printJson({ status: 'ok', agentId, level: options.level });
+            return;
+        }
+        console.log('');
+        console.log(theme.success(`  Integration enabled for ${agentId}`));
+        console.log(`  Level: ${options.level}`);
+        console.log(theme.dim('  Run: phantom agents list to see updated status'));
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Integration failed';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+agentsCommand
+    .command('network')
+    .description('Show agent network topology and connections')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const { AgentRegistry } = await import('@phantom/core');
+        const registry = new AgentRegistry();
+        const topology = registry.getNetworkTopology();
+        if (options.json) {
+            printJson(topology);
+            return;
+        }
+        console.log('');
+        console.log(theme.title('  AGENT NETWORK TOPOLOGY'));
+        console.log('');
+        console.log(theme.secondary(`Agents: ${topology.agents.length}`));
+        console.log(theme.secondary(`Connections: ${topology.connections.length}`));
+        console.log(theme.secondary(`Clusters: ${topology.clusters.length}`));
+        console.log('');
+        if (topology.clusters.length > 0) {
+            console.log(theme.title('  CLUSTERS'));
+            for (const cluster of topology.clusters) {
+                console.log(`  ${theme.accent(cluster.name)}: ${cluster.agents.join(', ')}`);
+            }
+            console.log('');
+        }
+        if (topology.connections.length > 0) {
+            console.log(theme.title('  CONNECTIONS'));
+            for (const conn of topology.connections.slice(0, 10)) { // Show top 10
+                const strengthBar = '█'.repeat(Math.floor(conn.strength / 20)) + '░'.repeat(5 - Math.floor(conn.strength / 20));
+                console.log(`  ${conn.from} → ${conn.to} [${strengthBar}] ${conn.strength}%`);
+            }
+            if (topology.connections.length > 10) {
+                console.log(theme.dim(`  ... and ${topology.connections.length - 10} more connections`));
+            }
+        }
+        console.log('');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Network analysis failed';
+        if (options.json) {
+            printJson({ status: 'error', error: message });
+        }
+        else {
+            console.log('');
+            console.log(theme.error(`  ${message}`));
+            console.log('');
+        }
+        process.exitCode = 1;
+    }
+});
+agentsCommand
+    .description('Show Agent Matrix usage and capabilities')
+    .action(() => {
+    console.log('');
+    console.log(theme.title('  PHANTOM AGENT MATRIX'));
+    console.log(theme.secondary('  Connect and coordinate all your AI agents'));
+    console.log('');
+    console.log(`  ${theme.accent('phantom agents scan')}     # Detect installed AI agents`);
+    console.log(`  ${theme.accent('phantom agents list')}     # Show registered agents`);
+    console.log(`  ${theme.accent('phantom agents integrate <id>')} # Enable integration`);
+    console.log(`  ${theme.accent('phantom agents network')}   # View network topology`);
+    console.log('');
+    console.log(theme.dim('  Supported agents: Claude Code, Cursor, Codex, Gemini, ChatGPT, VS Code, Zed'));
+    console.log('');
+});
+program
+    .command('boot')
+    .description('Run onboarding boot sequence')
+    .action(async () => {
+    await runBootSequence();
+    await showFirstRunSetup();
+});
+program
+    .command('tools')
+    .description('Tool palette (real-mode gate)')
+    .action(() => {
+    failNotImplemented('tools');
+});
+function dirnameSafe(pathValue) {
+    const idx = Math.max(pathValue.lastIndexOf('/'), pathValue.lastIndexOf('\\'));
+    if (idx <= 0)
+        return process.cwd();
+    return pathValue.slice(0, idx);
+}
+const argv = [...process.argv];
+if (argv[2] === 'integrate' &&
+    typeof argv[3] === 'string' &&
+    !argv[3].startsWith('-') &&
+    !['scan', 'doctor', 'connect'].includes(argv[3])) {
+    argv.splice(3, 0, 'connect');
+}
+program.parse(argv);
+//# sourceMappingURL=index.js.map