@timmeck/brain 1.0.0 → 1.1.1

package/src/matching/tfidf.ts

@@ -1,74 +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));
-      }
-    }
-  }
-}
+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

@@ -1,41 +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()))];
-}
+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

@@ -1,93 +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();
+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

@@ -1,73 +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);
-  });
-}
+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);
+  });
+}