@theihtisham/agent-shadow-brain 2.1.0 → 4.0.0

package/dist/brain/orchestrator.js

@@ -1,5 +1,5 @@
 // src/brain/orchestrator.ts — Central brain loop: watchers → analyzer → adapters
-// v2.0.0 — Super-Intelligence Edition
+// v4.0.0 — Hyper-Intelligence Edition
 import { EventEmitter } from 'events';
 import * as crypto from 'crypto';
 import { LLMClient } from './llm-client.js';
@@ -29,9 +29,29 @@ import { MCPServer } from './mcp-server.js';
 import { TeamMode } from './team-mode.js';
 import { MultiProjectManager } from './multi-project.js';
 import { NeuralMesh } from './neural-mesh.js';
+// v3.0.0 Hyper-Intelligence Modules
+import { ASTAnalyzer } from './ast-analyzer.js';
+import { AccessibilityChecker } from './accessibility-checker.js';
+import { I18nDetector } from './i18n-detector.js';
+import { DeadCodeEliminator } from './dead-code-eliminator.js';
+import { MutationAdvisor } from './mutation-advisor.js';
+import { CodeAgeAnalyzer } from './code-age-analyzer.js';
+import { APIContractAnalyzer } from './api-contract-analyzer.js';
+import { EnvAnalyzer } from './env-analyzer.js';
+import { LicenseCompliance } from './license-compliance.js';
+import { ConfigDriftDetector } from './config-drift-detector.js';
 import { FileWatcher } from '../watchers/file-watcher.js';
 import { GitWatcher } from '../watchers/git-watcher.js';
 import { createAdapter, detectRunningAgents } from '../adapters/index.js';
