@timmeck/brain 1.1.1 → 1.8.0

package/src/matching/error-matcher.ts

@@ -21,7 +21,8 @@ interface MatchSignal {
   compute: (a: ErrorRecord, b: ErrorRecord) => number;
 }
 
-const SIGNALS: MatchSignal[] = [
+// Base signals (used when vector search is NOT available)
+const SIGNALS_BASE: MatchSignal[] = [
   { name: 'fingerprint', weight: 0.30, compute: fingerprintMatch },
   { name: 'message_similarity', weight: 0.20, compute: messageSimilarity },
   { name: 'type_match', weight: 0.15, compute: typeMatch },
@@ -30,16 +31,41 @@ const SIGNALS: MatchSignal[] = [
   { name: 'context_similarity', weight: 0.10, compute: contextSimilarity },
 ];
 
+// Hybrid signals (used when vector search IS available — vector gets 20% weight)
+const SIGNALS_HYBRID: MatchSignal[] = [
+  { name: 'fingerprint', weight: 0.25, compute: fingerprintMatch },
+  { name: 'message_similarity', weight: 0.15, compute: messageSimilarity },
+  { name: 'type_match', weight: 0.12, compute: typeMatch },
+  { name: 'stack_similarity', weight: 0.12, compute: stackSimilarity },
+  { name: 'file_similarity', weight: 0.08, compute: fileSimilarity },
+  { name: 'context_similarity', weight: 0.08, compute: contextSimilarity },
+];
+
+const VECTOR_WEIGHT = 0.20;
 const MATCH_THRESHOLD = 0.70;
 const STRONG_MATCH_THRESHOLD = 0.90;
 
+/**
+ * Hybrid error matching: TF-IDF signals + optional vector similarity + synapse boost.
+ *
+ * @param incoming - The error to match
+ * @param candidates - Candidate errors to compare against
+ * @param vectorScores - Pre-computed vector similarity scores (errorId → score)
+ * @param synapseScores - Pre-computed synapse proximity scores (errorId → score)
+ */
 export function matchError(
   incoming: ErrorRecord,
   candidates: ErrorRecord[],
+  vectorScores?: Map<number, number>,
+  synapseScores?: Map<number, number>,
 ): MatchResult[] {
+  const useHybrid = vectorScores && vectorScores.size > 0;
+  const useSynapse = synapseScores && synapseScores.size > 0;
+  const signals = useHybrid ? SIGNALS_HYBRID : SIGNALS_BASE;
+
   return candidates
     .map(candidate => {
-      const signals = SIGNALS.map(signal => {
+      const signalResults = signals.map(signal => {
         const score = signal.compute(incoming, candidate);
         return {
           signal: signal.name,
@@ -48,12 +74,37 @@ export function matchError(
         };
       });
 
-      const totalScore = signals.reduce((sum, s) => sum + s.weighted, 0);
+      // Add vector similarity signal (if available)
+      if (useHybrid) {
+        const vectorScore = vectorScores.get(candidate.id) ?? 0;
+        signalResults.push({
+          signal: 'vector_similarity',
+          score: vectorScore,
+          weighted: vectorScore * VECTOR_WEIGHT,
+        });
+      }
+
+      let totalScore = signalResults.reduce((sum, s) => sum + s.weighted, 0);
+
+      // Synapse boost: if errors are already connected in the synapse network,
+      // give up to 5% bonus (doesn't create false positives, only reinforces)
+      if (useSynapse) {
+        const synapseScore = synapseScores.get(candidate.id) ?? 0;
+        if (synapseScore > 0) {
+          const bonus = Math.min(synapseScore * 0.05, 0.05);
+          totalScore = Math.min(1.0, totalScore + bonus);
+          signalResults.push({
+            signal: 'synapse_boost',
+            score: synapseScore,
+            weighted: bonus,
+          });
+        }
+      }
 
       return {
         errorId: candidate.id,
         score: totalScore,
-        signals,
+        signals: signalResults,
         isStrong: totalScore >= STRONG_MATCH_THRESHOLD,
       };
     })

package/src/mcp/http-server.ts

@@ -0,0 +1,137 @@
+import http from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { getLogger } from '../utils/logger.js';
+import type { IpcRouter } from '../ipc/router.js';
+import { registerToolsDirect } from './tools.js';
+
+export class McpHttpServer {
+  private server: http.Server | null = null;
+  private transports = new Map<string, SSEServerTransport>();
+  private logger = getLogger();
+
+  constructor(
+    private port: number,
+    private router: IpcRouter,
+  ) {}
+
+  start(): void {
+    this.server = http.createServer((req, res) => {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+
+      const url = new URL(req.url ?? '/', `http://localhost:${this.port}`);
+
+      if (url.pathname === '/sse' && req.method === 'GET') {
+        this.handleSSE(res);
+        return;
+      }
+
+      if (url.pathname === '/messages' && req.method === 'POST') {
+        this.handleMessage(req, res, url);
+        return;
+      }
+
+      if (url.pathname === '/' && req.method === 'GET') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          name: 'brain',
+          version: '1.7.0',
+          protocol: 'MCP',
+          transport: 'sse',
+          endpoints: {
+            sse: '/sse',
+            messages: '/messages',
+          },
+          clients: this.transports.size,
+        }));
+        return;
+      }
+
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not Found');
+    });
+
+    this.server.listen(this.port, () => {
+      this.logger.info(`MCP HTTP server (SSE) started on http://localhost:${this.port}`);
+    });
+  }
+
+  stop(): void {
+    this.transports.clear();
+    this.server?.close();
+    this.server = null;
+    this.logger.info('MCP HTTP server stopped');
+  }
+
+  getClientCount(): number {
+    return this.transports.size;
+  }
+
+  private async handleSSE(res: http.ServerResponse): Promise<void> {
+    try {
+      const transport = new SSEServerTransport('/messages', res);
+      const sessionId = transport.sessionId ?? randomUUID();
+      this.transports.set(sessionId, transport);
+
+      const server = new McpServer({
+        name: 'brain',
+        version: '1.7.0',
+      });
+
+      registerToolsDirect(server, this.router);
+
+      res.on('close', () => {
+        this.transports.delete(sessionId);
+        this.logger.debug(`MCP SSE client disconnected: ${sessionId}`);
+      });
+
+      await server.connect(transport);
+      this.logger.info(`MCP SSE client connected: ${sessionId}`);
+    } catch (err) {
+      this.logger.error('MCP SSE connection error:', err);
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end('Internal Server Error');
+      }
+    }
+  }
+
+  private async handleMessage(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    url: URL,
+  ): Promise<void> {
+    try {
+      const sessionId = url.searchParams.get('sessionId');
+      if (!sessionId) {
+        res.writeHead(400, { 'Content-Type': 'text/plain' });
+        res.end('Missing sessionId parameter');
+        return;
+      }
+
+      const transport = this.transports.get(sessionId);
+      if (!transport) {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Session not found. Connect to /sse first.');
+        return;
+      }
+
+      await transport.handlePostMessage(req, res);
+    } catch (err) {
+      this.logger.error('MCP message error:', err);
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end('Internal Server Error');
+      }
+    }
+  }
+}

