@timmeck/brain 1.0.0

package/src/matching/error-matcher.ts

@@ -0,0 +1,115 @@
+import type { ErrorRecord } from '../types/error.types.js';
+import { tokenize } from './tokenizer.js';
+import { cosineSimilarity, jaccardSimilarity, levenshteinDistance } from './similarity.js';
+
+export interface SignalScore {
+  signal: string;
+  score: number;
+  weighted: number;
+}
+
+export interface MatchResult {
+  errorId: number;
+  score: number;
+  signals: SignalScore[];
+  isStrong: boolean;
+}
+
+interface MatchSignal {
+  name: string;
+  weight: number;
+  compute: (a: ErrorRecord, b: ErrorRecord) => number;
+}
+
+const SIGNALS: MatchSignal[] = [
+  { name: 'fingerprint', weight: 0.30, compute: fingerprintMatch },
+  { name: 'message_similarity', weight: 0.20, compute: messageSimilarity },
+  { name: 'type_match', weight: 0.15, compute: typeMatch },
+  { name: 'stack_similarity', weight: 0.15, compute: stackSimilarity },
+  { name: 'file_similarity', weight: 0.10, compute: fileSimilarity },
+  { name: 'context_similarity', weight: 0.10, compute: contextSimilarity },
+];
+
+const MATCH_THRESHOLD = 0.70;
+const STRONG_MATCH_THRESHOLD = 0.90;
+
+export function matchError(
+  incoming: ErrorRecord,
+  candidates: ErrorRecord[],
+): MatchResult[] {
+  return candidates
+    .map(candidate => {
+      const signals = SIGNALS.map(signal => {
+        const score = signal.compute(incoming, candidate);
+        return {
+          signal: signal.name,
+          score,
+          weighted: score * signal.weight,
+        };
+      });
+
+      const totalScore = signals.reduce((sum, s) => sum + s.weighted, 0);
+
+      return {
+        errorId: candidate.id,
+        score: totalScore,
+        signals,
+        isStrong: totalScore >= STRONG_MATCH_THRESHOLD,
+      };
+    })
+    .filter(result => result.score >= MATCH_THRESHOLD)
+    .sort((a, b) => b.score - a.score);
+}
+
+function fingerprintMatch(a: ErrorRecord, b: ErrorRecord): number {
+  return a.fingerprint === b.fingerprint ? 1.0 : 0.0;
+}
+
+function messageSimilarity(a: ErrorRecord, b: ErrorRecord): number {
+  const tokensA = tokenize(a.message);
+  const tokensB = tokenize(b.message);
+  return cosineSimilarity(tokensA, tokensB);
+}
+
+function typeMatch(a: ErrorRecord, b: ErrorRecord): number {
+  return a.type === b.type ? 1.0 : 0.0;
+}
+
+function stackSimilarity(a: ErrorRecord, b: ErrorRecord): number {
+  const rawA = a.raw_output ?? '';
+  const rawB = b.raw_output ?? '';
+
+  const frameRe = /at (?:(.+?) )?\(/g;
+  const extractFuncs = (raw: string) => {
+    const funcs: string[] = [];
+    let m: RegExpExecArray | null;
+    const re = new RegExp(frameRe.source, 'g');
+    while ((m = re.exec(raw)) !== null) {
+      if (m[1]) funcs.push(m[1]);
+    }
+    return funcs;
+  };
+
+  const funcsA = extractFuncs(rawA);
+  const funcsB = extractFuncs(rawB);
+
+  if (funcsA.length === 0 && funcsB.length === 0) return 0.5;
+  return jaccardSimilarity(funcsA, funcsB);
+}
+
+function fileSimilarity(a: ErrorRecord, b: ErrorRecord): number {
+  const pathA = a.file_path ?? '';
+  const pathB = b.file_path ?? '';
+  if (!pathA || !pathB) return 0.0;
+  if (pathA === pathB) return 1.0;
+  return levenshteinDistance(pathA, pathB);
+}
+
+function contextSimilarity(a: ErrorRecord, b: ErrorRecord): number {
+  const ctxA = a.context ?? '';
+  const ctxB = b.context ?? '';
+  if (!ctxA || !ctxB) return 0.0;
+  const tokensA = tokenize(ctxA);
+  const tokensB = tokenize(ctxB);
+  return cosineSimilarity(tokensA, tokensB);
+}

package/src/matching/fingerprint.ts

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { sha256 } from '../utils/hash.js';
+import type { StackFrame } from '../parsing/types.js';
+
+export function templateMessage(msg: string): string {
+  return msg
+    .replace(/[A-Z]:\\[\w\-.\\ ]+\.\w+/g, '<PATH>')
+    .replace(/\/[\w\-./ ]+\.\w+/g, '<PATH>')
+    .replace(/:(\d+):(\d+)/g, ':<LINE>:<COL>')
+    .replace(/line \d+/gi, 'line <LINE>')
+    .replace(/0x[0-9a-fA-F]+/g, '<ADDR>')
+    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<UUID>')
+    .replace(/https?:\/\/[^\s]+/g, '<URL>')
+    .replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}/g, '<TIMESTAMP>');
+}
+
+export function generateFingerprint(
+  errorType: string,
+  message: string,
+  frames: StackFrame[],
+): string {
+  const template = templateMessage(message);
+  const topFrames = frames
+    .slice(0, 3)
+    .map(f => `${f.function_name || '<anon>'}@${path.basename(f.file_path || '<unknown>')}`)
+    .join('|');
+  const input = `${errorType}::${template}::${topFrames}`;
+  return sha256(input);
+}

