@timmeck/brain 1.0.0

package/src/mcp/tools.ts

@@ -0,0 +1,290 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { IpcClient } from '../ipc/client.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyResult = any;
+
+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 }] };
+}
+
+export function registerTools(server: McpServer, ipc: IpcClient): void {
+
+  // === Error Brain Tools ===
+
+  server.tool(
+    'brain_report_error',
+    'Report an error that occurred. Brain stores it, matches against known errors, returns solutions if available.',
+    {
+      error_output: z.string().describe('The raw error output from the terminal'),
+      command: z.string().optional().describe('The command that caused the error'),
+      task_context: z.string().optional().describe('What was the user trying to accomplish'),
+      working_directory: z.string().optional().describe('Working directory when error occurred'),
+      project: z.string().optional().describe('Project name'),
+    },
+    async (params) => {
+      const result: AnyResult = await ipc.request('error.report', {
+        project: params.project ?? 'default',
+        errorOutput: params.error_output,
+        filePath: params.working_directory,
+      });
+      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).`;
+      }
+      return textResult(response);
+    },
+  );
+
+  server.tool(
+    'brain_query_error',
+    'Search for similar errors and their solutions in the Brain database.',
+    {
+      query: z.string().describe('Error message or description to search for'),
+      project_only: z.boolean().optional().describe('Only search in current project'),
+    },
+    async (params) => {
+      const results: AnyResult = await ipc.request('error.query', {
+        search: params.query,
+      });
+      if (!results?.length) return textResult('No matching errors found.');
+      const lines = results.map((e: AnyResult) =>
+        `#${e.id} [${e.errorType}] ${e.message?.slice(0, 120)}${e.resolved ? ' (resolved)' : ''}`
+      );
+      return textResult(`Found ${results.length} errors:\n${lines.join('\n')}`);
+    },
+  );
+
+  server.tool(
+    'brain_report_solution',
+    'Report a successful solution for an error. Brain will learn from this.',
+    {
+      error_id: z.number().describe('The error ID this solution fixes'),
+      description: z.string().describe('What was done to fix the error'),
+      commands: z.string().optional().describe('Commands used to fix'),
+      code_change: z.string().optional().describe('Code changes or diff'),
+    },
+    async (params) => {
+      const solutionId: AnyResult = await ipc.request('solution.report', {
+        errorId: params.error_id,
+        description: params.description,
+        commands: params.commands,
+        codeChange: params.code_change,
+      });
+      return textResult(`Solution #${solutionId} recorded for error #${params.error_id}. Brain will use this to help with similar errors in the future.`);
+    },
+  );
+
+  server.tool(
+    'brain_report_attempt',
+    'Report a failed solution attempt. Brain learns what does NOT work.',
+    {
+      error_id: z.number().describe('The error ID'),
+      solution_id: z.number().describe('The solution ID that was attempted'),
+      description: z.string().optional().describe('What was tried'),
+      output: z.string().optional().describe('Output of the failed attempt'),
+    },
+    async (params) => {
+      await ipc.request('solution.rate', {
+        errorId: params.error_id,
+        solutionId: params.solution_id,
+        success: false,
+        output: params.output,
+      });
+      return textResult(`Failed attempt recorded for error #${params.error_id}. Brain will avoid suggesting this approach for similar errors.`);
+    },
+  );
+
+  // === Code Brain Tools ===
+
+  server.tool(
+    'brain_find_reusable_code',
+    'Search for reusable code modules from other projects. Use when starting new functionality.',
+    {
+      purpose: z.string().describe('What the code should do (e.g., "retry with backoff", "JWT authentication")'),
+      language: z.string().optional().describe('Programming language'),
+    },
+    async (params) => {
+      const results: AnyResult = await ipc.request('code.find', {
+        query: params.purpose,
+        language: params.language,
+      });
+      if (!results?.length) return textResult('No reusable code modules found.');
+      const lines = results.map((m: AnyResult) =>
+        `#${m.id} [${m.language}] ${m.name} — ${m.description ?? 'no description'} (reusability: ${m.reusabilityScore ?? '?'})`
+      );
+      return textResult(`Found ${results.length} modules:\n${lines.join('\n')}`);
+    },
+  );
+
+  server.tool(
+    'brain_register_code',
+    'Register a code module as reusable. Brain will analyze it and make it available to other projects.',
+    {
+      source_code: z.string().describe('The source code'),
+      file_path: z.string().describe('File path relative to project root'),
+      project: z.string().optional().describe('Project name'),
+      name: z.string().optional().describe('Module name (optional - Brain auto-detects)'),
+      language: z.string().optional().describe('Programming language'),
+      description: z.string().optional().describe('What this code does'),
+    },
+    async (params) => {
+      const result: AnyResult = await ipc.request('code.analyze', {
+        project: params.project ?? 'default',
+        name: params.name ?? params.file_path.split('/').pop() ?? 'unknown',
+        filePath: params.file_path,
+        language: params.language ?? detectLanguage(params.file_path),
+        source: params.source_code,
+        description: params.description,
+      });
+      return textResult(`Module #${result.moduleId} registered (${result.isNew ? 'new' : 'updated'}). Reusability score: ${result.reusabilityScore}.`);
+    },
+  );
+
+  server.tool(
+    'brain_check_code_similarity',
+    'Check if similar code already exists in other projects before writing new code.',
+    {
+      source_code: z.string().describe('The code to check'),
+      language: z.string().optional().describe('Programming language'),
+      file_path: z.string().optional().describe('File path for context'),
+    },
+    async (params) => {
+      const results: AnyResult = await ipc.request('code.similarity', {
+        source: params.source_code,
+        language: params.language ?? detectLanguage(params.file_path ?? ''),
+      });
+      if (!results?.length) return textResult('No similar code found. This appears to be unique.');
+      const lines = results.map((m: AnyResult) =>
+        `Module #${m.moduleId}: ${Math.round(m.score * 100)}% match (${m.matchType})`
+      );
+      return textResult(`Found ${results.length} similar modules:\n${lines.join('\n')}`);
+    },
+  );
+
+  // === Synapse Network Tools ===
+
+  server.tool(
+    'brain_explore',
+    'Explore what Brain knows about a topic. Uses spreading activation through the synapse network.',
+    {
+      node_type: z.string().describe('Type: error, solution, code_module, project'),
+      node_id: z.number().describe('ID of the node to explore from'),
+      max_depth: z.number().optional().describe('How many hops to follow (default: 3)'),
+    },
+    async (params) => {
+      const context: AnyResult = await ipc.request('synapse.context', {
+        errorId: params.node_id,
+      });
+      const sections: string[] = [];
+      if (context.solutions?.length) sections.push(`Solutions: ${context.solutions.length} found`);
+      if (context.relatedErrors?.length) sections.push(`Related errors: ${context.relatedErrors.length}`);
+      if (context.relevantModules?.length) sections.push(`Relevant modules: ${context.relevantModules.length}`);
+      if (context.preventionRules?.length) sections.push(`Prevention rules: ${context.preventionRules.length}`);
+      if (context.insights?.length) sections.push(`Insights: ${context.insights.length}`);
+      return textResult(sections.length ? sections.join('\n') : 'No connections found for this node.');
+    },
+  );
+
+  server.tool(
+    'brain_connections',
+    'Find how two things are connected in Brain (e.g., how an error relates to a code module).',
+    {
+      from_type: z.string().describe('Source type: error, solution, code_module, project'),
+      from_id: z.number().describe('Source ID'),
+      to_type: z.string().describe('Target type'),
+      to_id: z.number().describe('Target ID'),
+    },
+    async (params) => {
+      const path: AnyResult = await ipc.request('synapse.path', params);
+      if (!path) return textResult('No connection found between these nodes.');
+      return textResult(path);
+    },
+  );
+
+  // === Research Brain Tools ===
+
+  server.tool(
+    'brain_insights',
+    'Get research insights: trends, gaps, synergies, template candidates, and project suggestions.',
+    {
+      type: z.string().optional().describe('Filter by type: trend, pattern, gap, synergy, optimization, template_candidate, project_suggestion, warning'),
+      priority: z.string().optional().describe('Minimum priority: low, medium, high, critical'),
+    },
+    async (params) => {
+      const insights: AnyResult = await ipc.request('research.insights', {
+        type: params.type,
+        activeOnly: true,
+        limit: 20,
+      });
+      if (!insights?.length) return textResult('No active insights.');
+      const lines = insights.map((i: AnyResult) =>
+        `[${i.type}] ${i.title}: ${i.description?.slice(0, 150)}`
+      );
+      return textResult(`${insights.length} insights:\n${lines.join('\n')}`);
+    },
+  );
+
+  server.tool(
+    'brain_suggest',
+    'Ask Brain for suggestions: what to build next, what to improve, what patterns to extract.',
+    {
+      context: z.string().describe('Current context or question'),
+    },
+    async (params) => {
+      const suggestions: AnyResult = await ipc.request('research.suggest', {
+        context: params.context,
+      });
+      return textResult(suggestions);
+    },
+  );
+
+  // === Status & Notifications ===
+
+  server.tool(
+    'brain_status',
+    '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 lines = [
+        `Errors: ${summary.errors?.total ?? 0} total, ${summary.errors?.unresolved ?? 0} unresolved`,
+        `Solutions: ${summary.solutions?.total ?? 0}`,
+        `Rules: ${summary.rules?.active ?? 0} active`,
+        `Code modules: ${summary.modules?.total ?? 0}`,
+        `Insights: ${summary.insights?.active ?? 0} active`,
+        `Synapses: ${network.totalSynapses ?? 0} connections`,
+      ];
+      return textResult(lines.join('\n'));
+    },
+  );
+
+  server.tool(
+    'brain_notifications',
+    'Get pending notifications (new solutions, recurring errors, research insights).',
+    {},
+    async () => {
+      const notifications: AnyResult = await ipc.request('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)}`
+      );
+      return textResult(`${notifications.length} notifications:\n${lines.join('\n')}`);
+    },
+  );
+}
+
+function detectLanguage(filePath: string): string {
+  const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
+  const map: Record<string, string> = {
+    ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
+    py: 'python', rs: 'rust', go: 'go', java: 'java',
+    c: 'c', cpp: 'cpp', h: 'c', hpp: 'cpp',
+    rb: 'ruby', sh: 'shell', bash: 'shell',
+  };
+  return map[ext] ?? ext;
+}

