@timmeck/brain 1.8.0 → 1.8.2

package/src/mcp/http-server.ts

@@ -1,137 +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.7.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 {
-    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.7.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);
+}

package/src/parsing/parsers/compiler.ts

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