@theihtisham/agent-shadow-brain 4.0.3 → 5.0.1

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// src/cli.ts — CLI entry point for Shadow Brain v4.0.0
+// src/cli.ts — CLI entry point for Shadow Brain v5.0.1
 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 = '4.0.0';
+const VERSION = '5.0.1';
 const config = new Conf({
     projectName: 'shadow-brain',
     defaults: {
@@ -2179,11 +2179,256 @@ const v4Cmd = new Command('v4')
         process.exit(1);
     }
 });
+// ─── v5.0.0 INFINITE INTELLIGENCE COMMANDS ──────────────────────────────────
+const memoryCmd = new Command('memory')
+    .description('v5.0.0 — Hierarchical infinite memory (raw → summary → pattern → principle)')
+    .addCommand(new Command('stats')
+    .description('Show hierarchical memory statistics')
+    .action(async () => {
+    const { HierarchicalMemory } = await import('./brain/hierarchical-memory.js');
+    const hm = new HierarchicalMemory();
+    const stats = hm.stats();
+    console.log(chalk.magenta.bold(`\n  HIERARCHICAL MEMORY STATS\n`));
+    console.log(chalk `  {cyan Raw entries:}      ${stats.rawCount}`);
+    console.log(chalk `  {cyan Summary entries:}  ${stats.summaryCount}`);
+    console.log(chalk `  {cyan Pattern entries:}  ${stats.patternCount}`);
+    console.log(chalk `  {cyan Principle entries:} ${stats.principleCount}`);
+    console.log(chalk `  {cyan Total entries:}    ${stats.totalEntries}`);
+    console.log(chalk `  {cyan Total size:}       ${stats.totalSizeMB.toFixed(3)} MB`);
+    console.log(chalk `  {cyan Compression ratio:} ${(stats.compressionRatio * 100).toFixed(1)}%`);
+    console.log(chalk `  {cyan Retention:}        INFINITE`);
+    console.log(chalk `  {cyan Drill-down depth:} ${stats.drillDownDepth} tiers\n`);
+}))
+    .addCommand(new Command('search')
+    .description('Search hierarchical memory')
+    .argument('<query>', 'Search query')
+    .action(async (query) => {
+    const { HierarchicalMemory } = await import('./brain/hierarchical-memory.js');
+    const hm = new HierarchicalMemory();
+    const results = hm.search(query, 10);
+    if (results.length === 0) {
+        console.log(chalk.yellow('  No results found.'));
+        return;
+    }
+    console.log(chalk.magenta.bold(`\n  MEMORY SEARCH: "${query}"\n`));
+    for (const entry of results) {
+        const tierColors = { raw: 'dim', summary: 'cyan', pattern: 'magenta', principle: 'green' };
+        const color = tierColors[entry.tier] || 'white';
+        console.log(chalk `  {${color} [${entry.tier.toUpperCase()}]} ${entry.content.slice(0, 120).replace(/\n/g, ' ')}...`);
+        console.log(chalk `  {dim Category: ${entry.category} | Confidence: ${(entry.confidence * 100).toFixed(0)}% | Importance: ${entry.importance.toFixed(2)}}`);
+    }
+    console.log();
+}))
+    .addCommand(new Command('drilldown')
+    .description('Drill down from a higher-tier entry to raw sources')
+    .argument('<id>', 'Entry ID (first 8 chars)')
+    .action(async (id) => {
+    const { HierarchicalMemory } = await import('./brain/hierarchical-memory.js');
+    const hm = new HierarchicalMemory();
+    const allEntries = [...hm.getByTier('principle'), ...hm.getByTier('pattern'), ...hm.getByTier('summary')];
+    const match = allEntries.find(e => e.id.startsWith(id));
+    if (!match) {
+        console.log(chalk.yellow('  Entry not found.'));
+        return;
+    }
+    const levels = hm.drillDown(match.id);
+    console.log(chalk.magenta.bold(`\n  DRILL-DOWN from [${match.tier}] ${match.content.slice(0, 80)}...\n`));
+    for (let i = 0; i < levels.length; i++) {
+        const tier = levels[i][0]?.tier ?? '?';
+        console.log(chalk `  {cyan Level ${i} [${tier}]}: ${levels[i].length} entries`);
+        for (const entry of levels[i].slice(0, 3)) {
+            console.log(chalk `    {dim ${entry.content.slice(0, 100).replace(/\n/g, ' ')}}`);
+        }
+    }
+    console.log();
+}));
+const recallCmd = new Command('recall')
+    .description('v5.0.0 — Context-triggered associative recall')
+    .addCommand(new Command('activate')
+    .description('Activate memories for a specific file/context')
+    .argument('<file>', 'File path or context description')
+    .option('-c, --category <cat>', 'Category filter')
+    .option('-k, --keywords <kw>', 'Comma-separated keywords')
+    .action(async (file, opts) => {
+    const { HierarchicalMemory } = await import('./brain/hierarchical-memory.js');
+    const { ContextRecall } = await import('./brain/context-recall.js');
+    const hm = new HierarchicalMemory();
+    const cr = new ContextRecall(hm);
+    const now = new Date();
+    const results = cr.recall({
+        currentFile: file,
+        currentCategory: opts.category || 'general',
+        recentEdits: [],
+        projectType: 'auto',
+        keywords: opts.keywords?.split(',') || [],
+        timeOfDay: now.getHours(),
+        dayOfWeek: now.getDay(),
+    }, 15);
+    if (results.length === 0) {
+        console.log(chalk.yellow('  No memories activated for this context.'));
+        return;
+    }
+    console.log(chalk.magenta.bold(`\n  CONTEXT RECALL: ${file}\n`));
+    console.log(chalk `  {cyan Activated ${results.length} memories}\n`);
+    for (const r of results) {
+        const pct = (r.relevanceScore * 100).toFixed(0);
+        const triggers = r.activatedTriggers.join(', ');
+        console.log(chalk `  {green ${pct}%} [{dim ${r.entry.tier}}] ${r.entry.content.slice(0, 100).replace(/\n/g, ' ')}`);
+        console.log(chalk `    {dim Triggers: ${triggers}}`);
+    }
+    console.log();
+}))
+    .addCommand(new Command('summary')
+    .description('Get a summary of what the brain knows about current context')
+    .argument('<file>', 'File path')
+    .action(async (file) => {
+    const { HierarchicalMemory } = await import('./brain/hierarchical-memory.js');
+    const { ContextRecall } = await import('./brain/context-recall.js');
+    const hm = new HierarchicalMemory();
+    const cr = new ContextRecall(hm);
+    const summary = cr.getContextSummary({ currentFile: file });
+    console.log(chalk.magenta.bold(`\n  CONTEXT SUMMARY\n`));
+    console.log(summary);
+    console.log();
+}));
+const consensusCmd = new Command('consensus')
+    .description('v5.0.0 — Multi-agent consensus protocol')
+    .addCommand(new Command('stats')
+    .description('Show consensus engine statistics')
+    .action(async () => {
+    const { ConsensusEngine } = await import('./brain/consensus-engine.js');
+    const ce = new ConsensusEngine();
+    const stats = ce.getStats();
+    console.log(chalk.magenta.bold(`\n  CONSENSUS ENGINE STATS\n`));
+    console.log(chalk `  {cyan Total proposals:}   ${stats.totalProposals}`);
+    console.log(chalk `  {cyan Accepted:}          ${stats.acceptedCount}`);
+    console.log(chalk `  {cyan Rejected:}          ${stats.rejectedCount}`);
+    console.log(chalk `  {cyan Conflicts:}         ${stats.conflictCount}`);
+    console.log(chalk `  {cyan Pending:}           ${stats.pendingCount}`);
+    console.log(chalk `  {cyan Avg agreement:}     ${(stats.averageAgreement * 100).toFixed(1)}%`);
+    console.log(chalk `  {cyan Known agents:}      ${stats.agentCount}`);
+    if (stats.topTrustedAgents.length > 0) {
+        console.log(chalk `\n  {bold Top Trusted Agents:}`);
+        for (const agent of stats.topTrustedAgents) {
+            console.log(chalk `    {green ${agent.agent}}: trust=${(agent.score * 100).toFixed(0)}%, accuracy=${(agent.accuracy * 100).toFixed(0)}%`);
+        }
+    }
+    console.log();
+}))
+    .addCommand(new Command('trust')
+    .description('Show trust scores for all agents')
+    .action(async () => {
+    const { ConsensusEngine } = await import('./brain/consensus-engine.js');
+    const ce = new ConsensusEngine();
+    const scores = ce.getTrustScores();
+    if (scores.length === 0) {
+        console.log(chalk.yellow('  No trust scores recorded yet.'));
+        return;
+    }
+    console.log(chalk.magenta.bold(`\n  AGENT TRUST SCORES\n`));
+    for (const t of scores) {
+        const bar = '█'.repeat(Math.round(t.score * 20));
+        console.log(chalk `  {cyan ${t.agent.slice(0, 20)}}: ${(t.score * 100).toFixed(0)}% ${bar}`);
+    }
+    console.log();
+}));
+const collectiveCmd = new Command('collective')
+    .description('v5.0.0 — Cross-project collective learning')
+    .addCommand(new Command('stats')
+    .description('Show collective learning statistics')
+    .action(async () => {
+    const { CollectiveLearning } = await import('./brain/collective-learning.js');
+    const cl = new CollectiveLearning(process.cwd());
+    const stats = cl.getStats();
+    console.log(chalk.magenta.bold(`\n  COLLECTIVE LEARNING STATS\n`));
+    console.log(chalk `  {cyan Total rules:}       ${stats.totalRules}`);
+    console.log(chalk `  {cyan Verified rules:}    ${stats.verifiedRules}`);
+    console.log(chalk `  {cyan Avg accuracy:}      ${(stats.averageAccuracy * 100).toFixed(1)}%`);
+    console.log(chalk `  {cyan Consensus rate:}    ${(stats.consensusRate * 100).toFixed(1)}%`);
+    console.log(chalk `  {cyan Network size:}      ${stats.networkSize} projects`);
+    console.log(chalk `  {cyan Recent adoptions:}  ${stats.recentAdoptions}`);
+    if (stats.topCategories.length > 0) {
+        console.log(chalk `\n  {bold Top Categories:}`);
+        for (const cat of stats.topCategories.slice(0, 5)) {
+            console.log(chalk `    ${cat.category}: ${cat.count} rules`);
+        }
+    }
+    console.log();
+}))
+    .addCommand(new Command('rules')
+    .description('List verified collective rules')
+    .option('-c, --category <cat>', 'Filter by category')
+    .action(async (opts) => {
+    const { CollectiveLearning } = await import('./brain/collective-learning.js');
+    const cl = new CollectiveLearning(process.cwd());
+    const rules = cl.getVerifiedRules();
+    if (rules.length === 0) {
+        console.log(chalk.yellow('  No verified collective rules yet.'));
+        return;
+    }
+    console.log(chalk.magenta.bold(`\n  VERIFIED COLLECTIVE RULES (${rules.length})\n`));
+    for (const rule of rules.slice(0, 20)) {
+        const acc = (rule.accuracy * 100).toFixed(0);
+        const viral = (rule.viralScore * 100).toFixed(0);
+        console.log(chalk `  {green [${rule.category}]} ${rule.content.slice(0, 100)}`);
+        console.log(chalk `    {dim Accuracy: ${acc}% | Viral: ${viral}% | Verified by: ${rule.verifiedBy.length} projects}`);
+    }
+    console.log();
+}));
+const v5Cmd = new Command('v5')
+    .description('Run ALL v5.0.0 infinite intelligence analyses at once')
+    .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.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — v5.0.0 Infinite Intelligence Full Scan\n`));
+        console.log(chalk.cyan('  Running ALL modules: v3.0.0 + v4.0.0 + v5.0.0...'));
+        console.log(chalk.dim('  Hierarchical Memory | Context Recall | Consensus | Collective Learning'));
+        console.log(chalk.dim('  TurboQuant | SSSP | CAIP | Self-Evolution | Predictive | Knowledge Graph | Swarm | Adversarial\n'));
+        const results = await orchestrator.runFullHyperAnalysis();
+        // v5.0.0 Infinite Intelligence results
+        const status = orchestrator.getStatus();
+        const hmStats = status.hierarchicalMemoryStats;
+        const crStats = status.contextRecallStats;
+        const ceStats = status.consensusStats;
+        const clStats = status.collectiveLearningStats;
+        console.log(chalk.bold('  v5.0.0 Infinite Intelligence:'));
+        if (hmStats) {
+            console.log(chalk `  {magenta Hierarchical Memory:} ${hmStats.totalEntries} entries (${hmStats.rawCount} raw, ${hmStats.summaryCount} summary, ${hmStats.patternCount} pattern, ${hmStats.principleCount} principle)`);
+            console.log(chalk `  {magenta Compression:} ${(hmStats.compressionRatio * 100).toFixed(1)}% | Retention: INFINITE`);
+        }
+        if (crStats) {
+            console.log(chalk `  {magenta Context Recall:} ${crStats.triggerCount} learned triggers, ${crStats.linkCount} activation links`);
+        }
+        if (ceStats) {
+            console.log(chalk `  {magenta Consensus:} ${ceStats.totalProposals} proposals, ${ceStats.acceptedCount} accepted, ${ceStats.agentCount} agents`);
+        }
+        if (clStats) {
+            console.log(chalk `  {magenta Collective:} ${clStats.totalRules} rules, ${clStats.verifiedRules} verified, ${(clStats.averageAccuracy * 100).toFixed(0)}% avg accuracy`);
+        }
+        // v4.0.0 results
+        console.log(chalk.bold('\n  v4.0.0 Hyper-Intelligence:'));
+        const turbo = results.turboMemoryStats;
+        console.log(chalk `  {cyan TurboQuant:} ${turbo ? `${turbo.totalEntries} entries, ${(turbo.compressionRatio * 100).toFixed(1)}% compressed` : 'N/A'}`);
+        console.log(chalk `  {cyan Evolution:} gen ${results.evolutionSnapshot?.generation ?? 0}, fitness ${results.evolutionSnapshot?.bestFitness?.toFixed(3) ?? 'N/A'}`);
+        // v3.0.0 results
+        console.log(chalk.bold(`\n  v3.0.0 Findings: ${results.total}\n`));
+        if (opts.json) {
+            console.log(JSON.stringify({ v3: results, v5: { hmStats, crStats, ceStats, clStats } }, null, 2));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
 // ─── MAIN ─────────────────────────────────────────────────────────────────────
 const program = new Command();
 program
     .name('shadow-brain')
-    .description('Shadow Brain v4.0.0 — Hyper-Intelligence Layer for AI Coding Agents with Infinite Memory & Self-Evolution')
+    .description('Shadow Brain v5.0.1 — Infinite Intelligence Layer for AI Coding Agents with Zero-Config Setup, MCP Server, Rich Dashboard, Hierarchical Memory, Context Recall, Consensus & Collective Learning')
     .version(VERSION);
 program.addCommand(startCmd);
 program.addCommand(reviewCmd);
@@ -2238,5 +2483,186 @@ program.addCommand(graphCmd);
 program.addCommand(swarmCmd);
 program.addCommand(defenseCmd);
 program.addCommand(v4Cmd);
+program.addCommand(memoryCmd);
+program.addCommand(recallCmd);
+program.addCommand(consensusCmd);
+program.addCommand(collectiveCmd);
+program.addCommand(v5Cmd);
+// ─── v5.0.1 COMMANDS ────────────────────────────────────────────────────────────
+// off — Stop Shadow Brain (alias for killing the process, clean shutdown)
+const offCmd = new Command('off')
+    .description('Stop Shadow Brain and clean up')
+    .action(async () => {
+    console.log(chalk.magenta.bold('\n  SHADOW BRAIN v' + VERSION + ' — Shutting down'));
+    try {
+        const { default: execaDefault } = await import('execa');
+        const exec = execaDefault;
+        try {
+            if (process.platform === 'win32') {
+                await exec('taskkill', ['/F', '/IM', 'node.exe', '/FI', 'WINDOWTITLE eq shadow-brain*'], { reject: false });
+            }
+            else {
+                await exec('pkill', ['-f', 'shadow-brain'], { reject: false });
+            }
+        }
+        catch { /* no process found */ }
+        console.log(chalk.green('  Shadow Brain stopped successfully.'));
+    }
+    catch {
+        console.log(chalk.yellow('  No running Shadow Brain instance found.'));
+    }
+    process.exit(0);
+});
+// ask — Natural language query against brain state
+const askCmd = new Command('ask')
+    .description('Ask Shadow Brain a question about your project')
+    .argument('<question>', 'Natural language question')
+    .option('-p, --provider <provider>', 'LLM provider')
+    .option('-m, --model <model>', 'LLM model')
+    .action(async (question, opts) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Ask`));
+    console.log(chalk.dim('  Question: ') + chalk.cyan(question));
+    try {
+        const brainConfig = mergeConfig({ ...opts, projectDir: process.cwd() });
+        const orchestrator = new Orchestrator(brainConfig);
+        await orchestrator.start();
+        // Get project context and build a prompt
+        const status = orchestrator.getStatus();
+        const prompt = `You are Shadow Brain, an expert AI coding intelligence layer. Based on the following project context, answer the user's question concisely.\n\nProject: ${status.projectDir}\nProvider: ${status.provider}\nHealth Score: ${status.healthScore || 'N/A'}\nInsights Generated: ${status.insightsGenerated}\nFiles Reviewed: ${status.filesReviewed}\n\nQuestion: ${question}\n\nAnswer:`;
+        // Use the LLM client directly via the analyzer's prompt builder
+        const llm = new (await import('./brain/llm-client.js')).LLMClient({
+            provider: brainConfig.provider,
+            apiKey: brainConfig.apiKey,
+            model: brainConfig.model,
+        });
+        const answer = await llm.complete(prompt);
+        console.log(chalk.green('\n  ' + answer));
+        await orchestrator.stop();
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// export — Export brain state
+const exportCmd = new Command('export')
+    .description('Export full brain state to a portable JSON file')
+    .option('-o, --output <dir>', 'Output directory for the export')
+    .action(async (opts) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Export`));
+    try {
+        const { BrainPortability } = await import('./brain/brain-portability.js');
+        const portability = new BrainPortability(process.cwd(), opts.output);
+        const result = await portability.exportBrain();
+        console.log(chalk.green('  Brain state exported successfully!'));
+        console.log(chalk.dim('  File: ') + chalk.cyan(result.filePath));
+        console.log(chalk.dim('  Size: ') + chalk.cyan((result.sizeBytes / 1024).toFixed(1) + ' KB'));
+        console.log(chalk.dim('  SHA-256: ') + chalk.dim(result.checksum.slice(0, 16) + '...'));
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// import — Import brain state
+const importCmd = new Command('import')
+    .description('Import brain state from an export file')
+    .argument('<file>', 'Path to the export JSON file')
+    .option('--merge', 'Merge with existing state instead of replacing')
+    .option('--skip <modules>', 'Comma-separated list of modules to skip')
+    .action(async (file, opts) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Import`));
+    try {
+        const { BrainPortability } = await import('./brain/brain-portability.js');
+        const portability = new BrainPortability(process.cwd());
+        const result = await portability.importBrain(file, {
+            merge: opts.merge || false,
+            skipModules: opts.skip?.split(',') || [],
+        });
+        console.log(chalk.green('  Brain state imported successfully!'));
+        console.log(chalk.dim('  Imported: ') + chalk.green(result.imported.join(', ') || 'none'));
+        console.log(chalk.dim('  Skipped: ') + chalk.yellow(result.skipped.join(', ') || 'none'));
+        if (result.errors.length > 0) {
+            console.log(chalk.dim('  Errors: ') + chalk.red(result.errors.join('; ')));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+// plugin — Manage plugins
+const pluginCmd = new Command('plugin')
+    .description('Manage Shadow Brain plugins')
+    .addCommand(new Command('list')
+    .description('List installed plugins')
+    .action(async () => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Plugins`));
+    try {
+        const { PluginSystem } = await import('./brain/plugin-system.js');
+        const ps = new PluginSystem(process.cwd());
+        await ps.loadAll();
+        const plugins = ps.getPlugins();
+        if (plugins.length === 0) {
+            console.log(chalk.dim('  No plugins found.'));
+            console.log(chalk.dim('  Add plugins to: ') + chalk.cyan('shadow-brain-plugins/'));
+            return;
+        }
+        for (const p of plugins) {
+            const status = p.enabled ? chalk.green('active') : chalk.red('disabled');
+            console.log(`  ${status} ${chalk.bold(p.manifest.name)} v${p.manifest.version} — ${chalk.dim(p.manifest.description)}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}))
+    .addCommand(new Command('create')
+    .description('Create a new plugin from template')
+    .argument('<name>', 'Plugin name')
+    .action(async (name) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Create Plugin`));
+    try {
+        const { PluginSystem } = await import('./brain/plugin-system.js');
+        const ps = new PluginSystem(process.cwd());
+        const dir = ps.createTemplate(name);
+        console.log(chalk.green('  Plugin template created!'));
+        console.log(chalk.dim('  Directory: ') + chalk.cyan(dir));
+        console.log(chalk.dim('  Edit manifest.json and index.js to customize.'));
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+}))
+    .addCommand(new Command('stats')
+    .description('Show plugin system statistics')
+    .action(async () => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Plugin Stats`));
+    try {
+        const { PluginSystem } = await import('./brain/plugin-system.js');
+        const ps = new PluginSystem(process.cwd());
+        await ps.loadAll();
+        const stats = ps.getStats();
+        console.log(chalk.dim('  Total plugins: ') + chalk.cyan(String(stats.totalPlugins)));
+        console.log(chalk.dim('  Enabled: ') + chalk.green(String(stats.enabledPlugins)));
+        console.log(chalk.dim('  Disabled: ') + chalk.red(String(stats.disabledPlugins)));
+        console.log(chalk.dim('  Total hooks: ') + chalk.cyan(String(stats.totalHooks)));
+        if (Object.keys(stats.hooksByEvent).length > 0) {
+            console.log(chalk.dim('  Hooks by event:'));
+            for (const [event, count] of Object.entries(stats.hooksByEvent)) {
+                console.log(`    ${chalk.cyan(event)}: ${count}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}));
+program.addCommand(offCmd);
+program.addCommand(askCmd);
+program.addCommand(exportCmd);
+program.addCommand(importCmd);
+program.addCommand(pluginCmd);
 program.parse();
 //# sourceMappingURL=cli.js.map