package/src/parsing/error-parser.ts

@@ -0,0 +1,28 @@
+import { ErrorParserRegistry } from './types.js';
+import { nodeParser } from './parsers/node.js';
+import { pythonParser } from './parsers/python.js';
+import { rustParser } from './parsers/rust.js';
+import { goParser } from './parsers/go.js';
+import { shellParser } from './parsers/shell.js';
+import { compilerParser } from './parsers/compiler.js';
+import { genericParser } from './parsers/generic.js';
+
+let registryInstance: ErrorParserRegistry | null = null;
+
+export function getParserRegistry(): ErrorParserRegistry {
+  if (!registryInstance) {
+    registryInstance = new ErrorParserRegistry();
+    registryInstance.register(nodeParser);
+    registryInstance.register(pythonParser);
+    registryInstance.register(rustParser);
+    registryInstance.register(goParser);
+    registryInstance.register(shellParser);
+    registryInstance.register(compilerParser);
+    registryInstance.register(genericParser);
+  }
+  return registryInstance;
+}
+
+export function parseError(input: string) {
+  return getParserRegistry().parse(input);
+}

package/src/parsing/parsers/compiler.ts

@@ -0,0 +1,93 @@
+import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
+import path from 'node:path';
+
+const GCC_RE = /^(.+?):(\d+):(\d+): (error|warning|fatal error): (.+)/m;
+const JAVAC_RE = /^(.+\.java):(\d+): error: (.+)/m;
+const GENERIC_COMPILER_RE = /^(.+?):(\d+)(?::(\d+))?: (?:error|fatal): (.+)/m;
+
+export const compilerParser: ErrorParser = {
+  name: 'compiler',
+  priority: 7,
+
+  canParse(input: string): boolean {
+    return (
+      GCC_RE.test(input) ||
+      JAVAC_RE.test(input) ||
+      /compilation failed|fatal error:/.test(input)
+    );
+  },
+
+  parse(input: string): ParsedError | null {
+    let gccMatch = GCC_RE.exec(input);
+    if (gccMatch) {
+      const filePath = gccMatch[1]!;
+      const frame: StackFrame = {
+        function_name: null,
+        file_path: filePath,
+        line_number: parseInt(gccMatch[2]!, 10),
+        column_number: parseInt(gccMatch[3]!, 10),
+        normalized: `<compiler>@${path.basename(filePath)}`,
+      };
+      return {
+        errorType: gccMatch[4] === 'warning' ? 'CompilerWarning' : 'CompilerError',
+        message: gccMatch[5]!,
+        stackTrace: input,
+        frames: [frame],
+        sourceFile: filePath,
+        sourceLine: frame.line_number,
+        language: detectLanguage(filePath),
+      };
+    }
+
+    const javacMatch = JAVAC_RE.exec(input);
+    if (javacMatch) {
+      const filePath = javacMatch[1]!;
+      return {
+        errorType: 'CompilerError',
+        message: javacMatch[3]!,
+        stackTrace: input,
+        frames: [{
+          function_name: null,
+          file_path: filePath,
+          line_number: parseInt(javacMatch[2]!, 10),
+          column_number: null,
+          normalized: `<compiler>@${path.basename(filePath)}`,
+        }],
+        sourceFile: filePath,
+        sourceLine: parseInt(javacMatch[2]!, 10),
+        language: 'java',
+      };
+    }
+
+    const genericMatch = GENERIC_COMPILER_RE.exec(input);
+    if (genericMatch) {
+      const filePath = genericMatch[1]!;
+      return {
+        errorType: 'CompilerError',
+        message: genericMatch[4]!,
+        stackTrace: input,
+        frames: [{
+          function_name: null,
+          file_path: filePath,
+          line_number: parseInt(genericMatch[2]!, 10),
+          column_number: genericMatch[3] ? parseInt(genericMatch[3], 10) : null,
+          normalized: `<compiler>@${path.basename(filePath)}`,
+        }],
+        sourceFile: filePath,
+        sourceLine: parseInt(genericMatch[2]!, 10),
+        language: detectLanguage(filePath),
+      };
+    }
+
+    return null;
+  },
+};
+
+function detectLanguage(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  const map: Record<string, string> = {
+    '.c': 'c', '.h': 'c', '.cpp': 'cpp', '.cc': 'cpp', '.cxx': 'cpp',
+    '.java': 'java', '.rs': 'rust', '.go': 'go', '.swift': 'swift',
+  };
+  return map[ext] ?? 'unknown';
+}