package/src/matching/similarity.ts

@@ -0,0 +1,61 @@
+export function levenshteinDistance(a: string, b: string): number {
+  if (a === b) return 1.0;
+  if (a.length === 0 || b.length === 0) return 0.0;
+
+  const dp: number[][] = Array(b.length + 1)
+    .fill(0)
+    .map(() => Array(a.length + 1).fill(0) as number[]);
+
+  for (let i = 0; i <= a.length; i++) dp[0]![i] = i;
+  for (let j = 0; j <= b.length; j++) dp[j]![0] = j;
+
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      const cost = a[j - 1] === b[i - 1] ? 0 : 1;
+      dp[i]![j] = Math.min(
+        dp[i - 1]![j]! + 1,
+        dp[i]![j - 1]! + 1,
+        dp[i - 1]![j - 1]! + cost,
+      );
+    }
+  }
+
+  return 1 - dp[b.length]![a.length]! / Math.max(a.length, b.length);
+}
+
+export function cosineSimilarity(tokensA: string[], tokensB: string[]): number {
+  if (tokensA.length === 0 || tokensB.length === 0) return 0.0;
+
+  const vocab = new Set([...tokensA, ...tokensB]);
+  const vecA = new Map<string, number>();
+  const vecB = new Map<string, number>();
+
+  for (const t of tokensA) vecA.set(t, (vecA.get(t) ?? 0) + 1);
+  for (const t of tokensB) vecB.set(t, (vecB.get(t) ?? 0) + 1);
+
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+
+  for (const word of vocab) {
+    const a = vecA.get(word) ?? 0;
+    const b = vecB.get(word) ?? 0;
+    dot += a * b;
+    magA += a * a;
+    magB += b * b;
+  }
+
+  const denom = Math.sqrt(magA) * Math.sqrt(magB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+export function jaccardSimilarity(tokensA: string[], tokensB: string[]): number {
+  if (tokensA.length === 0 && tokensB.length === 0) return 0.0;
+
+  const setA = new Set(tokensA);
+  const setB = new Set(tokensB);
+  const intersection = new Set([...setA].filter(x => setB.has(x)));
+  const union = new Set([...setA, ...setB]);
+
+  return union.size === 0 ? 0 : intersection.size / union.size;
+}

package/src/matching/tfidf.ts

@@ -0,0 +1,74 @@
+export class TfIdfIndex {
+  private documents = new Map<number, string[]>();
+  private df = new Map<string, number>();
+  private idf = new Map<string, number>();
+  private documentCount = 0;
+
+  addDocument(id: number, tokens: string[]): void {
+    if (this.documents.has(id)) {
+      this.removeDocument(id);
+    }
+    const unique = new Set(tokens);
+    for (const token of unique) {
+      this.df.set(token, (this.df.get(token) ?? 0) + 1);
+    }
+    this.documents.set(id, tokens);
+    this.documentCount++;
+    this.recomputeIdfForTerms(unique);
+  }
+
+  removeDocument(id: number): void {
+    const tokens = this.documents.get(id);
+    if (!tokens) return;
+
+    const unique = new Set(tokens);
+    for (const token of unique) {
+      const count = this.df.get(token) ?? 0;
+      if (count <= 1) {
+        this.df.delete(token);
+        this.idf.delete(token);
+      } else {
+        this.df.set(token, count - 1);
+      }
+    }
+    this.documents.delete(id);
+    this.documentCount--;
+  }
+
+  query(tokens: string[], topK: number = 10): Array<{ id: number; score: number }> {
+    const scores = new Map<number, number>();
+
+    for (const token of tokens) {
+      const idfVal = this.idf.get(token) ?? 0;
+      if (idfVal === 0) continue;
+
+      for (const [docId, docTokens] of this.documents) {
+        const tf = docTokens.filter(t => t === token).length / docTokens.length;
+        const score = (scores.get(docId) ?? 0) + tf * idfVal;
+        scores.set(docId, score);
+      }
+    }
+
+    return Array.from(scores.entries())
+      .map(([id, score]) => ({ id, score }))
+      .sort((a, b) => b.score - a.score)
+      .slice(0, topK);
+  }
+
+  getDocumentCount(): number {
+    return this.documentCount;
+  }
+
+  getIdf(): ReadonlyMap<string, number> {
+    return this.idf;
+  }
+
+  private recomputeIdfForTerms(terms: Set<string>): void {
+    for (const term of terms) {
+      const dfVal = this.df.get(term) ?? 0;
+      if (dfVal > 0 && this.documentCount > 0) {
+        this.idf.set(term, Math.log(this.documentCount / dfVal));
+      }
+    }
+  }
+}

package/src/matching/tokenizer.ts

@@ -0,0 +1,41 @@
+const STOPWORDS = new Set([
+  'the', 'is', 'are', 'a', 'an', 'and', 'or', 'not', 'in', 'at', 'by', 'for',
+  'from', 'of', 'on', 'to', 'with', 'as', 'error', 'exception', 'throw', 'catch',
+  'was', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did',
+  'will', 'would', 'could', 'should', 'may', 'might', 'can', 'it', 'its',
+  'this', 'that', 'these', 'those', 'i', 'we', 'you', 'he', 'she', 'they',
+]);
+
+export function splitCamelCase(text: string): string[] {
+  return text
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+    .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+    .split(/\s+/)
+    .filter(t => t.length > 0);
+}
+
+export function splitSnakeCase(text: string): string[] {
+  return text.split(/[_\-]+/).filter(t => t.length > 0);
+}
+
+export function removeStopwords(tokens: string[]): string[] {
+  return tokens.filter(t => !STOPWORDS.has(t.toLowerCase()));
+}
+
+export function tokenize(text: string): string[] {
+  const words = text
+    .replace(/[^\w\s]/g, ' ')
+    .split(/\s+/)
+    .filter(t => t.length > 0);
+
+  const tokens: string[] = [];
+  for (const word of words) {
+    tokens.push(...splitCamelCase(word));
+    if (word.includes('_') || word.includes('-')) {
+      tokens.push(...splitSnakeCase(word));
+    }
+  }
+
+  const cleaned = removeStopwords(tokens);
+  return [...new Set(cleaned.map(t => t.toLowerCase()))];
+}

package/src/mcp/auto-detect.ts

@@ -0,0 +1,93 @@
+import { IpcClient } from '../ipc/client.js';
+import { getPipeName } from '../utils/paths.js';
+
+interface HookInput {
+  tool_name: string;
+  tool_input: { command?: string; file_path?: string };
+  tool_output: string;
+  exit_code?: number;
+}
+
+const ERROR_PATTERNS = [
+  /Error:/i,
+  /error\[E\d+\]/,                       // Rust errors
+  /Traceback \(most recent call last\)/,  // Python
+  /FATAL|PANIC/i,
+  /npm ERR!/,
+  /SyntaxError|TypeError|ReferenceError|RangeError/,
+  /ENOENT|EACCES|ECONNREFUSED|ETIMEDOUT/,
+  /ModuleNotFoundError|ImportError/,
+  /failed to compile/i,
+  /BUILD FAILED/i,
+  /Cannot find module/,
+  /command not found/,
+  /Permission denied/,
+];
+
+function isError(input: HookInput): boolean {
+  if (input.exit_code !== undefined && input.exit_code !== 0) return true;
+  return ERROR_PATTERNS.some(p => p.test(input.tool_output));
+}
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+  });
+}
+
+async function main(): Promise<void> {
+  const raw = await readStdin();
+  if (!raw.trim()) return;
+
+  let input: HookInput;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    return;
+  }
+
+  if (!isError(input)) return;
+
+  const client = new IpcClient(getPipeName(), 3000);
+  try {
+    await client.connect();
+
+    // Report error to Brain
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const result: any = await client.request('error.report', {
+      project: 'auto-detected',
+      errorOutput: input.tool_output,
+      command: input.tool_input.command,
+      autoDetected: true,
+    });
+
+    // If Brain knows a solution, output as feedback
+    if (result.matches?.length > 0) {
+      const best = result.matches[0];
+      process.stderr.write(`Brain: Similar error found (#${best.errorId}, ${Math.round(best.score * 100)}% match)\n`);
+      if (best.solutions?.length > 0) {
+        process.stderr.write(`Brain: Solution available — use brain_query_error to see details\n`);
+      }
+    }
+
+    // Anti-pattern check
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const antipatterns: any = await client.request('prevention.antipatterns', {
+      errorType: '',
+      message: input.tool_output,
+    });
+    if (antipatterns?.length > 0 && antipatterns[0].matched) {
+      process.stderr.write(`Brain WARNING: Known anti-pattern detected: ${antipatterns[0].description}\n`);
+    }
+
+  } catch {
+    // Hook must never block the workflow — silent failure
+  } finally {
+    client.disconnect();
+  }
+}
+
+main();