+// v4.0.0 Hyper-Intelligence Modules
+import { TurboMemory } from './turbo-memory.js';
+import { SSSPRouter } from './sssp-router.js';
+import { CrossAgentProtocol } from './cross-agent-protocol.js';
+import { SelfEvolution } from './self-evolution.js';
+import { PredictiveEngine } from './predictive-engine.js';
+import { KnowledgeGraph } from './knowledge-graph.js';
+import { SwarmIntelligence } from './swarm-intelligence.js';
+import { AdversarialDefense } from './adversarial-defense.js';
 export class Orchestrator extends EventEmitter {
     constructor(config) {
         super();
@@ -42,10 +62,12 @@ export class Orchestrator extends EventEmitter {
         this.multiProject = null;
         // v2.1.0 Quantum Neural Mesh
         this.neuralMesh = null;
+        this.knowledgeGraph = null;
         this.running = false;
         this.analyzing = false;
         this.pendingChanges = [];
         this.debounceTimer = null;
+        this.evolutionTimer = null;
         this.currentSession = null;
         this.startTime = 0;
         this.lastHealthScore = null;
@@ -87,6 +109,26 @@ export class Orchestrator extends EventEmitter {
         this.perfProfiler = new PerformanceProfiler(config.projectDir);
         this.contextCompletion = new ContextCompletionEngine(config.projectDir);
         this.learningEngine = new LearningEngine(config.projectDir, this.llmClient);
+        // v3.0.0 Hyper-Intelligence Modules
+        this.astAnalyzer = new ASTAnalyzer(config.projectDir);
+        this.a11yChecker = new AccessibilityChecker(config.projectDir);
+        this.i18nDetector = new I18nDetector(config.projectDir);
+        this.deadCodeEliminator = new DeadCodeEliminator(config.projectDir);
+        this.mutationAdvisor = new MutationAdvisor(config.projectDir);
+        this.codeAgeAnalyzer = new CodeAgeAnalyzer(config.projectDir);
+        this.apiContractAnalyzer = new APIContractAnalyzer(config.projectDir);
+        this.envAnalyzer = new EnvAnalyzer(config.projectDir);
+        this.licenseCompliance = new LicenseCompliance(config.projectDir);
+        this.configDriftDetector = new ConfigDriftDetector(config.projectDir);
+        // v4.0.0 Hyper-Intelligence Modules
+        this.turboMemory = new TurboMemory();
+        this.ssspRouter = new SSSPRouter();
+        this.crossAgentProtocol = new CrossAgentProtocol();
+        this.selfEvolution = new SelfEvolution();
+        this.predictiveEngine = new PredictiveEngine();
+        this.knowledgeGraph = new KnowledgeGraph(config.projectDir);
+        this.swarmIntelligence = new SwarmIntelligence();
+        this.adversarialDefense = new AdversarialDefense();
         // Load project config and setup notifier if configured
         const projectConfig = this.projectConfigLoader.load();
         if (projectConfig.notifications) {
@@ -147,6 +189,28 @@ export class Orchestrator extends EventEmitter {
             });
         }
         this.emit('agents-detected', { adapters: this.adapters });
+        // v4.0.0: Start Cross-Agent Protocol
+        await this.crossAgentProtocol.start().catch(() => { });
+        // v4.0.0: Initialize swarm with project files
+        try {
+            const projectContext = await this.contextBuilder.build([]);
+            const projectFiles = projectContext.recentFiles || projectContext.structure || [];
+            if (projectFiles.length > 0) {
+                const paths = projectFiles.slice(0, 200).map((f) => typeof f === 'string' ? f : f.path || f.name || '');
+                this.swarmIntelligence.initialize(paths.filter(Boolean));
+            }
+        }
+        catch { /* swarm init is best-effort */ }
+        // v4.0.0: Periodic self-evolution (every 30 minutes)
+        this.evolutionTimer = setInterval(async () => {
+            try {
+                await this.selfEvolution.evolve(this.currentSession?.insights || []);
+                if (this.knowledgeGraph) {
+                    await this.knowledgeGraph.build().catch(() => { });
+                }
+            }
+            catch { /* evolution runs silently */ }
+        }, 30 * 60 * 1000);
         if (this.config.watchMode) {
             this.setupWatchers();
             this.running = true;
@@ -175,6 +239,12 @@ export class Orchestrator extends EventEmitter {
         if (this.neuralMesh) {
             await this.neuralMesh.disconnect().catch(() => { });
         }
+        // v4.0.0: Cross-Agent Protocol shutdown + evolution timer cleanup
+        await this.crossAgentProtocol.stop().catch(() => { });
+        if (this.evolutionTimer) {
+            clearInterval(this.evolutionTimer);
+            this.evolutionTimer = null;
+        }
         this.emit('stopped');
     }
     async reviewOnce() {
@@ -198,6 +268,28 @@ export class Orchestrator extends EventEmitter {
             activity: activities,
             agentMemory,
         });
+        // v4.0.0: Adversarial defense — verify critical/high insights
+        const verifiedInsights = [];
+        for (const insight of insights) {
+            if (insight.priority === 'critical' || insight.priority === 'high') {
+                try {
+                    const flag = await this.adversarialDefense.verifyInsight(insight, this.config.projectDir);
+                    if (!flag || flag.verdict === 'real') {
+                        verifiedInsights.push(insight);
+                    }
+                    else {
+                        insight.adversarialFlag = flag;
+                    }
+                }
+                catch {
+                    verifiedInsights.push(insight); // trust on error
+                }
+            }
+            else {
+                verifiedInsights.push(insight);
+            }
+        }
+        insights = verifiedInsights;
         // ── Apply framework-specific rules ─────────────────────────────────
         const framework = detectFramework(context.structure || [], {}, context.language || []);
         if (framework !== 'unknown') {
@@ -264,6 +356,12 @@ export class Orchestrator extends EventEmitter {
                 this.neuralMesh.broadcastHealth(healthScore.overall);
             }
         }
+        // v4.0.0: Cross-agent broadcast
+        await this.crossAgentProtocol.broadcast('claude-code', {
+            type: 'insights',
+            insights: insights.slice(0, 5),
+            healthScore: healthScore.overall,
+        }).catch(() => { });
         return insights;
     }
     /** Generate a full report (HTML/markdown/JSON) */
@@ -560,10 +658,87 @@ export class Orchestrator extends EventEmitter {
             return [];
         return this.neuralMesh.getConnectedNodes();
     }
+    // ── v3.0.0: Hyper-Intelligence Methods ────────────────────────────────
+    /** AST-level complexity analysis — functions, cyclomatic complexity, nesting */
+    async runASTAnalysis(maxFiles) {
+        return this.astAnalyzer.analyzeProject(maxFiles);
+    }
+    /** WCAG accessibility audit for frontend code */
+    async runA11yCheck(maxFiles) {
+        return this.a11yChecker.analyzeProject(maxFiles);
+    }
+    /** Internationalization readiness detection */
+    async runI18nAnalysis(maxFiles) {
+        return this.i18nDetector.analyzeProject(maxFiles);
+    }
+    /** Dead code elimination — unreachable code, unused exports */
+    async runDeadCodeAnalysis(maxFiles) {
+        return this.deadCodeEliminator.analyzeProject(maxFiles);
+    }
+    /** Mutation testing advisor — suggests test-killing mutations */
+    async runMutationAnalysis(maxFiles) {
+        return this.mutationAdvisor.analyzeProject(maxFiles);
+    }
+    /** Code age analysis — stale files, ownership, freshness */
+    async runCodeAgeAnalysis() {
+        return this.codeAgeAnalyzer.analyzeProject();
+    }
+    /** API contract analysis — endpoint discovery and security audit */
+    async runAPIContractAnalysis(maxFiles) {
+        return this.apiContractAnalyzer.analyzeProject(maxFiles);
+    }
+    /** Environment variable analysis — secrets, validation, naming */
+    async runEnvAnalysis(maxFiles) {
+        return this.envAnalyzer.analyzeProject(maxFiles);
+    }
+    /** License compliance audit — restricted, copyleft, unknown licenses */
+    async runLicenseCompliance() {
+        return this.licenseCompliance.analyzeProject();
+    }
+    /** Configuration drift detection — missing configs, tsconfig, gitignore */
+    async runConfigDriftDetection() {
+        return this.configDriftDetector.analyzeProject();
+    }
+    /** Run ALL v3.0.0 + v4.0.0 hyper-intelligence analyses at once */
+    async runFullHyperAnalysis(opts) {
+        const maxFiles = opts?.maxFiles ?? 200;
+        const [ast, a11y, i18n, deadCode, mutation, codeAge, apiContract, env, license, configDrift] = await Promise.all([
+            this.runASTAnalysis(maxFiles).catch(() => []),
+            this.runA11yCheck(maxFiles).catch(() => []),
+            this.runI18nAnalysis(maxFiles).catch(() => []),
+            this.runDeadCodeAnalysis(maxFiles).catch(() => []),
+            this.runMutationAnalysis(maxFiles).catch(() => []),
+            this.runCodeAgeAnalysis().catch(() => []),
+            this.runAPIContractAnalysis(maxFiles).catch(() => []),
+            this.runEnvAnalysis(maxFiles).catch(() => []),
+            this.runLicenseCompliance().catch(() => []),
+            this.runConfigDriftDetection().catch(() => []),
+        ]);
+        // v4.0.0 analyses
+        const turboMemoryStats = this.turboMemory?.stats() ?? null;
+        const swarmState = this.swarmIntelligence?.getState?.() ?? null;
+        const defenseStats = this.adversarialDefense?.getDefenseStats?.() ?? null;
+        const evolutionSnapshot = this.selfEvolution?.getSnapshot?.() ?? null;
+        let knowledgeGraphEntityCount = 0;
+        try {
+            if (this.knowledgeGraph) {
+                await this.knowledgeGraph.build();
+                const kgStats = this.knowledgeGraph.getStats?.();
+                knowledgeGraphEntityCount = kgStats?.entities ?? 0;
+            }
+        }
+        catch { /* best-effort */ }
+        return {
+            ast, a11y, i18n, deadCode, mutation, codeAge, apiContract, env, license, configDrift,
+            turboMemoryStats, swarmState, defenseStats, evolutionSnapshot, knowledgeGraphEntityCount,
+            total: ast.length + a11y.length + i18n.length + deadCode.length + mutation.length +
+                codeAge.length + apiContract.length + env.length + license.length + configDrift.length,
+        };
+    }
     getStatus() {
         return {
             running: this.running,
-            version: '2.1.0',
+            version: '4.0.0',
             agents: this.adapters.map(a => `${a.displayName} (${a.name})`),
             insightsGenerated: this.currentSession?.insights.length || 0,
             filesReviewed: this.currentSession?.filesReviewed || 0,
@@ -591,6 +766,18 @@ export class Orchestrator extends EventEmitter {
             neuralMeshEnabled: this.neuralMesh !== null,
             meshNodeId: this.neuralMesh?.getNodeId()?.slice(0, 8) ?? null,
             meshNodeCount: this.neuralMesh?.getConnectedNodes()?.length ?? 0,
+            // v3.0.0
+            hyperModules: [
+                'ast', 'a11y', 'i18n', 'dead-code', 'mutation', 'code-age',
+                'api-contract', 'env', 'license', 'config-drift',
+            ],
+            // v4.0.0 Hyper-Intelligence
+            turboMemoryStats: this.turboMemory?.stats() ?? null,
+            caipConnectedAgents: this.crossAgentProtocol?.getConnectedAgents?.() ?? [],
+            evolutionGeneration: this.selfEvolution?.getSnapshot?.()?.generation ?? 0,
+            swarmConvergence: this.swarmIntelligence?.getState?.()?.convergenceScore ?? 0,
+            knowledgeGraphEntities: this.knowledgeGraph ? (this.knowledgeGraph.getStats?.()?.entityCount ?? 0) : 0,
+            adversarialStats: this.adversarialDefense?.getDefenseStats?.() ?? null,
         };
     }
     setupWatchers() {
@@ -670,7 +857,7 @@ export class Orchestrator extends EventEmitter {
                 }
             }
             // Enhance with pattern memory insights
-            const patternInsights = this.patternMemory.getPatternInsights(changes);
+            const patternInsights = await this.patternMemory.getPatternInsights(changes);
             insights.push(...patternInsights);
             // ── Apply custom rules ────────────────────────────────────────
             const customInsights = this.customRulesEngine.applyRules(changes);
@@ -683,6 +870,18 @@ export class Orchestrator extends EventEmitter {
             for (const insight of insights) {
                 this.patternMemory.recordErrorPattern(insight);
             }
+            // v4.0.0: Store patterns in TurboMemory for infinite retention
+            try {
+                for (const change of changes.slice(0, 30)) {
+                    const text = change.path + ' ' + (change.content || '').slice(0, 200);
+                    const vector = this.textToVector(text);
+                    await this.turboMemory.store(change.path, vector, {
+                        type: 'file_change',
+                        insightCount: insights.length,
+                    });
+                }
+            }
+            catch { /* TurboMemory storage is best-effort */ }
             // ── v2.0.0: Super-Intelligence Enhancements ────────────────────
             // Type safety analysis on changed TypeScript files
             const tsFiles = changes.filter(c => c.path.endsWith('.ts') || c.path.endsWith('.tsx'));
@@ -731,6 +930,144 @@ export class Orchestrator extends EventEmitter {
                 }
             }
             catch { /* skip learning failures */ }
+            // ── v3.0.0: Hyper-Intelligence Enhancements ────────────────────
+            // AST complexity analysis on changed TypeScript files
+            if (tsFiles.length > 0) {
+                try {
+                    for (const f of tsFiles.slice(0, 5)) {
+                        const funcs = this.astAnalyzer.extractFunctionInfo(f.path);
+                        for (const fn of funcs) {
+                            if (fn.cyclomaticComplexity > 10) {
+                                insights.push({
+                                    type: 'warning',
+                                    priority: fn.cyclomaticComplexity > 20 ? 'high' : 'medium',
+                                    title: `[ast] High complexity in ${fn.name}() — cyclomatic: ${fn.cyclomaticComplexity}`,
+                                    content: `Function "${fn.name}" in ${f.path} has cyclomatic complexity of ${fn.cyclomaticComplexity}. ` +
+                                        `Consider breaking it into smaller functions. ` +
+                                        `Parameters: ${fn.params}, Lines: ${fn.endLine - fn.startLine}, Nesting: ${fn.nestingDepth}`,
+                                    files: [f.path],
+                                    timestamp: new Date(),
+                                });
+                            }
+                        }
+                    }
+                }
+                catch { /* skip AST failures */ }
+            }
+            // Accessibility check on changed frontend files
+            const frontendFiles = changes.filter(c => /\.(tsx|jsx|vue|svelte|html)$/.test(c.path) && c.content);
+            if (frontendFiles.length > 0) {
+                try {
+                    for (const f of frontendFiles.slice(0, 5)) {
+                        const a11yIssues = this.a11yChecker.analyzeFile(f.path);
+                        for (const issue of a11yIssues) {
+                            insights.push({
+                                type: 'a11y',
+                                priority: issue.severity === 'critical' ? 'critical' : issue.severity === 'serious' ? 'high' : issue.severity === 'moderate' ? 'medium' : 'low',
+                                title: `[a11y] ${issue.message}`,
+                                content: `${issue.message}\nRule: ${issue.rule} (WCAG ${issue.wcagCriterion} Level ${issue.wcagLevel})\nSuggestion: ${issue.suggestion}`,
+                                files: [f.path],
+                                timestamp: new Date(),
+                            });
+                        }
+                    }
+                }
+                catch { /* skip a11y failures */ }
+            }
+            // i18n detection on frontend files
+            if (frontendFiles.length > 0) {
+                try {
+                    for (const f of frontendFiles.slice(0, 5)) {
+                        const i18nIssues = this.i18nDetector.analyzeFile(f.path, false);
+                        for (const issue of i18nIssues) {
+                            insights.push({
+                                type: 'i18n',
+                                priority: issue.severity === 'high' ? 'high' : 'medium',
+                                title: `[i18n] ${issue.content}`,
+                                content: `${issue.content}\nType: ${issue.type}\nSuggestion: ${issue.suggestion}`,
+                                files: [f.path],
+                                timestamp: new Date(),
+                            });
+                        }
+                    }
+                }
+                catch { /* skip i18n failures */ }
+            }
+            // Env secret scan on changed files
+            try {
+                for (const change of changes.filter(c => c.content).slice(0, 10)) {
+                    const secretPatterns = [
+                        /(?:api[_-]?key|secret|token|password)\s*[:=]\s*["'][^"']{8,}["']/gi,
+                        /(?:mongodb|postgres|mysql|redis):\/\/[^\s"']+/gi,
+                    ];
+                    for (const regex of secretPatterns) {
+                        regex.lastIndex = 0;
+                        if (regex.test(change.content) && !change.content.includes('process.env')) {
+                            insights.push({
+                                type: 'env',
+                                priority: 'critical',
+                                title: `[env] Hardcoded secret in ${change.path}`,
+                                content: 'Never hardcode secrets in source code. Use environment variables or a secret manager.',
+                                files: [change.path],
+                                timestamp: new Date(),
+                                confidence: 0.95,
+                            });
+                        }
+                    }
+                }
+            }
+            catch { /* skip env scan failures */ }
+            // ── v4.0.0: Hyper-Intelligence Enhancements ────────────────────
+            // Knowledge Graph build + PageRank
+            try {
+                if (this.knowledgeGraph) {
+                    await this.knowledgeGraph.build();
+                    const topEntities = this.knowledgeGraph.getTopEntities(10);
+                    const changedPaths = new Set(changes.map(c => c.path));
+                    for (const entity of topEntities) {
+                        const entityFile = entity.file || '';
+                        if (entityFile && changedPaths.has(entityFile)) {
+                            insights.push({
+                                priority: 'medium',
+                                type: 'pattern',
+                                title: `[graph] High-impact entity: ${entity.name}`,
+                                content: `${entity.name} in ${entityFile} has PageRank score ${entity.pageRankScore?.toFixed(3) || 'N/A'} — changes here ripple across the codebase`,
+                                files: [entityFile],
+                                timestamp: new Date(),
+                            });
+                        }
+                    }
+                }
+            }
+            catch { /* knowledge graph is best-effort */ }
+            // Predictive Engine — Bug Risk + Debt Forecast
+            try {
+                const codeAgeFiles = changes.filter(c => c.content).slice(0, 20).map(c => ({
+                    file: c.path,
+                    lastModified: new Date(),
+                    daysSinceModification: 0,
+                    linesChangedRecently: 1,
+                    stalenessScore: 0,
+                    risk: 'fresh',
+                    authors: [],
+                    churnRate: 0,
+                }));
+                const metrics = this.lastMetrics;
+                if (codeAgeFiles.length > 0 && metrics) {
+                    const bugRisks = this.predictiveEngine.scoreBugRisk(codeAgeFiles, metrics);
+                    for (const risk of bugRisks.filter(r => r.riskLevel === 'high' || r.riskLevel === 'critical')) {
+                        insights.push({
+                            priority: (risk.riskLevel === 'critical' ? 'high' : 'medium'),
+                            type: 'warning',
+                            title: `[predict] Bug risk in ${risk.file}: ${risk.riskLevel}`,
+                            content: `Risk factors: ${risk.factors.join(', ')}. Confidence: ${(risk.confidence * 100).toFixed(0)}%`,
+                            files: [risk.file],
+                            timestamp: new Date(),
+                        });
+                    }
+                }
+            }
+            catch { /* predictive engine is best-effort */ }
             for (const insight of insights) {
                 insight.timestamp = new Date();
             }
@@ -755,6 +1092,18 @@ export class Orchestrator extends EventEmitter {
                     this.currentSession.insights = this.currentSession.insights.slice(-100);
                 }
             }
+            // v4.0.0: Swarm pheromone update
+            try {
+                for (const insight of insights) {
+                    const files = insight.files || [];
+                    if (files.length > 0) {
+                        const strength = (insight.priority === 'critical' ? 3 : insight.priority === 'high' ? 2 : 1) * 1.5;
+                        this.swarmIntelligence.depositPheromone(files, strength);
+                    }
+                }
+                this.swarmIntelligence.evaporate();
+            }
+            catch { /* swarm update is best-effort */ }
             this.emit('insights', { insights });
             // ── v2.1.0: Neural Mesh Broadcasting ────────────────────────────
             if (this.neuralMesh && this.neuralMesh.isRunning()) {
@@ -771,6 +1120,22 @@ export class Orchestrator extends EventEmitter {
                     this.neuralMesh.broadcastPattern(insight.title, insight.type);
                 }
             }
+            // v4.0.0: Cross-agent broadcast + self-evolution meta-learning
+            try {
+                const boostPacket = {
+                    insights: insights.slice(0, 3),
+                    healthScore: healthScore.overall,
+                    contextSummary: changes.map(c => c.path).slice(0, 10).join(', '),
+                };
+                await this.crossAgentProtocol.broadcast('claude-code', boostPacket);
+            }
+            catch { /* cross-agent broadcast is best-effort */ }
+            try {
+                for (const insight of insights) {
+                    this.selfEvolution.updateMetaLearning(`${insight.type}:${insight.priority}`, insight.priority !== 'low');
+                }
+            }
+            catch { /* self-evolution is best-effort */ }
         }
         catch (err) {
             this.emit('error', { error: err });
@@ -837,5 +1202,20 @@ export class Orchestrator extends EventEmitter {
         }
         return changes;
     }
+    /** v4.0.0: Simple text-to-vector for TurboMemory compatibility */
+    textToVector(text, dimensions = 64) {
+        const vector = new Array(dimensions).fill(0);
+        const words = text.toLowerCase().split(/\W+/).filter(w => w.length > 2);
+        for (const word of words) {
+            let hash = 0;
+            for (let i = 0; i < word.length; i++) {
+                hash = ((hash << 5) - hash) + word.charCodeAt(i);
+                hash = hash & hash;
+            }
+            vector[Math.abs(hash) % dimensions] += 1;
+        }
+        const max = Math.max(...vector, 1);
+        return vector.map(v => v / max);
+    }
 }
 //# sourceMappingURL=orchestrator.js.map