@theihtisham/agent-shadow-brain 1.2.0 → 3.0.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// src/cli.ts — CLI entry point for Shadow Brain v1.2.0
+// src/cli.ts — CLI entry point for Shadow Brain v3.0.0
 import { Command } from 'commander';
 import chalk from 'chalk';
 import Conf from 'conf';
@@ -7,7 +7,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { Orchestrator } from './brain/orchestrator.js';
 import { detectRunningAgents, createAdapter } from './adapters/index.js';
-const VERSION = '1.2.0';
+const VERSION = '3.0.0';
 const config = new Conf({
     projectName: 'shadow-brain',
     defaults: {
@@ -882,11 +882,982 @@ const notifyCmd = new Command('notify')
         process.exit(1);
     }
 });
+// ─── MCP (Start MCP Server) ──────────────────────────────────────────────────
+const mcpCmd = new Command('mcp')
+    .description('Start Shadow Brain as an MCP (Model Context Protocol) server')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--port <port>', 'MCP server port', '7342')
+    .option('--host <host>', 'MCP server host', 'localhost')
+    .option('-p, --provider <provider>', 'LLM provider')
+    .option('-k, --api-key <key>', 'API key')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ ...opts, projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — MCP Server\n`));
+        console.log(chalk.dim('  Starting MCP server...'));
+        await orchestrator.startMCPServer({ port: parseInt(opts.port || '7342'), host: opts.host || 'localhost' });
+        console.log(chalk.green(`  ✓ MCP server running at http://${opts.host || 'localhost'}:${opts.port || '7342'}/mcp`));
+        console.log(chalk.dim('  Endpoints:'));
+        console.log(chalk.dim('    POST /mcp  — JSON-RPC 2.0 requests'));
+        console.log(chalk.dim('    GET  /sse   — Server-Sent Events stream'));
+        console.log(chalk.dim('\n  Press Ctrl+C to stop\n'));
+        process.on('SIGINT', async () => {
+            await orchestrator.stopMCPServer();
+            process.exit(0);
+        });
+        // Keep alive
+        await new Promise(() => { });
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── TEAM (Team Mode) ────────────────────────────────────────────────────────
+const teamCmd = new Command('team')
+    .description('Manage team mode — share insights and patterns across team')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--share <message>', 'Share an insight with the team')
+    .option('--list', 'List team insights')
+    .option('--stats', 'Show team statistics')
+    .option('--user <name>', 'Your team username')
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    orchestrator.enableTeamMode(opts.user || process.env.USER || 'anonymous');
+    try {
+        if (opts.share) {
+            const insight = {
+                type: 'context', priority: 'medium',
+                title: opts.share.slice(0, 100), content: opts.share,
+                files: [], timestamp: new Date(),
+            };
+            const result = await orchestrator.shareTeamInsight(insight);
+            console.log(chalk.green(`  ✓ Insight shared with team (ID: ${result?.id || 'unknown'})`));
+            return;
+        }
+        if (opts.stats) {
+            const stats = await orchestrator.getTeamStats();
+            if (!stats) {
+                console.log(chalk.dim('  No team data available.'));
+                return;
+            }
+            if (opts.json) {
+                console.log(JSON.stringify(stats, null, 2));
+                return;
+            }
+            console.log(chalk.magenta.bold('\n  SHADOW BRAIN Team Stats\n'));
+            console.log(chalk.dim(`  Members:        `) + chalk.cyan(String(stats.members)));
+            console.log(chalk.dim(`  Total Insights: `) + chalk.cyan(String(stats.totalInsights)));
+            console.log(chalk.dim(`  Total Patterns: `) + chalk.cyan(String(stats.totalPatterns)));
+            console.log();
+            return;
+        }
+        // Default: list insights
+        const insights = await orchestrator.getTeamInsights(20);
+        if (insights.length === 0) {
+            console.log(chalk.dim('  No team insights yet. Use --share to add one.'));
+            return;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Team Insights (${insights.length})\n`));
+        for (const ti of insights) {
+            const color = ti.insight.priority === 'critical' ? 'red' : ti.insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${ti.insight.priority}]} ${ti.insight.title}`);
+            console.log(chalk.dim(`    Shared by: ${ti.sharedBy} | Upvotes: ${ti.upvotes}`));
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── PROJECTS (Multi-Project Manager) ─────────────────────────────────────────
+const projectsCmd = new Command('projects')
+    .description('Manage multiple projects with Shadow Brain')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--add <dir>', 'Register a project directory')
+    .option('--remove <dir>', 'Unregister a project directory')
+    .option('--scan <parent-dir>', 'Scan directory for git repositories')
+    .option('--health', 'Show aggregated health across all projects')
+    .option('--list', 'List all registered projects')
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    const mgr = orchestrator.getMultiProjectManager();
+    try {
+        if (opts.add) {
+            const info = await mgr.addProject(path.resolve(opts.add));
+            console.log(chalk.green(`  ✓ Project registered: ${info.name} (${info.dir})`));
+            return;
+        }
+        if (opts.remove) {
+            await mgr.removeProject(path.resolve(opts.remove));
+            console.log(chalk.green(`  ✓ Project removed: ${opts.remove}`));
+            return;
+        }
+        if (opts.scan) {
+            console.log(chalk.cyan(`  Scanning ${opts.scan} for git repositories...`));
+            const repos = await mgr.scanDirectory(path.resolve(opts.scan));
+            if (repos.length === 0) {
+                console.log(chalk.dim('  No git repositories found.'));
+            }
+            else {
+                console.log(chalk.green(`  Found ${repos.length} project(s):`));
+                for (const r of repos) {
+                    console.log(chalk.dim(`    • ${r}`));
+                }
+            }
+            return;
+        }
+        if (opts.health) {
+            const health = await mgr.getAggregatedHealth();
+            if (opts.json) {
+                console.log(JSON.stringify(health, null, 2));
+                return;
+            }
+            console.log(chalk.magenta.bold('\n  SHADOW BRAIN Aggregated Health\n'));
+            console.log(chalk.dim(`  Projects:       `) + chalk.cyan(String(health.projects)));
+            console.log(chalk.dim(`  Average Health: `) + chalk.cyan(`${health.averageHealth}/100`));
+            console.log(chalk.dim(`  Best Project:   `) + chalk.green(health.bestProject));
+            console.log(chalk.dim(`  Worst Project:  `) + chalk.yellow(health.worstProject));
+            console.log(chalk.dim(`  Critical Issues:`) + chalk.red(String(health.criticalIssues)));
+            console.log();
+            return;
+        }
+        // Default: list projects
+        const projects = await mgr.listProjects();
+        if (projects.length === 0) {
+            console.log(chalk.dim('  No projects registered. Use --add or --scan to register projects.'));
+            return;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(projects, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Registered Projects (${projects.length})\n`));
+        for (const p of projects) {
+            const statusColor = p.status === 'running' ? 'green' : p.status === 'error' ? 'red' : 'yellow';
+            const health = p.lastHealth !== null ? `${p.lastHealth}/100` : 'N/A';
+            console.log(`  ${chalk[statusColor]('●')} ${chalk.bold(p.name)} ${chalk.dim(`(${p.dir})`)}`);
+            console.log(chalk.dim(`    Status: ${p.status} | Health: ${health} | Insights: ${p.insightCount}`));
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── SEMANTIC (Semantic Analysis) ─────────────────────────────────────────────
+const semanticCmd = new Command('semantic')
+    .description('Run semantic code analysis — symbols, unused exports, dead code')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Running semantic analysis...'));
+        const { symbols, unusedExports, deadCode } = await orchestrator.getSemanticInsights();
+        const totalSymbols = Array.from(symbols.values()).reduce((sum, s) => sum + s.length, 0);
+        if (opts.json) {
+            const serializable = {
+                totalSymbols,
+                filesAnalyzed: symbols.size,
+                unusedExports: unusedExports.map(s => ({ name: s.name, type: s.type, file: s.file, line: s.line })),
+                deadCode: deadCode.map(s => ({ name: s.name, type: s.type, file: s.file, line: s.line })),
+            };
+            console.log(JSON.stringify(serializable, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Semantic Analysis\n`));
+        console.log(chalk.dim(`  Files analyzed: `) + chalk.cyan(String(symbols.size)));
+        console.log(chalk.dim(`  Total symbols:  `) + chalk.cyan(String(totalSymbols)));
+        console.log(chalk.dim(`  Unused exports: `) + chalk.yellow(String(unusedExports.length)));
+        console.log(chalk.dim(`  Dead code:      `) + chalk.red(String(deadCode.length)));
+        if (unusedExports.length > 0) {
+            console.log(chalk.yellow('\n  Unused Exports:'));
+            for (const s of unusedExports.slice(0, 20)) {
+                console.log(chalk.dim(`    • ${s.name} (${s.type}) — ${s.file}:${s.line}`));
+            }
+        }
+        if (deadCode.length > 0) {
+            console.log(chalk.red('\n  Dead Code:'));
+            for (const s of deadCode.slice(0, 20)) {
+                console.log(chalk.dim(`    • ${s.name} (${s.type}) — ${s.file}:${s.line}`));
+            }
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── DEPS (Dependency Graph) ─────────────────────────────────────────────────
+const depsCmd = new Command('deps')
+    .description('Analyze dependency graph — cycles, orphans, hubs')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Building dependency graph...'));
+        const graph = await orchestrator.getDependencyGraph();
+        const details = orchestrator.getDependencyDetails(graph);
+        if (opts.json) {
+            console.log(JSON.stringify({ ...graph, ...details }, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Dependency Graph\n`));
+        console.log(chalk.dim(`  Files (nodes):  `) + chalk.cyan(String(graph.nodes.length)));
+        console.log(chalk.dim(`  Imports (edges):`) + chalk.cyan(String(graph.edges.length)));
+        console.log(chalk.dim(`  Orphans:        `) + chalk.yellow(String(details.orphans.length)));
+        console.log(chalk.dim(`  Cycles:         `) + chalk.red(String(details.cycles.length)));
+        console.log(chalk.dim(`  Hubs:           `) + chalk.yellow(String(details.hubs.length)));
+        if (details.cycles.length > 0) {
+            console.log(chalk.red('\n  Circular Dependencies:'));
+            for (const cycle of details.cycles.slice(0, 10)) {
+                console.log(chalk.red(`    ↻ ${cycle.join(' → ')}`));
+            }
+        }
+        if (details.hubs.length > 0) {
+            console.log(chalk.yellow('\n  Dependency Hubs:'));
+            for (const hub of details.hubs.slice(0, 10)) {
+                console.log(chalk.dim(`    • ${hub.file} — ${hub.dependents} dependents (${hub.risk} risk)`));
+            }
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── DUPES (Duplicate Detection) ─────────────────────────────────────────────
+const dupesCmd = new Command('dupes')
+    .description('Detect duplicate and near-duplicate code blocks')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--threshold <n>', 'Minimum similarity (0-1)', '0.8')
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        const threshold = parseFloat(opts.threshold || '0.8');
+        console.log(chalk.cyan(`  Detecting duplicate code (threshold: ${threshold})...`));
+        const groups = await orchestrator.detectDuplicates(threshold);
+        if (opts.json) {
+            console.log(JSON.stringify(groups, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Duplicate Detection\n`));
+        if (groups.length === 0) {
+            console.log(chalk.green('  No significant duplicates found!'));
+            return;
+        }
+        console.log(chalk.yellow(`  Found ${groups.length} duplicate group(s):\n`));
+        for (let i = 0; i < groups.length; i++) {
+            const g = groups[i];
+            console.log(chalk.bold(`  Group ${i + 1} (${(g.similarity * 100).toFixed(0)}% similar):`));
+            for (const block of g.blocks) {
+                console.log(chalk.dim(`    • ${block.file}:${block.startLine}-${block.endLine} (${block.type})`));
+            }
+            console.log(chalk.cyan(`    Suggestion: ${g.suggestedRefactor}`));
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── PERF (Performance Profiling) ────────────────────────────────────────────
+const perfCmd = new Command('perf')
+    .description('Profile code for performance anti-patterns')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Profiling for performance issues...'));
+        const insights = await orchestrator.profilePerformance();
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Performance Profiler (${insights.length} findings)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  No performance issues detected!'));
+            return;
+        }
+        for (const pi of insights) {
+            const color = pi.severity === 'critical' ? 'red' : pi.severity === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${pi.severity.toUpperCase()}]} ${pi.description}`);
+            console.log(chalk.dim(`    Category: ${pi.category} | Impact: ${pi.estimatedImpact}`));
+            console.log(chalk.cyan(`    Fix: ${pi.suggestion}`));
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── CONTEXT (Context Gaps) ──────────────────────────────────────────────────
+const contextCmd = new Command('context')
+    .description('Analyze project context completeness and suggest improvements')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Analyzing project context...'));
+        const [gaps, knowledge] = await Promise.all([
+            orchestrator.getContextGaps(),
+            orchestrator.buildKnowledge(),
+        ]);
+        if (opts.json) {
+            console.log(JSON.stringify({ knowledge, gaps }, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Context Analysis\n`));
+        console.log(chalk.dim('  Project: ') + chalk.cyan(knowledge.name));
+        console.log(chalk.dim('  Architecture: ') + chalk.cyan(knowledge.architecture || 'Not documented'));
+        if (knowledge.conventions.length > 0) {
+            console.log(chalk.dim('  Conventions: ') + chalk.cyan(knowledge.conventions.join(', ')));
+        }
+        if (gaps.length > 0) {
+            console.log(chalk.yellow(`\n  Context Gaps (${gaps.length}):`));
+            for (const gap of gaps) {
+                const color = gap.priority === 'critical' ? 'red' : gap.priority === 'high' ? 'yellow' : 'blue';
+                console.log(chalk `  {${color}.bold [${gap.priority}]} ${gap.title}`);
+                console.log(chalk.dim(`    ${gap.content}`));
+            }
+        }
+        else {
+            console.log(chalk.green('\n  No context gaps found!'));
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── LEARN (Learning Engine) ─────────────────────────────────────────────────
+const learnCmd = new Command('learn')
+    .description('Run the learning engine to extract patterns and lessons from the codebase')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Running learning engine...'));
+        await orchestrator.runLearningCycle();
+        const lessons = await orchestrator.getLearnedLessons();
+        if (opts.json) {
+            console.log(JSON.stringify(lessons, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Learning Engine (${lessons.length} lessons)\n`));
+        if (lessons.length === 0) {
+            console.log(chalk.dim('  No lessons learned yet. Run analysis first.'));
+            return;
+        }
+        for (const lesson of lessons) {
+            console.log(chalk.bold(`  [${lesson.category}] ${lesson.pattern}`));
+            console.log(chalk.dim(`    Lesson: ${lesson.lesson}`));
+            console.log(chalk.dim(`    Confidence: ${(lesson.confidence * 100).toFixed(0)}%`));
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── MESH (v2.1.0 Quantum Neural Mesh) ──────────────────────────────────────
+const meshCmd = new Command('mesh')
+    .description('Quantum Neural Mesh — cross-session shared intelligence');
+meshCmd.command('status')
+    .description('Show mesh status and connected nodes')
+    .action(async () => {
+    try {
+        const { NeuralMesh } = await import('./brain/neural-mesh.js');
+        const mesh = new NeuralMesh(process.cwd());
+        const state = mesh.getMeshState();
+        console.log(chalk.magenta.bold('\n  QUANTUM NEURAL MESH Status\n'));
+        console.log(chalk.bold('  Quantum State:'), state.quantumState === 'coherent'
+            ? chalk.green(state.quantumState) : state.quantumState === 'decoherent'
+            ? chalk.yellow(state.quantumState) : chalk.red(state.quantumState));
+        console.log(chalk.bold('  Active Nodes:'), state.nodes.filter(n => n.status === 'active').length);
+        console.log(chalk.bold('  Total Nodes:'), state.nodes.length);
+        console.log(chalk.bold('  Insights Exchanged:'), state.totalInsightsExchanged);
+        console.log(chalk.bold('  Knowledge Entries:'), state.knowledge.length);
+        console.log(chalk.bold('  Average Entropy:'), state.averageEntropy.toFixed(3));
+        console.log(chalk.bold('  Mesh Uptime:'), Math.round(state.meshUptime / 1000) + 's');
+        if (state.nodes.length > 0) {
+            console.log(chalk.cyan('\n  Connected Nodes:'));
+            for (const node of state.nodes) {
+                const statusIcon = node.status === 'active' ? chalk.green('●') : node.status === 'idle' ? chalk.yellow('◐') : chalk.red('○');
+                console.log(`  ${statusIcon} ${chalk.bold(node.projectName)} (${node.personality}) — PID ${node.pid}`);
+                console.log(chalk.dim(`    Health: ${node.healthScore ?? 'N/A'} | Insights: ${node.insightsGenerated} | Task: ${node.currentTask || 'idle'}`));
+            }
+        }
+        if (state.knowledge.length > 0) {
+            console.log(chalk.cyan('\n  Top Knowledge:'));
+            for (const k of state.knowledge.slice(0, 10)) {
+                const conf = (k.confidence * 100).toFixed(0);
+                console.log(`  ${chalk.bold(`[${k.category}]`)} ${k.content.slice(0, 80)}... (confidence: ${conf}%, freq: ${k.frequency})`);
+            }
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+meshCmd.command('insights')
+    .description('Get cross-session insights from other Shadow Brain instances')
+    .option('-n, --limit <number>', 'Max insights to show', '20')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    try {
+        const { NeuralMesh } = await import('./brain/neural-mesh.js');
+        const mesh = new NeuralMesh(process.cwd());
+        const insights = mesh.getCrossSessionInsights(parseInt(opts.limit));
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  Cross-Session Insights (${insights.length})\n`));
+        if (insights.length === 0) {
+            console.log(chalk.dim('  No cross-session insights found. Start multiple Shadow Brain instances to share knowledge.'));
+            return;
+        }
+        for (const csi of insights) {
+            const prioColor = csi.insight.priority === 'critical' ? 'red' : csi.insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${prioColor}.bold [${csi.insight.priority}]} ${csi.insight.title}`);
+            console.log(chalk.dim(`    From: ${csi.sourceProject} | Relevance: ${(csi.relevanceScore * 100).toFixed(0)}%`));
+            console.log(chalk.dim(`    ${csi.insight.content.slice(0, 120)}`));
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+meshCmd.command('knowledge')
+    .description('View shared knowledge base across all mesh nodes')
+    .option('-n, --limit <number>', 'Max entries to show', '20')
+    .option('--category <category>', 'Filter by category')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    try {
+        const { NeuralMesh } = await import('./brain/neural-mesh.js');
+        const mesh = new NeuralMesh(process.cwd());
+        let knowledge = mesh.getSharedKnowledge(parseInt(opts.limit));
+        if (opts.category) {
+            knowledge = knowledge.filter(k => k.category === opts.category);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(knowledge, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  Shared Knowledge Base (${knowledge.length} entries)\n`));
+        if (knowledge.length === 0) {
+            console.log(chalk.dim('  No shared knowledge found yet.'));
+            return;
+        }
+        for (const k of knowledge) {
+            const conf = (k.confidence * 100).toFixed(0);
+            console.log(chalk `  {bold [${k.category}]} ${k.content.slice(0, 100)}`);
+            console.log(chalk.dim(`    Confidence: ${conf}% | Frequency: ${k.frequency} | Source: ${k.sourceProject}`));
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+meshCmd.command('nodes')
+    .description('List all connected mesh nodes')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    try {
+        const { NeuralMesh } = await import('./brain/neural-mesh.js');
+        const mesh = new NeuralMesh(process.cwd());
+        const nodes = mesh.getConnectedNodes();
+        if (opts.json) {
+            console.log(JSON.stringify(nodes, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  Mesh Nodes (${nodes.length})\n`));
+        if (nodes.length === 0) {
+            console.log(chalk.dim('  No nodes connected.'));
+            return;
+        }
+        for (const node of nodes) {
+            const statusIcon = node.status === 'active' ? chalk.green('●') : node.status === 'idle' ? chalk.yellow('◐') : chalk.red('○');
+            console.log(`  ${statusIcon} ${chalk.bold(node.projectName)}`);
+            console.log(chalk.dim(`    Node: ${node.id.slice(0, 12)}... | PID: ${node.pid} | Personality: ${node.personality}`));
+            console.log(chalk.dim(`    Health: ${node.healthScore ?? 'N/A'} | Insights: ${node.insightsGenerated} | Task: ${node.currentTask || 'idle'}`));
+            console.log(chalk.dim(`    Started: ${new Date(node.startedAt).toLocaleString()} | Last HB: ${new Date(node.lastHeartbeat).toLocaleString()}`));
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+meshCmd.command('aggregate')
+    .description('Get aggregated insights across all mesh projects')
+    .action(async () => {
+    try {
+        const { NeuralMesh } = await import('./brain/neural-mesh.js');
+        const mesh = new NeuralMesh(process.cwd());
+        const agg = mesh.getAggregatedInsights();
+        if (!agg) {
+            console.log(chalk.dim('\n  No mesh data available.\n'));
+            return;
+        }
+        console.log(chalk.magenta.bold('\n  Aggregated Mesh Intelligence\n'));
+        console.log(chalk.bold('  Total Projects:'), agg.totalProjects);
+        console.log(chalk.bold('  Total Insights:'), agg.totalInsights);
+        if (agg.topCategories.length > 0) {
+            console.log(chalk.cyan('\n  Top Categories:'));
+            for (const cat of agg.topCategories.slice(0, 10)) {
+                console.log(`    ${chalk.bold(cat.category)}: ${cat.count}`);
+            }
+        }
+        if (agg.crossProjectPatterns.length > 0) {
+            console.log(chalk.cyan('\n  Cross-Project Patterns:'));
+            for (const p of agg.crossProjectPatterns.slice(0, 10)) {
+                console.log(`    ${chalk.bold(p.pattern)} — seen in ${p.projects} project(s)`);
+            }
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── AST (Complexity Analysis) ────────────────────────────────────────────────
+const astCmd = new Command('ast')
+    .description('Run AST-level complexity analysis — cyclomatic complexity, nesting, function size')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .option('--max-files <n>', 'Max files to analyze', '200')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Running AST complexity analysis...'));
+        const insights = await orchestrator.runASTAnalysis(parseInt(opts.maxFiles));
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN AST Analysis (${insights.length} findings)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  No complexity issues detected!'));
+            return;
+        }
+        for (const insight of insights) {
+            const color = insight.priority === 'critical' ? 'red' : insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+            console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+            console.log(`    ${insight.content.slice(0, 200)}${insight.content.length > 200 ? '...' : ''}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── A11Y (Accessibility Audit) ──────────────────────────────────────────────
+const a11yCmd = new Command('a11y')
+    .description('Run WCAG accessibility audit on frontend code')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .option('--max-files <n>', 'Max files to analyze', '200')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Running accessibility audit...'));
+        const insights = await orchestrator.runA11yCheck(parseInt(opts.maxFiles));
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Accessibility Audit (${insights.length} issues)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  No accessibility issues found!'));
+            return;
+        }
+        for (const insight of insights) {
+            const color = insight.priority === 'critical' ? 'red' : insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+            console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+            console.log(`    ${insight.content.slice(0, 200)}${insight.content.length > 200 ? '...' : ''}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── I18N (Internationalization) ──────────────────────────────────────────────
+const i18nCmd = new Command('i18n')
+    .description('Check internationalization readiness — hardcoded strings, locale support')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .option('--max-files <n>', 'Max files to analyze', '200')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Running i18n readiness check...'));
+        const insights = await orchestrator.runI18nAnalysis(parseInt(opts.maxFiles));
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN i18n Analysis (${insights.length} findings)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  No i18n issues found!'));
+            return;
+        }
+        for (const insight of insights) {
+            const color = insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+            console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+            console.log(`    ${insight.content.slice(0, 200)}${insight.content.length > 200 ? '...' : ''}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── DEAD-CODE ────────────────────────────────────────────────────────────────
+const deadCodeCmd = new Command('dead-code')
+    .description('Detect dead code — unreachable code, unused exports, unused variables')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .option('--max-files <n>', 'Max files to analyze', '200')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Scanning for dead code...'));
+        const insights = await orchestrator.runDeadCodeAnalysis(parseInt(opts.maxFiles));
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Dead Code Detection (${insights.length} findings)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  No dead code detected!'));
+            return;
+        }
+        for (const insight of insights) {
+            const color = insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+            console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+            console.log(`    ${insight.content.slice(0, 200)}${insight.content.length > 200 ? '...' : ''}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── MUTATION (Mutation Testing Advisor) ──────────────────────────────────────
+const mutationCmd = new Command('mutation')
+    .description('Suggest mutation testing cases — tests that would catch real bugs')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .option('--max-files <n>', 'Max files to analyze', '200')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Running mutation testing advisor...'));
+        const insights = await orchestrator.runMutationAnalysis(parseInt(opts.maxFiles));
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Mutation Advisor (${insights.length} suggestions)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  No mutation suggestions — code looks well-tested or analysis found nothing!'));
+            return;
+        }
+        for (const insight of insights) {
+            const color = insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+            console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+            console.log(`    ${insight.content.slice(0, 200)}${insight.content.length > 200 ? '...' : ''}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── CODE-AGE ─────────────────────────────────────────────────────────────────
+const codeAgeCmd = new Command('code-age')
+    .description('Analyze code freshness — stale files, ownership, change frequency')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Analyzing code age and freshness...'));
+        const insights = await orchestrator.runCodeAgeAnalysis();
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Code Age Analysis (${insights.length} findings)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  Code looks fresh and well-maintained!'));
+            return;
+        }
+        for (const insight of insights) {
+            const color = insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+            console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+            console.log(`    ${insight.content.slice(0, 200)}${insight.content.length > 200 ? '...' : ''}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── API (API Contract Analysis) ──────────────────────────────────────────────
+const apiCmd = new Command('api')
+    .description('Analyze API contracts — endpoint discovery, security, consistency')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .option('--max-files <n>', 'Max files to analyze', '200')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Running API contract analysis...'));
+        const insights = await orchestrator.runAPIContractAnalysis(parseInt(opts.maxFiles));
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN API Contract Analysis (${insights.length} findings)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  No API contract issues detected!'));
+            return;
+        }
+        for (const insight of insights) {
+            const color = insight.priority === 'critical' ? 'red' : insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+            console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+            console.log(`    ${insight.content.slice(0, 200)}${insight.content.length > 200 ? '...' : ''}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── ENV (Environment Variable Analysis) ──────────────────────────────────────
+const envCmd = new Command('env')
+    .description('Analyze environment variables — secrets, validation, naming conventions')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .option('--max-files <n>', 'Max files to analyze', '200')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Analyzing environment variables...'));
+        const insights = await orchestrator.runEnvAnalysis(parseInt(opts.maxFiles));
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Environment Analysis (${insights.length} findings)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  No environment variable issues detected!'));
+            return;
+        }
+        for (const insight of insights) {
+            const color = insight.priority === 'critical' ? 'red' : insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+            console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+            console.log(`    ${insight.content.slice(0, 200)}${insight.content.length > 200 ? '...' : ''}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── LICENSE (License Compliance) ─────────────────────────────────────────────
+const licenseCmd = new Command('license')
+    .description('Audit dependency licenses — restricted, copyleft, unknown licenses')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Running license compliance audit...'));
+        const insights = await orchestrator.runLicenseCompliance();
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN License Compliance (${insights.length} findings)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  All dependency licenses are compliant!'));
+            return;
+        }
+        for (const insight of insights) {
+            const color = insight.priority === 'critical' ? 'red' : insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+            console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+            console.log(`    ${insight.content.slice(0, 200)}${insight.content.length > 200 ? '...' : ''}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── CONFIG-DRIFT ─────────────────────────────────────────────────────────────
+const configDriftCmd = new Command('config-drift')
+    .description('Detect configuration drift — missing configs, inconsistent settings')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.cyan('  Detecting configuration drift...'));
+        const insights = await orchestrator.runConfigDriftDetection();
+        if (opts.json) {
+            console.log(JSON.stringify(insights, null, 2));
+            return;
+        }
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN Config Drift Detection (${insights.length} findings)\n`));
+        if (insights.length === 0) {
+            console.log(chalk.green('  No configuration drift detected!'));
+            return;
+        }
+        for (const insight of insights) {
+            const color = insight.priority === 'high' ? 'yellow' : 'blue';
+            console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+            console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+            console.log(`    ${insight.content.slice(0, 200)}${insight.content.length > 200 ? '...' : ''}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// ─── HYPER (Full Hyper-Analysis) ──────────────────────────────────────────────
+const hyperCmd = new Command('hyper')
+    .description('Run ALL v3.0.0 hyper-intelligence analyses at once')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--json', 'Output as JSON')
+    .option('--max-files <n>', 'Max files per analysis', '200')
+    .action(async (projectDir, opts) => {
+    const brainConfig = mergeConfig({ projectDir, watchMode: false });
+    const orchestrator = new Orchestrator(brainConfig);
+    try {
+        console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Hyper-Intelligence Full Scan\n`));
+        console.log(chalk.cyan('  Running all 10 hyper-intelligence modules in parallel...'));
+        console.log(chalk.dim('  This may take a moment for large projects.\n'));
+        const results = await orchestrator.runFullHyperAnalysis({
+            maxFiles: parseInt(opts.maxFiles),
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(results, null, 2));
+            return;
+        }
+        const modules = [
+            { name: 'ast', label: 'AST Complexity', insights: results.ast },
+            { name: 'a11y', label: 'Accessibility (WCAG)', insights: results.a11y },
+            { name: 'i18n', label: 'Internationalization', insights: results.i18n },
+            { name: 'deadCode', label: 'Dead Code', insights: results.deadCode },
+            { name: 'mutation', label: 'Mutation Testing', insights: results.mutation },
+            { name: 'codeAge', label: 'Code Age', insights: results.codeAge },
+            { name: 'apiContract', label: 'API Contracts', insights: results.apiContract },
+            { name: 'env', label: 'Environment Variables', insights: results.env },
+            { name: 'license', label: 'License Compliance', insights: results.license },
+            { name: 'configDrift', label: 'Config Drift', insights: results.configDrift },
+        ];
+        for (const mod of modules) {
+            const count = mod.insights.length;
+            const color = count === 0 ? 'green' : count < 5 ? 'yellow' : 'red';
+            const icon = count === 0 ? '✓' : '⚠';
+            console.log(chalk `  {${color}.bold ${icon}} ${chalk.bold(mod.label)}: ${count} finding(s)`);
+        }
+        console.log(chalk.bold(`\n  Total findings: ${results.total}\n`));
+        // Show critical/high priority details
+        const allCritical = modules.flatMap(m => m.insights.filter(i => i.priority === 'critical' || i.priority === 'high'));
+        if (allCritical.length > 0) {
+            console.log(chalk.red.bold(`  Critical/High Priority (${allCritical.length}):\n`));
+            for (const insight of allCritical.slice(0, 20)) {
+                const color = insight.priority === 'critical' ? 'red' : 'yellow';
+                console.log(chalk `  {${color}.bold [${insight.priority.toUpperCase()}]} ${insight.title}`);
+                console.log(chalk.dim(`    Files: ${insight.files?.join(', ') || 'none'}`));
+                console.log();
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
 // ─── MAIN ─────────────────────────────────────────────────────────────────────
 const program = new Command();
 program
     .name('shadow-brain')
-    .description('Shadow Brain — AI agent watcher and intelligence injector')
+    .description('Shadow Brain v3.0.0 — Hyper-Intelligence Layer for AI Coding Agents with Quantum Neural Mesh')
     .version(VERSION);
 program.addCommand(startCmd);
 program.addCommand(reviewCmd);
@@ -907,5 +1878,29 @@ program.addCommand(prCmd);
 program.addCommand(commitMsgCmd);
 program.addCommand(rulesCmd);
 program.addCommand(notifyCmd);
+// v2.0.0 commands
+program.addCommand(mcpCmd);
+program.addCommand(teamCmd);
+program.addCommand(projectsCmd);
+program.addCommand(semanticCmd);
+program.addCommand(depsCmd);
+program.addCommand(dupesCmd);
+program.addCommand(perfCmd);
+program.addCommand(contextCmd);
+program.addCommand(learnCmd);
+// v2.1.0 commands
+program.addCommand(meshCmd);
+// v3.0.0 hyper-intelligence commands
+program.addCommand(astCmd);
+program.addCommand(a11yCmd);
+program.addCommand(i18nCmd);
+program.addCommand(deadCodeCmd);
+program.addCommand(mutationCmd);
+program.addCommand(codeAgeCmd);
+program.addCommand(apiCmd);
+program.addCommand(envCmd);
+program.addCommand(licenseCmd);
+program.addCommand(configDriftCmd);
+program.addCommand(hyperCmd);
 program.parse();
 //# sourceMappingURL=cli.js.map