@timmeck/brain 1.8.1 → 1.8.2

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/http-server.ts

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

package/src/parsing/error-parser.ts

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