@timmeck/brain 1.8.5 → 2.0.0

package/src/matching/tokenizer.ts

@@ -1,41 +0,0 @@
-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 +0,0 @@
-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/http-server.ts

@@ -1,140 +0,0 @@
-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.8.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 {
-    for (const transport of this.transports.values()) {
-      try { transport.close?.(); } catch { /* ignore */ }
-    }
-    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.8.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/server.ts

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

package/src/mcp/tools.ts

@@ -1,328 +0,0 @@
-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 ===
-
-  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 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);
-    },
-  );
-
-  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 call('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 call('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 call('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 call('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 call('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 call('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 call('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 call('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 call('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_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.',
-    {
-      context: z.string().describe('Current context or question'),
-    },
-    async (params) => {
-      const suggestions: AnyResult = await call('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 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}`,
-        `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 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)}`
-      );
-      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;
-}