package/src/mcp/server.ts

@@ -0,0 +1,73 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { IpcClient } from '../ipc/client.js';
+import { getPipeName } from '../utils/paths.js';
+import { registerTools } from './tools.js';
+
+function spawnDaemon(): void {
+  const entryPoint = path.resolve(import.meta.dirname, '../index.ts');
+  const child = spawn(process.execPath, [
+    '--import', 'tsx',
+    entryPoint, 'daemon',
+  ], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: path.resolve(import.meta.dirname, '../..'),
+  });
+  child.unref();
+  process.stderr.write(`Brain: Auto-started daemon (PID: ${child.pid})\n`);
+}
+
+async function connectWithRetry(ipc: IpcClient, retries: number, delayMs: number): Promise<void> {
+  for (let i = 0; i < retries; i++) {
+    try {
+      await ipc.connect();
+      return;
+    } catch {
+      if (i < retries - 1) {
+        await new Promise(r => setTimeout(r, delayMs));
+      }
+    }
+  }
+  throw new Error('Could not connect to daemon after retries');
+}
+
+export async function startMcpServer(): Promise<void> {
+  const server = new McpServer({
+    name: 'brain',
+    version: '1.0.0',
+  });
+
+  const ipc = new IpcClient(getPipeName());
+
+  try {
+    await ipc.connect();
+  } catch {
+    // Daemon not running — auto-start it
+    process.stderr.write('Brain: Daemon not running, starting automatically...\n');
+    spawnDaemon();
+    try {
+      await connectWithRetry(ipc, 10, 500);
+    } catch {
+      process.stderr.write('Brain: Could not connect to daemon after auto-start. Check logs.\n');
+      process.exit(1);
+    }
+  }
+
+  registerTools(server, ipc);
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  process.on('SIGINT', () => {
+    ipc.disconnect();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', () => {
+    ipc.disconnect();
+    process.exit(0);
+  });
+}