package/src/parsing/parsers/generic.ts

@@ -0,0 +1,28 @@
+import type { ErrorParser, ParsedError } from '../types.js';
+
+const ERROR_LINE_RE = /(?:error|Error|ERROR)[\s:]+(.+)/;
+
+export const genericParser: ErrorParser = {
+  name: 'generic',
+  priority: 0,
+
+  canParse(_input: string): boolean {
+    return true;
+  },
+
+  parse(input: string): ParsedError | null {
+    const match = ERROR_LINE_RE.exec(input);
+    const firstLine = input.trim().split('\n')[0] ?? input;
+    const message = match ? match[1]! : firstLine;
+
+    return {
+      errorType: 'UnknownError',
+      message: message.trim(),
+      stackTrace: null,
+      frames: [],
+      sourceFile: null,
+      sourceLine: null,
+      language: null,
+    };
+  },
+};

package/src/parsing/parsers/go.ts

@@ -0,0 +1,97 @@
+import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
+import path from 'node:path';
+
+const GO_FILE_ERROR_RE = /^\.?\/?(.+\.go):(\d+):(\d+): (.+)/m;
+const GO_PANIC_RE = /^panic: (.+)/m;
+const GO_GOROUTINE_RE = /^goroutine \d+ \[.+\]:/m;
+const GO_STACK_RE = /^\t(.+\.go):(\d+)/gm;
+const GO_FUNC_RE = /^(.+)\(.*\)$/gm;
+
+export const goParser: ErrorParser = {
+  name: 'go',
+  priority: 10,
+
+  canParse(input: string): boolean {
+    return (
+      GO_FILE_ERROR_RE.test(input) ||
+      GO_PANIC_RE.test(input) ||
+      /^fatal error:/.test(input)
+    );
+  },
+
+  parse(input: string): ParsedError | null {
+    const panicMatch = GO_PANIC_RE.exec(input);
+    if (panicMatch) {
+      return parsePanic(input, panicMatch[1]!);
+    }
+
+    const fileMatch = GO_FILE_ERROR_RE.exec(input);
+    if (fileMatch) {
+      return {
+        errorType: 'CompilerError',
+        message: fileMatch[4]!,
+        stackTrace: input,
+        frames: [{
+          function_name: null,
+          file_path: fileMatch[1]!,
+          line_number: parseInt(fileMatch[2]!, 10),
+          column_number: parseInt(fileMatch[3]!, 10),
+          normalized: `<compiler>@${path.basename(fileMatch[1]!)}`,
+        }],
+        sourceFile: fileMatch[1]!,
+        sourceLine: parseInt(fileMatch[2]!, 10),
+        language: 'go',
+      };
+    }
+
+    const fatalMatch = /^fatal error: (.+)/m.exec(input);
+    if (fatalMatch) {
+      return {
+        errorType: 'FatalError',
+        message: fatalMatch[1]!,
+        stackTrace: input,
+        frames: [],
+        sourceFile: null,
+        sourceLine: null,
+        language: 'go',
+      };
+    }
+
+    return null;
+  },
+};
+
+function parsePanic(input: string, message: string): ParsedError {
+  const frames: StackFrame[] = [];
+  const lines = input.split('\n');
+  let i = 0;
+
+  while (i < lines.length) {
+    if (lines[i]!.startsWith('\t')) {
+      const stackMatch = /^\t(.+\.go):(\d+)/.exec(lines[i]!);
+      if (stackMatch) {
+        const funcLine = i > 0 ? lines[i - 1]!.trim() : null;
+        const funcName = funcLine?.replace(/\(.*\)$/, '') ?? null;
+        frames.push({
+          function_name: funcName,
+          file_path: stackMatch[1]!,
+          line_number: parseInt(stackMatch[2]!, 10),
+          column_number: null,
+          normalized: `${funcName || '<anon>'}@${path.basename(stackMatch[1]!)}`,
+        });
+      }
+    }
+    i++;
+  }
+
+  const topFrame = frames[0];
+  return {
+    errorType: 'PanicError',
+    message,
+    stackTrace: input,
+    frames,
+    sourceFile: topFrame?.file_path ?? null,
+    sourceLine: topFrame?.line_number ?? null,
+    language: 'go',
+  };
+}