package/src/mcp/tools.ts

@@ -1,16 +1,29 @@
 import { z } from 'zod';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { IpcClient } from '../ipc/client.js';
+import type { IpcRouter } from '../ipc/router.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AnyResult = any;
 
+type BrainCall = (method: string, params?: unknown) => Promise<unknown> | unknown;
+
 function textResult(data: unknown): { content: Array<{ type: 'text'; text: string }> } {
   const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
   return { content: [{ type: 'text' as const, text }] };
 }
 
+/** Register tools using IPC client (for stdio MCP transport) */
 export function registerTools(server: McpServer, ipc: IpcClient): void {
+  registerToolsWithCaller(server, (method, params) => ipc.request(method, params));
+}
+
+/** Register tools using router directly (for HTTP MCP transport inside daemon) */
+export function registerToolsDirect(server: McpServer, router: IpcRouter): void {
+  registerToolsWithCaller(server, (method, params) => router.handle(method, params));
+}
+
+function registerToolsWithCaller(server: McpServer, call: BrainCall): void {
 
   // === Error Brain Tools ===
 
@@ -25,16 +38,23 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       project: z.string().optional().describe('Project name'),
     },
     async (params) => {
-      const result: AnyResult = await ipc.request('error.report', {
+      const result: AnyResult = await call('error.report', {
         project: params.project ?? 'default',
         errorOutput: params.error_output,
         filePath: params.working_directory,
+        taskContext: params.task_context,
+        workingDirectory: params.working_directory,
+        command: params.command,
       });
       let response = `Error #${result.errorId} recorded (${result.isNew ? 'new' : 'seen before'}).`;
       if (result.matches?.length > 0) {
         const best = result.matches[0];
         response += `\nSimilar error found (#${best.errorId}, ${Math.round(best.score * 100)}% match).`;
       }
+      if (result.crossProjectMatches?.length > 0) {
+        const best = result.crossProjectMatches[0];
+        response += `\nCross-project match found (#${best.errorId}, ${Math.round(best.score * 100)}% match from another project).`;
+      }
       return textResult(response);
     },
   );
@@ -47,7 +67,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       project_only: z.boolean().optional().describe('Only search in current project'),
     },
     async (params) => {
-      const results: AnyResult = await ipc.request('error.query', {
+      const results: AnyResult = await call('error.query', {
         search: params.query,
       });
       if (!results?.length) return textResult('No matching errors found.');
@@ -68,7 +88,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       code_change: z.string().optional().describe('Code changes or diff'),
     },
     async (params) => {
-      const solutionId: AnyResult = await ipc.request('solution.report', {
+      const solutionId: AnyResult = await call('solution.report', {
         errorId: params.error_id,
         description: params.description,
         commands: params.commands,
@@ -88,7 +108,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       output: z.string().optional().describe('Output of the failed attempt'),
     },
     async (params) => {
-      await ipc.request('solution.rate', {
+      await call('solution.rate', {
         errorId: params.error_id,
         solutionId: params.solution_id,
         success: false,
@@ -108,7 +128,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       language: z.string().optional().describe('Programming language'),
     },
     async (params) => {
-      const results: AnyResult = await ipc.request('code.find', {
+      const results: AnyResult = await call('code.find', {
         query: params.purpose,
         language: params.language,
       });
@@ -132,7 +152,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       description: z.string().optional().describe('What this code does'),
     },
     async (params) => {
-      const result: AnyResult = await ipc.request('code.analyze', {
+      const result: AnyResult = await call('code.analyze', {
         project: params.project ?? 'default',
         name: params.name ?? params.file_path.split('/').pop() ?? 'unknown',
         filePath: params.file_path,
@@ -153,7 +173,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       file_path: z.string().optional().describe('File path for context'),
     },
     async (params) => {
-      const results: AnyResult = await ipc.request('code.similarity', {
+      const results: AnyResult = await call('code.similarity', {
         source: params.source_code,
         language: params.language ?? detectLanguage(params.file_path ?? ''),
       });
@@ -176,7 +196,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       max_depth: z.number().optional().describe('How many hops to follow (default: 3)'),
     },
     async (params) => {
-      const context: AnyResult = await ipc.request('synapse.context', {
+      const context: AnyResult = await call('synapse.context', {
         errorId: params.node_id,
       });
       const sections: string[] = [];
@@ -199,7 +219,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       to_id: z.number().describe('Target ID'),
     },
     async (params) => {
-      const path: AnyResult = await ipc.request('synapse.path', params);
+      const path: AnyResult = await call('synapse.path', params);
       if (!path) return textResult('No connection found between these nodes.');
       return textResult(path);
     },
@@ -215,7 +235,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       priority: z.string().optional().describe('Minimum priority: low, medium, high, critical'),
     },
     async (params) => {
-      const insights: AnyResult = await ipc.request('research.insights', {
+      const insights: AnyResult = await call('research.insights', {
         type: params.type,
         activeOnly: true,
         limit: 20,
@@ -228,6 +248,24 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
     },
   );
 
+  server.tool(
+    'brain_rate_insight',
+    'Rate an insight as useful or not useful. Helps Brain learn what insights matter.',
+    {
+      insight_id: z.number().describe('The insight ID to rate'),
+      rating: z.number().describe('Rating: 1 (useful), 0 (neutral), -1 (not useful)'),
+      comment: z.string().optional().describe('Optional feedback comment'),
+    },
+    async (params) => {
+      const success: AnyResult = await call('insight.rate', {
+        id: params.insight_id,
+        rating: params.rating,
+        comment: params.comment,
+      });
+      return textResult(success ? `Insight #${params.insight_id} rated.` : `Insight #${params.insight_id} not found.`);
+    },
+  );
+
   server.tool(
     'brain_suggest',
     'Ask Brain for suggestions: what to build next, what to improve, what patterns to extract.',
@@ -235,7 +273,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
       context: z.string().describe('Current context or question'),
     },
     async (params) => {
-      const suggestions: AnyResult = await ipc.request('research.suggest', {
+      const suggestions: AnyResult = await call('research.suggest', {
         context: params.context,
       });
       return textResult(suggestions);
@@ -249,8 +287,8 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
     'Get current Brain status: errors, solutions, code modules, synapse network, insights.',
     {},
     async () => {
-      const summary: AnyResult = await ipc.request('analytics.summary', {});
-      const network: AnyResult = await ipc.request('synapse.stats', {});
+      const summary: AnyResult = await call('analytics.summary', {});
+      const network: AnyResult = await call('synapse.stats', {});
       const lines = [
         `Errors: ${summary.errors?.total ?? 0} total, ${summary.errors?.unresolved ?? 0} unresolved`,
         `Solutions: ${summary.solutions?.total ?? 0}`,
@@ -268,7 +306,7 @@ export function registerTools(server: McpServer, ipc: IpcClient): void {
     'Get pending notifications (new solutions, recurring errors, research insights).',
     {},
     async () => {
-      const notifications: AnyResult = await ipc.request('notification.list', {});
+      const notifications: AnyResult = await call('notification.list', {});
       if (!notifications?.length) return textResult('No pending notifications.');
       const lines = notifications.map((n: AnyResult) =>
         `[${n.type}] ${n.title}: ${n.message?.slice(0, 120)}`

package/src/services/analytics.service.ts

@@ -1,3 +1,4 @@
+import type { ErrorRecord } from '../types/error.types.js';
 import type { ErrorRepository } from '../db/repositories/error.repository.js';
 import type { SolutionRepository } from '../db/repositories/solution.repository.js';
 import type { CodeModuleRepository } from '../db/repositories/code-module.repository.js';
@@ -14,6 +15,7 @@ export interface ProjectSummary {
   antipatterns: { total: number };
   modules: { total: number };
   insights: { active: number };
+  healthScore?: number;
 }
 
 export interface NetworkOverview {
@@ -69,6 +71,140 @@ export class AnalyticsService {
     };
   }
 
+  computeHealthScore(projectId?: number): number {
+    const summary = this.getSummary(projectId);
+    const networkStats = this.synapseManager.getNetworkStats();
+
+    let score = 0;
+    let maxScore = 0;
+
+    // Data Volume (30 points)
+    maxScore += 30;
+    const dataVolume = summary.errors.total + (summary.modules.total * 2) + summary.solutions.total;
+    score += Math.min(30, dataVolume * 0.3);
+
+    // Synapse Density (20 points) - more connections = richer network
+    maxScore += 20;
+    const synapseDensity = networkStats.totalSynapses / Math.max(1, networkStats.totalNodes);
+    score += Math.min(20, synapseDensity * 5);
+
+    // Solution Coverage (20 points) - resolved errors vs total
+    maxScore += 20;
+    if (summary.errors.total > 0) {
+      const resolvedRate = 1 - (summary.errors.unresolved / summary.errors.total);
+      score += resolvedRate * 20;
+    } else {
+      score += 10; // No errors = neutral
+    }
+
+    // Learning Activity (15 points) - active rules + insights
+    maxScore += 15;
+    const learningActivity = summary.rules.active + summary.insights.active;
+    score += Math.min(15, learningActivity * 1.5);
+
+    // Error Trend (15 points) - fewer recent errors = better
+    maxScore += 15;
+    if (summary.errors.total > 0) {
+      const recentRatio = summary.errors.last7d / Math.max(1, summary.errors.total);
+      // Low recent ratio = health is good (errors decreasing)
+      score += Math.max(0, 15 - recentRatio * 30);
+    } else {
+      score += 15;
+    }
+
+    return Math.round((score / maxScore) * 100);
+  }
+
+  getTimeSeries(projectId?: number, days: number = 30): Array<{ date: string; errors: number; solutions: number }> {
+    const series: Array<{ date: string; errors: number; solutions: number }> = [];
+
+    for (let i = days - 1; i >= 0; i--) {
+      const dayStart = new Date(Date.now() - (i + 1) * 86400000).toISOString();
+      const dayEnd = new Date(Date.now() - i * 86400000).toISOString();
+
+      const errorsInDay = this.errorRepo.countSince(dayStart, projectId) - this.errorRepo.countSince(dayEnd, projectId);
+
+      series.push({
+        date: dayStart.split('T')[0]!,
+        errors: Math.max(0, errorsInDay),
+        solutions: 0, // Approximation
+      });
+    }
+
+    return series;
+  }
+
+  explainError(errorId: number): {
+    error: ErrorRecord | undefined;
+    solutions: Array<{ id: number; description: string; confidence: number; successRate: number }>;
+    chain: { parents: ErrorRecord[]; children: ErrorRecord[] };
+    relatedErrors: Array<{ id: number; type: string; message: string; similarity: number }>;
+    rules: Array<{ id: number; pattern: string; action: string; confidence: number }>;
+    insights: Array<{ id: number; type: string; title: string }>;
+    synapseConnections: number;
+  } {
+    const error = this.errorRepo.getById(errorId);
+    if (!error) {
+      return {
+        error: undefined, solutions: [], chain: { parents: [], children: [] },
+        relatedErrors: [], rules: [], insights: [], synapseConnections: 0,
+      };
+    }
+
+    // Solutions
+    const solutions = this.solutionRepo.findForError(errorId).map(s => ({
+      id: s.id,
+      description: s.description,
+      confidence: s.confidence,
+      successRate: this.solutionRepo.successRate(s.id),
+    }));
+
+    // Error chain
+    const parents = this.errorRepo.findChainParents(errorId);
+    const children = this.errorRepo.findChainChildren(errorId);
+
+    // Related via synapses
+    const context = this.synapseManager.getErrorContext(errorId);
+    const relatedErrors = context.relatedErrors.map(r => {
+      const e = this.errorRepo.getById(r.node.id);
+      return {
+        id: r.node.id,
+        type: e?.type ?? 'unknown',
+        message: e?.message ?? '',
+        similarity: r.activation,
+      };
+    });
+
+    // Prevention rules
+    const matchedRules = this.ruleRepo.findActive(error.project_id);
+    const rules = matchedRules
+      .filter(r => {
+        try { return new RegExp(r.pattern, 'i').test(`${error.type}: ${error.message}`); }
+        catch { return false; }
+      })
+      .map(r => ({ id: r.id, pattern: r.pattern, action: r.action, confidence: r.confidence }));
+
+    // Related insights
+    const insights = context.insights.map(i => ({
+      id: i.node.id,
+      type: i.node.type,
+      title: `Insight #${i.node.id}`,
+    }));
+
+    // Total synapse connections
+    const allConnections = this.synapseManager.activate({ type: 'error', id: errorId });
+
+    return {
+      error,
+      solutions,
+      chain: { parents, children },
+      relatedErrors,
+      rules,
+      insights,
+      synapseConnections: allConnections.length,
+    };
+  }
+
   getNetworkOverview(limit: number = 10): NetworkOverview {
     const stats = this.synapseManager.getNetworkStats();
     const strongest = this.synapseManager.getStrongestSynapses(limit);