@timmeck/brain 1.2.0 → 1.8.0

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);

package/src/services/code.service.ts

@@ -6,7 +6,7 @@ import { analyzeCode } from '../code/analyzer.js';
 import { fingerprintCode } from '../code/fingerprint.js';
 import { computeReusabilityScore } from '../code/scorer.js';
 import { detectGranularity } from '../code/registry.js';
-import { findExactMatches, findSemanticMatches } from '../code/matcher.js';
+import { findExactMatches, findSemanticMatches, findStructuralMatches } from '../code/matcher.js';
 import { sha256 } from '../utils/hash.js';
 import { getEventBus } from '../utils/events.js';
 import { getLogger } from '../utils/logger.js';
@@ -53,27 +53,59 @@ export class CodeService {
     // Check if module already exists (by fingerprint)
     const existing = this.codeModuleRepo.findByFingerprint(fingerprint);
     if (existing) {
+      // Source Hash Change Detection: compare hash to decide if re-analysis needed
+      if (existing.source_hash === sourceHash) {
+        // Unchanged — skip re-analysis
+        this.logger.debug(`Module ${existing.name} unchanged (hash match), skipping`);
+        this.synapseManager.strengthen(
+          { type: 'code_module', id: existing.id },
+          { type: 'project', id: project.id },
+          'uses_module',
+        );
+        return { moduleId: existing.id, isNew: false, reusabilityScore: existing.reusability_score };
+      }
+
+      // Hash changed — re-analyze
+      this.logger.info(`Module ${existing.name} changed (hash drift), re-analyzing`);
+      const reScore = computeReusabilityScore({
+        source: input.source,
+        filePath: input.filePath,
+        exports: analysis.exports,
+        internalDeps: analysis.internalDeps,
+        hasTypeAnnotations: analysis.hasTypeAnnotations,
+        complexity: analysis.complexity,
+      });
+
       this.codeModuleRepo.update(existing.id, {
         source_hash: sourceHash,
+        lines_of_code: analysis.linesOfCode,
+        complexity: analysis.complexity,
+        reusability_score: reScore,
         updated_at: new Date().toISOString(),
       });
 
+      // Re-index dependency synapses on change
+      this.indexDependencySynapses(existing.id, analysis.internalDeps, project.id);
+
       this.synapseManager.strengthen(
         { type: 'code_module', id: existing.id },
         { type: 'project', id: project.id },
         'uses_module',
       );
 
-      return { moduleId: existing.id, isNew: false, reusabilityScore: existing.reusability_score };
+      this.eventBus.emit('module:updated', { moduleId: existing.id });
+
+      return { moduleId: existing.id, isNew: false, reusabilityScore: reScore };
     }
 
-    // Compute reusability score
+    // Compute reusability score (with complexity)
     const reusabilityScore = computeReusabilityScore({
       source: input.source,
       filePath: input.filePath,
       exports: analysis.exports,
       internalDeps: analysis.internalDeps,
       hasTypeAnnotations: analysis.hasTypeAnnotations,
+      complexity: analysis.complexity,
     });
 
     const granularity = detectGranularity(input.source, input.language);
@@ -87,7 +119,7 @@ export class CodeService {
       description: input.description ?? null,
       source_hash: sourceHash,
       lines_of_code: analysis.linesOfCode,
-      complexity: null,
+      complexity: analysis.complexity,
       reusability_score: reusabilityScore,
     });
 
@@ -98,6 +130,12 @@ export class CodeService {
       'uses_module',
     );
 
+    // Create dependency synapses for internal imports
+    this.indexDependencySynapses(moduleId, analysis.internalDeps, project.id);
+
+    // Compute and store pairwise module similarities
+    this.computeModuleSimilarities(moduleId, input.source, input.language);
+
     this.eventBus.emit('module:registered', { moduleId, projectId: project.id });
     this.logger.info(`Code module registered (id=${moduleId}, name=${input.name}, granularity=${granularity}, score=${reusabilityScore.toFixed(2)})`);
 
@@ -141,6 +179,51 @@ export class CodeService {
     return this.codeModuleRepo.getById(id);
   }
 
+  private computeModuleSimilarities(moduleId: number, source: string, language: string): void {
+    const allModules = this.codeModuleRepo.findByLanguage(language, 100);
+    const candidates = allModules.filter(m => m.id !== moduleId);
+    if (candidates.length === 0) return;
+
+    const matches = findStructuralMatches(source, language, candidates, 0.3);
+
+    for (const match of matches) {
+      if (match.score >= 0.3 && match.moduleId !== moduleId) {
+        this.codeModuleRepo.upsertSimilarity(moduleId, match.moduleId, match.score);
+
+        // High similarity → create synapse
+        if (match.score >= 0.7) {
+          this.synapseManager.strengthen(
+            { type: 'code_module', id: moduleId },
+            { type: 'code_module', id: match.moduleId },
+            'similar_to',
+          );
+        }
+      }
+    }
+  }
+
+  private indexDependencySynapses(moduleId: number, internalDeps: string[], projectId: number): void {
+    const projectModules = this.codeModuleRepo.findByProject(projectId);
+
+    for (const dep of internalDeps) {
+      // Normalize the dep path to match against registered modules
+      const depName = dep.replace(/^\.\//, '').replace(/\.\w+$/, '');
+
+      const target = projectModules.find(m => {
+        const modulePath = m.file_path.replace(/\\/g, '/').replace(/\.\w+$/, '');
+        return modulePath.endsWith(depName) || m.name === depName;
+      });
+
+      if (target && target.id !== moduleId) {
+        this.synapseManager.strengthen(
+          { type: 'code_module', id: moduleId },
+          { type: 'code_module', id: target.id },
+          'depends_on',
+        );
+      }
+    }
+  }
+
   listProjects(): Array<{ id: number; name: string; path: string | null; language: string | null; framework: string | null; moduleCount: number }> {
     const projects = this.projectRepo.getAll();
     return projects.map(p => ({