package/src/parsing/parsers/node.ts

@@ -0,0 +1,69 @@
+import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
+import path from 'node:path';
+
+const V8_STACK_RE = /at (?:(.+?) )?\((.+?):(\d+):(\d+)\)/;
+const V8_STACK_BARE_RE = /at (.+?):(\d+):(\d+)/;
+const ERROR_TYPE_RE = /^(\w+(?:Error|Exception|Warning)?): (.+)$/m;
+
+function parseFrames(input: string): StackFrame[] {
+  const frames: StackFrame[] = [];
+  for (const line of input.split('\n')) {
+    const trimmed = line.trim();
+    let match = V8_STACK_RE.exec(trimmed);
+    if (match) {
+      frames.push({
+        function_name: match[1] || null,
+        file_path: match[2]!,
+        line_number: parseInt(match[3]!, 10),
+        column_number: parseInt(match[4]!, 10),
+        normalized: `${match[1] || '<anon>'}@${path.basename(match[2]!)}`,
+      });
+      continue;
+    }
+    match = V8_STACK_BARE_RE.exec(trimmed);
+    if (match) {
+      frames.push({
+        function_name: null,
+        file_path: match[1]!,
+        line_number: parseInt(match[2]!, 10),
+        column_number: parseInt(match[3]!, 10),
+        normalized: `<anon>@${path.basename(match[1]!)}`,
+      });
+    }
+  }
+  return frames;
+}
+
+export const nodeParser: ErrorParser = {
+  name: 'node',
+  priority: 10,
+
+  canParse(input: string): boolean {
+    return (
+      /at .+ \(.+:\d+:\d+\)/.test(input) ||
+      /at .+:\d+:\d+/.test(input) ||
+      /^\w*Error:/.test(input) ||
+      /^\w*TypeError:/.test(input)
+    );
+  },
+
+  parse(input: string): ParsedError | null {
+    const typeMatch = ERROR_TYPE_RE.exec(input);
+    if (!typeMatch) return null;
+
+    const errorType = typeMatch[1]!;
+    const message = typeMatch[2]!;
+    const frames = parseFrames(input);
+    const topFrame = frames[0];
+
+    return {
+      errorType,
+      message,
+      stackTrace: input,
+      frames,
+      sourceFile: topFrame?.file_path ?? null,
+      sourceLine: topFrame?.line_number ?? null,
+      language: 'javascript',
+    };
+  },
+};

