@theihtisham/agent-shadow-brain 5.0.0 → 5.0.1

package/dist/brain/mcp-server.js

@@ -1,5 +1,6 @@
 // src/brain/mcp-server.ts — JSON-RPC 2.0 MCP server over HTTP
 // Exposes analysis tools via Model Context Protocol
+// v5.0.1 — Infinite Intelligence Edition (Cursor + Claude Code + Kilo Code compatible)
 import * as http from 'http';
 export class MCPServer {
     constructor(orchestrator, options) {
@@ -19,6 +20,18 @@ export class MCPServer {
             semantic: this.handleSemantic.bind(this),
             deps: this.handleDeps.bind(this),
             learn: this.handleLearn.bind(this),
+            memory: this.handleMemory.bind(this),
+            recall: this.handleRecall.bind(this),
+            consensus: this.handleConsensus.bind(this),
+            turbo: this.handleTurbo.bind(this),
+            swarm: this.handleSwarm.bind(this),
+            evolution: this.handleEvolution.bind(this),
+            knowledge_graph: this.handleKnowledgeGraph.bind(this),
+            predict: this.handlePredict.bind(this),
+            ask: this.handleAsk.bind(this),
+            status: this.handleStatus.bind(this),
+            modules: this.handleModules.bind(this),
+            auto_config: this.handleAutoConfig.bind(this),
         };
     }
     async start() {
@@ -28,27 +41,44 @@ export class MCPServer {
                 return;
             }
             const url = new URL(req.url, `http://${req.headers.host}`);
-            // CORS headers
+            // CORS headers — permissive for Cursor, Claude Code, and other AI tools
             res.setHeader('Access-Control-Allow-Origin', '*');
-            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Accept');
+            res.setHeader('Access-Control-Max-Age', '86400');
             if (req.method === 'OPTIONS') {
                 res.writeHead(204);
                 res.end();
                 return;
             }
-            if (req.method === 'POST' && url.pathname === '/mcp') {
+            if (req.method === 'POST' && (url.pathname === '/mcp' || url.pathname === '/')) {
                 await this.handleHTTPMCPRequest(req, res);
             }
             else if (req.method === 'GET' && url.pathname === '/sse') {
                 this.handleSSEConnection(req, res);
             }
+            else if (req.method === 'GET' && url.pathname === '/health') {
+                // Lightweight health endpoint for tool connectivity checks
+                this.sendJSON(res, 200, {
+                    status: 'ok',
+                    version: '5.0.1',
+                    uptime: process.uptime(),
+                    tools: Object.keys(this.toolHandlers).length,
+                });
+            }
+            else if (req.method === 'POST' && url.pathname === '/v1/chat') {
+                // Cursor compatibility — some versions POST to /v1/chat
+                await this.handleHTTPMCPRequest(req, res);
+            }
             else {
                 this.sendJSON(res, 404, {
                     error: 'Not found',
                     endpoints: {
                         'POST /mcp': 'JSON-RPC 2.0 MCP handler',
+                        'POST /': 'JSON-RPC 2.0 MCP handler (root path for Cursor)',
+                        'POST /v1/chat': 'Cursor compatibility endpoint',
                         'GET /sse': 'Server-Sent Events for real-time updates',
+                        'GET /health': 'Health check endpoint',
                     },
                 });
             }
@@ -62,7 +92,6 @@ export class MCPServer {
         });
     }
     async stop() {
-        // Close all SSE clients
         for (const [id, client] of this.sseClients) {
             try {
                 client.res.write('event: close\ndata: {"reason":"server shutting down"}\n\n');
@@ -86,7 +115,6 @@ export class MCPServer {
         }
     }
     async handleRequest(request) {
-        // Validate JSON-RPC version
         if (request.jsonrpc !== '2.0') {
             return this.makeError(request.id, -32600, 'Invalid Request: jsonrpc must be "2.0"');
         }
@@ -95,6 +123,9 @@ export class MCPServer {
             switch (method) {
                 case 'initialize':
                     return this.makeResult(request.id, this.handleInitialize());
+                case 'notifications/initialized':
+                    // Cursor sends this after initialize — acknowledge silently
+                    return this.makeResult(request.id, {});
                 case 'tools/list':
                     return this.makeResult(request.id, { tools: this.getToolDefinitions() });
                 case 'resources/list':
@@ -130,10 +161,12 @@ export class MCPServer {
                 tools: { listChanged: false },
                 resources: { subscribe: false, listChanged: false },
                 prompts: { listChanged: false },
+                logging: {},
             },
             serverInfo: {
                 name: 'agent-shadow-brain',
-                version: '2.0.0',
+                version: '5.0.1',
+                description: 'World\'s #1 AI coding intelligence layer — infinite memory, multi-agent consensus, self-evolving',
             },
         };
     }
@@ -155,7 +188,6 @@ export class MCPServer {
     async handleHealth(params) {
         const healthScore = await this.orchestrator.getHealthScore();
         const currentScore = healthScore.overall;
-        // Broadcast health change via SSE if score changed significantly
         if (this.lastHealthScore !== null && Math.abs(currentScore - this.lastHealthScore) >= 5) {
             this.broadcastSSE('health-change', {
                 previous: this.lastHealthScore,
@@ -206,7 +238,6 @@ export class MCPServer {
     async handleSemantic(params) {
         const maxFiles = params.maxFiles ?? 100;
         const result = await this.orchestrator.getSemanticInsights(maxFiles);
-        // Convert Map to serializable object
         const symbolsObj = {};
         if (result.symbols instanceof Map) {
             for (const [file, syms] of result.symbols) {
@@ -242,6 +273,238 @@ export class MCPServer {
             lessons: lessons,
         };
     }
+    async handleMemory(params) {
+        const action = params.action ?? 'stats';
+        const hm = this.orchestrator.hierarchicalMemory;
+        if (!hm)
+            return { error: 'Hierarchical memory not initialized' };
+        switch (action) {
+            case 'stats':
+                return hm.getStats?.() || { entries: 0 };
+            case 'store': {
+                const { content, category, importance } = params;
+                const id = hm.store?.(content, category, importance ?? 0.5);
+                return { id, stored: true };
+            }
+            case 'retrieve': {
+                const { tier, limit } = params;
+                const entries = hm.getByTier?.(tier) || [];
+                return { entries: entries.slice(0, limit ?? 50) };
+            }
+            case 'search': {
+                const { query, topK } = params;
+                // Use context recall for semantic search
+                const cr = this.orchestrator.contextRecall;
+                if (cr) {
+                    const results = cr.recall({ keywords: query.split(' ') }, topK ?? 10);
+                    return { results };
+                }
+                return { results: [] };
+            }
+            default:
+                return { error: `Unknown memory action: ${action}` };
+        }
+    }
+    async handleRecall(params) {
+        const context = {
+            currentFile: params.file,
+            currentCategory: params.category,
+            projectType: params.projectType,
+            keywords: params.keywords || [],
+        };
+        const cr = this.orchestrator.contextRecall;
+        if (!cr)
+            return { results: [], error: 'Context recall not initialized' };
+        const results = cr.recall(context, params.topK ?? 20);
+        return {
+            count: results.length,
+            results: results.map((r) => ({
+                content: r.entry?.content?.slice(0, 200),
+                relevanceScore: r.relevanceScore,
+                triggers: r.activatedTriggers?.slice(0, 5),
+            })),
+        };
+    }
+    async handleConsensus(params) {
+        const ce = this.orchestrator.consensusEngine;
+        if (!ce)
+            return { error: 'Consensus engine not initialized' };
+        const action = params.action ?? 'stats';
+        switch (action) {
+            case 'stats':
+                return ce.getStats?.() || {};
+            case 'propose': {
+                const id = ce.propose?.(params.content, params.category, params.confidence ?? 0.5, params.evidence || []);
+                return { proposalId: id };
+            }
+            case 'trust':
+                return ce.getTrustScores?.() || [];
+            default:
+                return { error: `Unknown consensus action: ${action}` };
+        }
+    }
+    async handleTurbo(params) {
+        const tm = this.orchestrator.turboMemory;
+        if (!tm)
+            return { error: 'TurboMemory not initialized' };
+        const action = params.action ?? 'stats';
+        switch (action) {
+            case 'stats':
+                return tm.stats?.() || {};
+            case 'search': {
+                const results = tm.search?.(params.query, params.topK ?? 10);
+                return { results: results || [] };
+            }
+            default:
+                return { error: `Unknown turbo action: ${action}` };
+        }
+    }
+    async handleSwarm(params) {
+        const si = this.orchestrator.swarmIntelligence;
+        if (!si)
+            return { error: 'Swarm intelligence not initialized' };
+        const action = params.action ?? 'state';
+        switch (action) {
+            case 'state':
+                return si.getState?.() || {};
+            case 'priorities': {
+                const files = si.getHighPriorityFiles?.(params.count ?? 10);
+                return { files: files || [] };
+            }
+            default:
+                return { error: `Unknown swarm action: ${action}` };
+        }
+    }
+    async handleEvolution(params) {
+        const se = this.orchestrator.selfEvolution;
+        if (!se)
+            return { error: 'Self-evolution not initialized' };
+        const action = params.action ?? 'snapshot';
+        switch (action) {
+            case 'snapshot':
+                return se.getSnapshot?.() || {};
+            case 'best_rules': {
+                const rules = se.getBestRules?.(params.category ?? 'all', params.count ?? 10);
+                return { rules: rules || [] };
+            }
+            default:
+                return { error: `Unknown evolution action: ${action}` };
+        }
+    }
+    async handleKnowledgeGraph(params) {
+        const kg = this.orchestrator.knowledgeGraph;
+        if (!kg)
+            return { error: 'Knowledge graph not initialized' };
+        const action = params.action ?? 'stats';
+        switch (action) {
+            case 'stats':
+                return kg.getStats?.() || {};
+            case 'top_entities': {
+                const entities = kg.getTopEntities?.(params.count ?? 20);
+                return { entities: entities || [] };
+            }
+            default:
+                return { error: `Unknown knowledge graph action: ${action}` };
+        }
+    }
+    async handlePredict(params) {
+        const pe = this.orchestrator.predictiveEngine;
+        if (!pe)
+            return { error: 'Predictive engine not initialized' };
+        return {
+            predictionAvailable: true,
+            note: 'Use the predict CLI command for full bug/debt risk scoring',
+        };
+    }
+    async handleAsk(params) {
+        const query = params.query;
+        if (!query)
+            return { error: 'Missing query parameter' };
+        // Natural language query — combine recall + search
+        const keywords = query.toLowerCase().split(/\s+/).filter(w => w.length > 2);
+        const results = [];
+        // Context recall
+        const cr = this.orchestrator.contextRecall;
+        if (cr) {
+            const recallResults = cr.recall({ keywords }, 10);
+            for (const r of recallResults.slice(0, 5)) {
+                results.push({
+                    source: 'memory',
+                    content: r.entry?.content?.slice(0, 300),
+                    relevance: r.relevanceScore,
+                });
+            }
+        }
+        // Pattern memory
+        const pm = this.orchestrator.patternMemory;
+        if (pm) {
+            const patterns = pm.getPatternInsights?.(keywords.join(' '));
+            if (patterns) {
+                for (const p of patterns.slice(0, 3)) {
+                    results.push({ source: 'pattern', content: p });
+                }
+            }
+        }
+        return {
+            query,
+            resultCount: results.length,
+            results,
+        };
+    }
+    async handleStatus(params) {
+        const status = this.orchestrator.getStatus?.() || {};
+        return {
+            version: '5.0.1',
+            ...status,
+        };
+    }
+    async handleModules(params) {
+        const status = this.orchestrator.getStatus?.() || {};
+        const modules = [];
+        const moduleList = [
+            { key: 'hierarchicalMemory', name: 'Hierarchical Memory' },
+            { key: 'patternMemory', name: 'Pattern Memory' },
+            { key: 'learningEngine', name: 'Learning Engine' },
+            { key: 'neuralMesh', name: 'Neural Mesh' },
+            { key: 'consensusEngine', name: 'Consensus Engine' },
+            { key: 'contextRecall', name: 'Context Recall' },
+            { key: 'turboMemory', name: 'TurboMemory' },
+            { key: 'ssspRouter', name: 'SSSP Router' },
+            { key: 'selfEvolution', name: 'Self Evolution' },
+            { key: 'predictiveEngine', name: 'Predictive Engine' },
+            { key: 'knowledgeGraph', name: 'Knowledge Graph' },
+            { key: 'swarmIntelligence', name: 'Swarm Intelligence' },
+            { key: 'adversarialDefense', name: 'Adversarial Defense' },
+        ];
+        for (const mod of moduleList) {
+            const instance = this.orchestrator[mod.key];
+            modules.push({
+                name: mod.name,
+                version: '5.0.1',
+                status: instance ? 'active' : 'idle',
+            });
+        }
+        return { modules, totalModules: modules.length, activeModules: modules.filter(m => m.status === 'active').length };
+    }
+    async handleAutoConfig(params) {
+        // Trigger auto-detection — useful for MCP tools to discover project info
+        try {
+            const { AutoSetup } = await import('./auto-setup.js');
+            const setup = new AutoSetup(this.orchestrator.config?.projectDir || process.cwd());
+            const result = await setup.detect();
+            return {
+                project: result.projectName,
+                type: result.projectType,
+                languages: result.languages,
+                frameworks: result.frameworks,
+                aiTools: result.aiTools.filter(t => t.detected).map(t => t.name),
+                packageManager: result.packageManager,
+            };
+        }
+        catch {
+            return { error: 'Auto-setup module not available' };
+        }
+    }
     // ── Tool Definitions ───────────────────────────────────────────────────
     getToolDefinitions() {
         return [
@@ -251,66 +514,165 @@ export class MCPServer {
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        maxFiles: {
-                            type: 'number',
-                            description: 'Maximum number of insights to return (default: 50)',
-                        },
+                        maxFiles: { type: 'number', description: 'Maximum number of insights to return (default: 50)' },
                     },
                 },
             },
             {
                 name: 'health',
                 description: 'Get the current project health score with detailed breakdown',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'fixes',
+                description: 'Get smart fix suggestions for current code issues',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'metrics',
+                description: 'Get code metrics: LOC, complexity, language breakdown',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'semantic',
+                description: 'Get semantic analysis: symbols, unused exports, dead code',
                 inputSchema: {
                     type: 'object',
-                    properties: {},
+                    properties: {
+                        maxFiles: { type: 'number', description: 'Maximum files to analyze (default: 100)' },
+                    },
                 },
             },
             {
-                name: 'fixes',
-                description: 'Get smart fix suggestions for current code issues',
+                name: 'deps',
+                description: 'Get dependency graph: imports, cycles, orphans, hubs',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'learn',
+                description: 'Run a learning cycle to extract patterns and lessons from the project',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'memory',
+                description: 'Manage infinite hierarchical memory — store, retrieve, search, stats',
                 inputSchema: {
                     type: 'object',
-                    properties: {},
+                    properties: {
+                        action: { type: 'string', enum: ['stats', 'store', 'retrieve', 'search'], description: 'Action to perform (default: stats)' },
+                        content: { type: 'string', description: 'Content to store (for store action)' },
+                        category: { type: 'string', description: 'Category for storage/retrieval' },
+                        importance: { type: 'number', description: 'Importance 0-1 (for store action)' },
+                        tier: { type: 'string', enum: ['raw', 'summary', 'pattern', 'principle'], description: 'Memory tier to retrieve' },
+                        query: { type: 'string', description: 'Search query (for search action)' },
+                        topK: { type: 'number', description: 'Max results to return' },
+                    },
                 },
             },
             {
-                name: 'metrics',
-                description: 'Get code metrics: LOC, complexity, language breakdown',
+                name: 'recall',
+                description: 'Context-triggered associative recall — activate memories based on current work context',
                 inputSchema: {
                     type: 'object',
-                    properties: {},
+                    properties: {
+                        file: { type: 'string', description: 'Current file being edited' },
+                        category: { type: 'string', description: 'Current work category' },
+                        projectType: { type: 'string', description: 'Project type' },
+                        keywords: { type: 'array', items: { type: 'string' }, description: 'Keywords from current context' },
+                        topK: { type: 'number', description: 'Max results (default: 20)' },
+                    },
                 },
             },
             {
-                name: 'semantic',
-                description: 'Get semantic analysis: symbols, unused exports, dead code',
+                name: 'consensus',
+                description: 'Multi-agent consensus protocol — propose, vote, trust scores',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        maxFiles: {
-                            type: 'number',
-                            description: 'Maximum files to analyze (default: 100)',
-                        },
+                        action: { type: 'string', enum: ['stats', 'propose', 'trust'], description: 'Action (default: stats)' },
+                        content: { type: 'string', description: 'Proposal content (for propose action)' },
+                        category: { type: 'string', description: 'Proposal category' },
+                        confidence: { type: 'number', description: 'Confidence 0-1' },
                     },
                 },
             },
             {
-                name: 'deps',
-                description: 'Get dependency graph: imports, cycles, orphans, hubs',
+                name: 'turbo',
+                description: 'TurboQuant 6x compressed vector memory — stats and semantic search',
                 inputSchema: {
                     type: 'object',
-                    properties: {},
+                    properties: {
+                        action: { type: 'string', enum: ['stats', 'search'], description: 'Action (default: stats)' },
+                        query: { type: 'string', description: 'Search query' },
+                        topK: { type: 'number', description: 'Max results' },
+                    },
                 },
             },
             {
-                name: 'learn',
-                description: 'Run a learning cycle to extract patterns and lessons from the project',
+                name: 'swarm',
+                description: 'Swarm intelligence (Ant Colony) — file prioritization via pheromone trails',
                 inputSchema: {
                     type: 'object',
-                    properties: {},
+                    properties: {
+                        action: { type: 'string', enum: ['state', 'priorities'], description: 'Action (default: state)' },
+                        count: { type: 'number', description: 'Number of priority files (default: 10)' },
+                    },
+                },
+            },
+            {
+                name: 'evolution',
+                description: 'Self-evolving genetic rules — view evolution snapshot and best rules',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        action: { type: 'string', enum: ['snapshot', 'best_rules'], description: 'Action (default: snapshot)' },
+                        category: { type: 'string', description: 'Category for best rules' },
+                        count: { type: 'number', description: 'Number of rules to return' },
+                    },
+                },
+            },
+            {
+                name: 'knowledge_graph',
+                description: 'Knowledge graph with PageRank — code entity importance and relationships',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        action: { type: 'string', enum: ['stats', 'top_entities'], description: 'Action (default: stats)' },
+                        count: { type: 'number', description: 'Number of entities to return' },
+                    },
                 },
             },
+            {
+                name: 'predict',
+                description: 'Predictive bug forecasting — check bug risk and debt predictions',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'ask',
+                description: 'Natural language query — ask the brain anything about the project',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Natural language question about the project' },
+                    },
+                    required: ['query'],
+                },
+            },
+            {
+                name: 'status',
+                description: 'Get full Shadow Brain status — version, modules, health, stats',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'modules',
+                description: 'List all brain modules with their activation status',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'auto_config',
+                description: 'Auto-detect project configuration — languages, frameworks, AI tools',
+                inputSchema: { type: 'object', properties: {} },
+            },
         ];
     }
     // ── HTTP Handling ──────────────────────────────────────────────────────
@@ -328,7 +690,6 @@ export class MCPServer {
             });
             return;
         }
-        // Support batch requests
         if (Array.isArray(parsed)) {
             const results = await Promise.all(parsed.map((r) => this.handleRequest(r)));
             this.sendJSON(res, 200, results);
@@ -345,11 +706,9 @@ export class MCPServer {
             Connection: 'keep-alive',
             'Access-Control-Allow-Origin': '*',
         });
-        // Send initial connection event
-        res.write(`event: connected\ndata: {"clientId":"${clientId}"}\n\n`);
+        res.write(`event: connected\ndata: {"clientId":"${clientId}","version":"5.0.1"}\n\n`);
         const client = { res, id: clientId };
         this.sseClients.set(clientId, client);
-        // Handle client disconnect
         req.on('close', () => {
             this.sseClients.delete(clientId);
         });
@@ -374,7 +733,7 @@ export class MCPServer {
         return new Promise((resolve, reject) => {
             const chunks = [];
             let size = 0;
-            const maxSize = 10 * 1024 * 1024; // 10 MB limit
+            const maxSize = 10 * 1024 * 1024;
             req.on('data', (chunk) => {
                 size += chunk.length;
                 if (size > maxSize) {