@theihtisham/agent-shadow-brain 5.0.1 → 5.2.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// src/cli.ts — CLI entry point for Shadow Brain v5.0.1
+// src/cli.ts — CLI entry point for Shadow Brain v5.1.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 = '5.0.1';
+const VERSION = '5.1.1';
 const config = new Conf({
     projectName: 'shadow-brain',
     defaults: {
@@ -2495,8 +2495,7 @@ const offCmd = new Command('off')
     .action(async () => {
     console.log(chalk.magenta.bold('\n  SHADOW BRAIN v' + VERSION + ' — Shutting down'));
     try {
-        const { default: execaDefault } = await import('execa');
-        const exec = execaDefault;
+        const { execa: exec } = await import('execa');
         try {
             if (process.platform === 'win32') {
                 await exec('taskkill', ['/F', '/IM', 'node.exe', '/FI', 'WINDOWTITLE eq shadow-brain*'], { reject: false });
@@ -2664,5 +2663,436 @@ program.addCommand(askCmd);
 program.addCommand(exportCmd);
 program.addCommand(importCmd);
 program.addCommand(pluginCmd);
+// ── v5.1.1 Commands ─────────────────────────────────────────────────────
+const lspCmd = new Command('lsp')
+    .description('Start the built-in Language Server Protocol server')
+    .option('--port <port>', 'TCP port for LSP server', '7343')
+    .option('--stdio', 'Use stdio transport instead of TCP')
+    .action(async (opts) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — LSP Server`));
+    try {
+        const { LSPServer } = await import('./brain/lsp-server.js');
+        const lsp = new LSPServer(process.cwd());
+        if (opts.stdio) {
+            console.log(chalk.cyan('  Starting LSP server (stdio mode)...'));
+            lsp.startStdio();
+        }
+        else {
+            const port = parseInt(opts.port, 10);
+            console.log(chalk.cyan(`  Starting LSP server on port ${port}...`));
+            lsp.startTCP(port);
+        }
+        console.log(chalk.green('  LSP server running. Connect your editor.'));
+        console.log(chalk.dim('  Features: diagnostics, hover, completions, code actions'));
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+        process.exit(1);
+    }
+});
+const finetuneCmd = new Command('fine-tune')
+    .description('Train the brain on your codebase patterns')
+    .addCommand(new Command('train')
+    .description('Train on the current project')
+    .option('--dir <directory>', 'Directory to train on')
+    .action(async (opts) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Fine-Tuning Engine`));
+    try {
+        const { FineTuningEngine } = await import('./brain/fine-tuning-engine.js');
+        const ft = new FineTuningEngine(opts.dir || process.cwd());
+        console.log(chalk.cyan('  Training on codebase patterns...'));
+        await ft.trainOnDirectory(opts.dir);
+        await ft.save();
+        const stats = ft.stats();
+        console.log(chalk.green('  Training complete!'));
+        console.log(chalk.dim('  Patterns: ') + chalk.cyan(String(stats.totalPatterns)));
+        console.log(chalk.dim('  Training points: ') + chalk.cyan(String(stats.totalTrainingPoints)));
+        console.log(chalk.dim('  Models: ') + chalk.cyan(String(stats.models)));
+        console.log(chalk.dim('  Accuracy: ') + chalk.cyan(`${(stats.accuracy * 100).toFixed(1)}%`));
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}))
+    .addCommand(new Command('stats')
+    .description('Show fine-tuning statistics')
+    .action(async () => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Fine-Tune Stats`));
+    try {
+        const { FineTuningEngine } = await import('./brain/fine-tuning-engine.js');
+        const ft = new FineTuningEngine(process.cwd());
+        await ft.load();
+        const stats = ft.stats();
+        console.log(chalk.dim('  Patterns: ') + chalk.cyan(String(stats.totalPatterns)));
+        console.log(chalk.dim('  Training points: ') + chalk.cyan(String(stats.totalTrainingPoints)));
+        console.log(chalk.dim('  Models: ') + chalk.cyan(String(stats.models)));
+        console.log(chalk.dim('  Accuracy: ') + chalk.cyan(`${(stats.accuracy * 100).toFixed(1)}%`));
+        if (stats.lastTrainingRun) {
+            console.log(chalk.dim('  Last trained: ') + chalk.cyan(new Date(stats.lastTrainingRun).toLocaleString()));
+        }
+        if (stats.topPatterns.length > 0) {
+            console.log(chalk.dim('\n  Top patterns:'));
+            for (const p of stats.topPatterns.slice(0, 5)) {
+                console.log(`    ${chalk.yellow(p.type)} (${p.count}x)`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}))
+    .addCommand(new Command('suggest')
+    .description('Get code suggestions based on trained model')
+    .argument('[context]', 'Context for suggestions', '')
+    .action(async (context) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Code Suggestions`));
+    try {
+        const { FineTuningEngine } = await import('./brain/fine-tuning-engine.js');
+        const ft = new FineTuningEngine(process.cwd());
+        await ft.load();
+        const suggestions = ft.suggest(context || 'general');
+        if (suggestions.length === 0) {
+            console.log(chalk.dim('  No suggestions yet. Run: shadow-brain fine-tune train'));
+            return;
+        }
+        for (const s of suggestions) {
+            console.log(`  ${chalk.cyan(s.category)} ${chalk.white(s.text)} (${chalk.dim(`${(s.confidence * 100).toFixed(0)}%`)})`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}));
+const cacheCmd = new Command('cache')
+    .description('Smart cache management')
+    .addCommand(new Command('stats')
+    .description('Show cache statistics')
+    .action(async () => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Smart Cache`));
+    try {
+        const { SmartCache } = await import('./brain/smart-cache.js');
+        const cache = new SmartCache();
+        const stats = cache.stats();
+        console.log(chalk.dim('  Hot: ') + chalk.red(String(stats.hotEntries)));
+        console.log(chalk.dim('  Warm: ') + chalk.yellow(String(stats.warmEntries)));
+        console.log(chalk.dim('  Cold: ') + chalk.blue(String(stats.coldEntries)));
+        console.log(chalk.dim('  Hit rate: ') + chalk.green(`${(stats.hitRate * 100).toFixed(1)}%`));
+        console.log(chalk.dim('  Memory: ') + chalk.cyan(`${stats.memoryUsageMB} MB`));
+        console.log(chalk.dim('  Prefetch hits: ') + chalk.cyan(String(stats.prefetchHits)));
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}));
+const intentCmd = new Command('intent')
+    .description('Developer intent prediction')
+    .addCommand(new Command('stats')
+    .description('Show intent prediction statistics')
+    .action(async () => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Intent Engine`));
+    try {
+        const { IntentEngine } = await import('./brain/intent-engine.js');
+        const ie = new IntentEngine();
+        const stats = ie.stats();
+        console.log(chalk.dim('  Predictions: ') + chalk.cyan(String(stats.totalPredictions)));
+        console.log(chalk.dim('  Accuracy: ') + chalk.green(`${(stats.accuracy * 100).toFixed(1)}%`));
+        console.log(chalk.dim('  Avg confidence: ') + chalk.cyan(`${(stats.avgConfidence * 100).toFixed(1)}%`));
+        if (stats.topIntents.length > 0) {
+            console.log(chalk.dim('\n  Top intents:'));
+            for (const a of stats.topIntents.slice(0, 5)) {
+                console.log(`    ${chalk.yellow(a.action)}: ${a.count}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}));
+const dnaCmd = new Command('dna')
+    .description('Code DNA fingerprinting and style analysis')
+    .addCommand(new Command('profile')
+    .description('Build a DNA profile of the project')
+    .option('--name <name>', 'Profile name', 'default')
+    .action(async (opts) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Code DNA`));
+    try {
+        const { CodeDNA } = await import('./brain/code-dna.js');
+        const dna = new CodeDNA(process.cwd());
+        console.log(chalk.cyan('  Building DNA profile...'));
+        const profile = await dna.buildProfile(opts.name);
+        console.log(chalk.green('  Profile built!'));
+        console.log(chalk.dim('  Files analyzed: ') + chalk.cyan(String(profile.fileCount)));
+        console.log(chalk.dim('  Genes tracked: ') + chalk.cyan(String(profile.genes.size)));
+        console.log(chalk.dim('\n  Gene highlights:'));
+        for (const g of Array.from(profile.genes.values()).slice(0, 8)) {
+            const bar = '█'.repeat(Math.round(g.value * 10)) + '░'.repeat(10 - Math.round(g.value * 10));
+            console.log(`    ${chalk.dim(g.category.padEnd(16))} ${chalk.yellow(g.trait.padEnd(24))} ${chalk.cyan(bar)} ${(g.value * 100).toFixed(0)}%`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}))
+    .addCommand(new Command('consistency')
+    .description('Check code style consistency')
+    .action(async () => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Style Consistency`));
+    try {
+        const { CodeDNA } = await import('./brain/code-dna.js');
+        const dna = new CodeDNA(process.cwd());
+        console.log(chalk.cyan('  Analyzing consistency...'));
+        const report = await dna.checkConsistency();
+        const scoreColor = report.overall > 0.8 ? chalk.green : report.overall > 0.6 ? chalk.yellow : chalk.red;
+        console.log(chalk.dim('  Overall score: ') + scoreColor(`${(report.overall * 100).toFixed(1)}%`));
+        if (report.recommendations.length > 0) {
+            console.log(chalk.dim('\n  Recommendations:'));
+            for (const r of report.recommendations.slice(0, 5)) {
+                console.log(`    ${chalk.yellow('→')} ${r}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}));
+const temporalCmd = new Command('temporal')
+    .description('Temporal code evolution analysis')
+    .addCommand(new Command('velocity')
+    .description('Show development velocity')
+    .action(async () => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Velocity`));
+    try {
+        const { TemporalIntelligence } = await import('./brain/temporal-intelligence.js');
+        const ti = new TemporalIntelligence(process.cwd());
+        const velocity = ti.getVelocity();
+        const trendIcon = velocity.trend === 'accelerating' ? '🚀' : velocity.trend === 'stable' ? '→' : velocity.trend === 'decelerating' ? '↓' : '⏸';
+        console.log(chalk.dim('  Daily events: ') + chalk.cyan(String(velocity.daily)));
+        console.log(chalk.dim('  Weekly events: ') + chalk.cyan(String(velocity.weekly)));
+        console.log(chalk.dim('  Monthly events: ') + chalk.cyan(String(velocity.monthly)));
+        console.log(chalk.dim('  Trend: ') + chalk.yellow(`${trendIcon} ${velocity.trend} (${(velocity.trendConfidence * 100).toFixed(0)}%)`));
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}))
+    .addCommand(new Command('hotfiles')
+    .description('Show most active files')
+    .option('-n <count>', 'Number of files', '10')
+    .action(async (opts) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Hot Files`));
+    try {
+        const { TemporalIntelligence } = await import('./brain/temporal-intelligence.js');
+        const ti = new TemporalIntelligence(process.cwd());
+        const hot = ti.getHotFiles(parseInt(opts.n || '10', 10));
+        if (hot.length === 0) {
+            console.log(chalk.dim('  No file history yet. Run analysis first.'));
+            return;
+        }
+        for (const f of hot) {
+            const bar = '█'.repeat(Math.round(f.hotness * 10)) + '░'.repeat(10 - Math.round(f.hotness * 10));
+            console.log(`  ${chalk.red(bar)} ${chalk.dim(`${(f.hotness * 100).toFixed(0)}%`.padStart(4))} ${chalk.white(f.file)}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}))
+    .addCommand(new Command('predict-bugs')
+    .description('Predict bug-prone files')
+    .option('-n <count>', 'Number of predictions', '10')
+    .action(async (opts) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Bug Predictions`));
+    try {
+        const { TemporalIntelligence } = await import('./brain/temporal-intelligence.js');
+        const ti = new TemporalIntelligence(process.cwd());
+        const bugs = ti.predictBugs(parseInt(opts.n || '10', 10));
+        if (bugs.length === 0) {
+            console.log(chalk.dim('  No predictions available. Need more history.'));
+            return;
+        }
+        for (const b of bugs) {
+            const risk = b.probability > 0.7 ? chalk.red : b.probability > 0.4 ? chalk.yellow : chalk.green;
+            console.log(`  ${risk(`${(b.probability * 100).toFixed(0)}%`.padStart(4))} ${chalk.white(b.file)}`);
+            for (const f of b.factors) {
+                console.log(`       ${chalk.dim('→')} ${chalk.dim(f)}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('  Error:'), err.message);
+    }
+}));
+program.addCommand(lspCmd);
+program.addCommand(finetuneCmd);
+program.addCommand(cacheCmd);
+program.addCommand(intentCmd);
+program.addCommand(dnaCmd);
+program.addCommand(temporalCmd);
+// ─── v5.2.0 — SUBCONSCIOUS SINGULARITY ──────────────────────────────────────
+const attachCmd = new Command('attach-all')
+    .description('Auto-detect every installed AI agent and install Shadow Brain hooks (v5.2.0)')
+    .argument('[project-dir]', 'Project directory', process.cwd())
+    .option('--dry-run', 'Show what would be attached without installing')
+    .action(async (projectDir, opts) => {
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Universal Bootstrap`));
+    const { getHookInstaller } = await import('./brain/session-hooks.js');
+    const installer = getHookInstaller();
+    if (opts.dryRun) {
+        const detected = await installer.detectInstalled(projectDir);
+        console.log(chalk.cyan(`  Detected agents: ${detected.length}`));
+        for (const agent of detected) {
+            console.log(`    ${chalk.green('✓')} ${agent}`);
+        }
+        console.log(chalk.dim('\n  Run without --dry-run to install hooks.'));
+        return;
+    }
+    const report = await installer.attachAll(projectDir);
+    console.log(chalk.cyan(`  Detected: ${report.detected.length} agents (${report.durationMs}ms)`));
+    for (const agent of report.attached) {
+        console.log(`    ${chalk.green('✓')} ${agent} attached`);
+    }
+    for (const fail of report.failed) {
+        console.log(`    ${chalk.red('✗')} ${fail.agent}: ${fail.reason}`);
+    }
+    console.log(chalk.dim(`\n  ${report.hooks.length} hook(s) installed across ${report.attached.length} agent(s).`));
+    console.log(chalk.dim('  Every agent will now call Shadow Brain on session start.'));
+});
+const subconsciousCmd = new Command('subconscious')
+    .description('Manage the Subconscious Engine — proactive context injection')
+    .addCommand(new Command('inject')
+    .description('Generate + emit a session-start briefing for the current agent')
+    .option('--agent <agent>', 'Agent tool name (auto-detected if omitted)')
+    .option('--task <hint>', 'Current task hint for similarity search')
+    .option('--json', 'Output JSON instead of formatted text')
+    .action(async (opts) => {
+    const { getSubconscious } = await import('./brain/subconscious.js');
+    const { GlobalBrain } = await import('./brain/global-brain.js');
+    const projectDir = process.cwd();
+    const projectId = GlobalBrain.projectIdFor(projectDir);
+    let agentTool = opts.agent;
+    if (!agentTool) {
+        const detected = await detectRunningAgents(projectDir);
+        agentTool = detected[0]?.name || 'claude-code';
+    }
+    const sub = getSubconscious();
+    const briefing = await sub.generateBriefing({
+        agentTool,
+        projectDir,
+        projectId,
+        currentTask: opts.task,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(briefing, null, 2));
+    }
+    else {
+        console.log(briefing.fullText || chalk.dim('(no relevant context yet — brain is empty)'));
+    }
+}))
+    .addCommand(new Command('status')
+    .description('Show subconscious engine stats')
+    .action(async () => {
+    const { getSubconscious } = await import('./brain/subconscious.js');
+    const stats = getSubconscious().getStats();
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Subconscious Stats`));
+    console.log(`    Total briefings: ${chalk.cyan(stats.totalBriefings)}`);
+    console.log(`    Avg tokens: ${chalk.cyan(stats.avgTokenCount.toFixed(0))}`);
+    console.log(`    Avg generation: ${chalk.cyan(stats.avgGenerationMs.toFixed(1) + 'ms')}`);
+    console.log(`    By agent:`);
+    for (const [agent, count] of Object.entries(stats.byAgent)) {
+        console.log(`      ${chalk.dim('•')} ${agent}: ${count}`);
+    }
+}))
+    .addCommand(new Command('configure')
+    .description('Update subconscious config')
+    .option('--budget <tokens>', 'Token budget (default 2000)')
+    .option('--lookback <hours>', 'Lookback hours (default 24)')
+    .option('--threshold <score>', 'Relevance threshold 0-1')
+    .option('--enable', 'Enable subconscious')
+    .option('--disable', 'Disable subconscious')
+    .action(async (opts) => {
+    const { getSubconscious } = await import('./brain/subconscious.js');
+    const sub = getSubconscious();
+    const patch = {};
+    if (opts.budget)
+        patch.tokenBudget = parseInt(opts.budget, 10);
+    if (opts.lookback)
+        patch.lookbackHours = parseFloat(opts.lookback);
+    if (opts.threshold)
+        patch.relevanceThreshold = parseFloat(opts.threshold);
+    if (opts.enable)
+        patch.enabled = true;
+    if (opts.disable)
+        patch.enabled = false;
+    sub.configure(patch);
+    console.log(chalk.green('  ✓ Subconscious config updated.'));
+    console.log(JSON.stringify(sub.getConfig(), null, 2));
+}));
+const globalBrainCmd = new Command('global')
+    .description('Manage the Singleton Global Brain — one brain, all projects, all agents')
+    .addCommand(new Command('stats')
+    .description('Show global brain stats')
+    .action(async () => {
+    const { getGlobalBrain } = await import('./brain/global-brain.js');
+    const brain = getGlobalBrain();
+    await brain.init();
+    const s = brain.getStats();
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Global Brain`));
+    console.log(`    Projects: ${chalk.cyan(s.totalProjects)}`);
+    console.log(`    Agents:   ${chalk.cyan(s.totalAgents)}`);
+    console.log(`    Entries:  ${chalk.cyan(s.totalEntries)}`);
+    console.log(`    Size:     ${chalk.cyan(s.totalSizeMB.toFixed(2) + ' MB')}`);
+    console.log(`    Hit rate: ${chalk.cyan((s.hitRate * 100).toFixed(1) + '%')} (${s.hits}/${s.hits + s.misses})`);
+    console.log(`    Pending:  ${chalk.cyan(s.pendingWrites)}`);
+    console.log(`    Uptime:   ${chalk.cyan(Math.round(s.uptime / 1000) + 's')}`);
+    console.log(`    Last sync: ${chalk.dim(s.lastSync.toISOString())}`);
+}))
+    .addCommand(new Command('recall')
+    .description('Recall entries from the global brain — works across projects + agents')
+    .option('-q, --query <text>', 'Keyword search')
+    .option('--agent <agent>', 'Filter by agent tool')
+    .option('--category <cat>', 'Filter by category')
+    .option('--limit <n>', 'Max results', '20')
+    .option('--json', 'Output JSON')
+    .action(async (opts) => {
+    const { getGlobalBrain } = await import('./brain/global-brain.js');
+    const brain = getGlobalBrain();
+    await brain.init();
+    const results = brain.recall({
+        keywords: opts.query ? opts.query.split(/\s+/) : undefined,
+        agentTool: opts.agent,
+        category: opts.category,
+        limit: parseInt(opts.limit, 10),
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — Global Recall (${results.length})`));
+    for (const r of results) {
+        console.log(`    ${chalk.cyan('[' + r.agentTool + ']')} ${chalk.dim(r.category)} ${chalk.white(r.content.slice(0, 100))}`);
+    }
+}))
+    .addCommand(new Command('cache')
+    .description('Show L0 in-memory cache stats')
+    .action(async () => {
+    const { getAllCacheStats } = await import('./brain/l0-cache.js');
+    const all = getAllCacheStats();
+    console.log(chalk.magenta.bold(`\n  SHADOW BRAIN v${VERSION} — L0 Cache`));
+    for (const [name, s] of Object.entries(all)) {
+        console.log(`    ${chalk.cyan(name)}: ${s.entries} entries, ${(s.bytesUsed / 1024).toFixed(1)} KB / ${(s.bytesLimit / 1024 / 1024).toFixed(0)} MB, ${(s.hitRate * 100).toFixed(1)}% hits, ${s.avgAccessNs.toFixed(0)}ns avg`);
+    }
+}))
+    .addCommand(new Command('sync')
+    .description('Force flush of pending writes to disk')
+    .action(async () => {
+    const { getGlobalBrain } = await import('./brain/global-brain.js');
+    const brain = getGlobalBrain();
+    await brain.init();
+    await brain.sync();
+    console.log(chalk.green('  ✓ Synced to disk.'));
+}));
+program.addCommand(attachCmd);
+program.addCommand(subconsciousCmd);
+program.addCommand(globalBrainCmd);
 program.parse();
 //# sourceMappingURL=cli.js.map