package/src/parsing/parsers/python.ts

@@ -0,0 +1,62 @@
+import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
+import path from 'node:path';
+
+const FRAME_RE = /File "(.+?)", line (\d+)(?:, in (.+))?/g;
+const ERROR_LINE_RE = /^(\w+(?:Error|Exception|Warning)?): (.+)$/m;
+
+export const pythonParser: ErrorParser = {
+  name: 'python',
+  priority: 10,
+
+  canParse(input: string): boolean {
+    return (
+      /Traceback \(most recent call last\)/.test(input) ||
+      /File ".+", line \d+/.test(input)
+    );
+  },
+
+  parse(input: string): ParsedError | null {
+    const frames: StackFrame[] = [];
+    let match: RegExpExecArray | null;
+    const frameRe = new RegExp(FRAME_RE.source, 'g');
+
+    while ((match = frameRe.exec(input)) !== null) {
+      frames.push({
+        function_name: match[3] || null,
+        file_path: match[1]!,
+        line_number: parseInt(match[2]!, 10),
+        column_number: null,
+        normalized: `${match[3] || '<module>'}@${path.basename(match[1]!)}`,
+      });
+    }
+
+    const lines = input.trim().split('\n');
+    let errorType = 'PythonError';
+    let message = '';
+
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const errMatch = ERROR_LINE_RE.exec(lines[i]!);
+      if (errMatch) {
+        errorType = errMatch[1]!;
+        message = errMatch[2]!;
+        break;
+      }
+    }
+
+    if (!message && lines.length > 0) {
+      message = lines[lines.length - 1]!;
+    }
+
+    const topFrame = frames[frames.length - 1];
+
+    return {
+      errorType,
+      message,
+      stackTrace: input,
+      frames,
+      sourceFile: topFrame?.file_path ?? null,
+      sourceLine: topFrame?.line_number ?? null,
+      language: 'python',
+    };
+  },
+};