@timmeck/brain 1.8.1 → 1.8.2

package/src/ipc/server.ts

@@ -1,110 +1,176 @@
-import net from 'node:net';
-import { randomUUID } from 'node:crypto';
-import { getLogger } from '../utils/logger.js';
-
-const logger = getLogger();
-import type { IpcMessage } from '../types/ipc.types.js';
-import { encodeMessage, MessageDecoder } from './protocol.js';
-import type { IpcRouter } from './router.js';
-
-export class IpcServer {
-  private server: net.Server | null = null;
-  private clients = new Map<string, net.Socket>();
-
-  constructor(
-    private router: IpcRouter,
-    private pipeName: string,
-  ) {}
-
-  start(): void {
-    this.server = net.createServer((socket) => {
-      const clientId = randomUUID();
-      this.clients.set(clientId, socket);
-      const decoder = new MessageDecoder();
-
-      logger.info(`IPC client connected: ${clientId}`);
-
-      socket.on('data', (chunk) => {
-        const messages = decoder.feed(chunk);
-        for (const msg of messages) {
-          this.handleMessage(clientId, msg, socket);
-        }
-      });
-
-      socket.on('close', () => {
-        logger.info(`IPC client disconnected: ${clientId}`);
-        this.clients.delete(clientId);
-      });
-
-      socket.on('error', (err) => {
-        logger.error(`IPC client ${clientId} error:`, err);
-        this.clients.delete(clientId);
-      });
-    });
-
-    this.server.on('error', (err) => {
-      logger.error('IPC server error:', err);
-    });
-
-    this.server.listen(this.pipeName, () => {
-      logger.info(`IPC server listening on ${this.pipeName}`);
-    });
-  }
-
-  private handleMessage(clientId: string, msg: IpcMessage, socket: net.Socket): void {
-    if (msg.type !== 'request' || !msg.method) return;
-
-    try {
-      const result = this.router.handle(msg.method, msg.params);
-      const response: IpcMessage = {
-        id: msg.id,
-        type: 'response',
-        result,
-      };
-      socket.write(encodeMessage(response));
-    } catch (err) {
-      const response: IpcMessage = {
-        id: msg.id,
-        type: 'response',
-        error: { code: -1, message: err instanceof Error ? err.message : String(err) },
-      };
-      socket.write(encodeMessage(response));
-    }
-  }
-
-  notify(clientId: string | null, notification: Omit<IpcMessage, 'id' | 'type'>): void {
-    const msg: IpcMessage = {
-      id: randomUUID(),
-      type: 'notification',
-      ...notification,
-    };
-    const encoded = encodeMessage(msg);
-
-    if (clientId) {
-      const socket = this.clients.get(clientId);
-      if (socket && !socket.destroyed) {
-        socket.write(encoded);
-      }
-    } else {
-      for (const socket of this.clients.values()) {
-        if (!socket.destroyed) {
-          socket.write(encoded);
-        }
-      }
-    }
-  }
-
-  getClientCount(): number {
-    return this.clients.size;
-  }
-
-  stop(): void {
-    for (const socket of this.clients.values()) {
-      socket.destroy();
-    }
-    this.clients.clear();
-    this.server?.close();
-    this.server = null;
-    logger.info('IPC server stopped');
-  }
-}
+import net from 'node:net';
+import fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { getLogger } from '../utils/logger.js';
+
+const logger = getLogger();
+import type { IpcMessage } from '../types/ipc.types.js';
+import { encodeMessage, MessageDecoder } from './protocol.js';
+import type { IpcRouter } from './router.js';
+
+export class IpcServer {
+  private server: net.Server | null = null;
+  private clients = new Map<string, net.Socket>();
+
+  constructor(
+    private router: IpcRouter,
+    private pipeName: string,
+  ) {}
+
+  start(): void {
+    this.createServer();
+    this.listen();
+  }
+
+  private createServer(): void {
+    this.server = net.createServer((socket) => {
+      const clientId = randomUUID();
+      this.clients.set(clientId, socket);
+      const decoder = new MessageDecoder();
+
+      logger.info(`IPC client connected: ${clientId}`);
+
+      socket.on('data', (chunk) => {
+        const messages = decoder.feed(chunk);
+        for (const msg of messages) {
+          this.handleMessage(clientId, msg, socket);
+        }
+      });
+
+      socket.on('close', () => {
+        logger.info(`IPC client disconnected: ${clientId}`);
+        this.clients.delete(clientId);
+      });
+
+      socket.on('error', (err) => {
+        logger.error(`IPC client ${clientId} error:`, err);
+        this.clients.delete(clientId);
+      });
+    });
+  }
+
+  private listen(retried = false): void {
+    if (!this.server) return;
+
+    this.server.on('error', (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE' && !retried) {
+        logger.warn(`IPC pipe in use, attempting to recover stale pipe: ${this.pipeName}`);
+        this.recoverStalePipe();
+      } else {
+        logger.error('IPC server error:', err);
+      }
+    });
+
+    this.server.listen(this.pipeName, () => {
+      logger.info(`IPC server listening on ${this.pipeName}`);
+    });
+  }
+
+  /**
+   * On Windows, named pipes can remain after a crashed daemon.
+   * Try to connect as a client — if it fails, the pipe is stale and we can reclaim it.
+   * On Unix, simply unlink the socket file and retry.
+   */
+  private recoverStalePipe(): void {
+    const probe = net.createConnection(this.pipeName);
+
+    probe.on('connect', () => {
+      // Pipe is alive — another daemon is actually running
+      probe.destroy();
+      logger.error('IPC pipe is held by another running daemon. Stop it first with: brain stop');
+    });
+
+    probe.on('error', () => {
+      // Pipe is stale — no one is listening. Clean up and retry.
+      probe.destroy();
+      logger.info('Stale IPC pipe detected, reclaiming...');
+
+      // On Unix, unlink the socket file
+      if (process.platform !== 'win32') {
+        try { fs.unlinkSync(this.pipeName); } catch { /* ignore */ }
+      }
+
+      // Recreate server and retry (Windows auto-reclaims dead named pipes on re-listen)
+      this.createServer();
+      this.server!.on('error', (err) => {
+        logger.error('IPC server error after recovery:', err);
+      });
+      this.server!.listen(this.pipeName, () => {
+        logger.info(`IPC server recovered and listening on ${this.pipeName}`);
+      });
+    });
+
+    // Timeout: if probe hangs, treat pipe as stale
+    probe.setTimeout(2000, () => {
+      probe.destroy();
+      logger.warn('IPC pipe probe timed out, treating as stale');
+      if (process.platform !== 'win32') {
+        try { fs.unlinkSync(this.pipeName); } catch { /* ignore */ }
+      }
+      this.createServer();
+      this.server!.on('error', (err) => {
+        logger.error('IPC server error after timeout recovery:', err);
+      });
+      this.server!.listen(this.pipeName, () => {
+        logger.info(`IPC server recovered (timeout) and listening on ${this.pipeName}`);
+      });
+    });
+  }
+
+  private handleMessage(clientId: string, msg: IpcMessage, socket: net.Socket): void {
+    if (msg.type !== 'request' || !msg.method) return;
+
+    try {
+      const result = this.router.handle(msg.method, msg.params);
+      const response: IpcMessage = {
+        id: msg.id,
+        type: 'response',
+        result,
+      };
+      socket.write(encodeMessage(response));
+    } catch (err) {
+      const response: IpcMessage = {
+        id: msg.id,
+        type: 'response',
+        error: { code: -1, message: err instanceof Error ? err.message : String(err) },
+      };
+      socket.write(encodeMessage(response));
+    }
+  }
+
+  notify(clientId: string | null, notification: Omit<IpcMessage, 'id' | 'type'>): void {
+    const msg: IpcMessage = {
+      id: randomUUID(),
+      type: 'notification',
+      ...notification,
+    };
+    const encoded = encodeMessage(msg);
+
+    if (clientId) {
+      const socket = this.clients.get(clientId);
+      if (socket && !socket.destroyed) {
+        socket.write(encoded);
+      }
+    } else {
+      for (const socket of this.clients.values()) {
+        if (!socket.destroyed) {
+          socket.write(encoded);
+        }
+      }
+    }
+  }
+
+  getClientCount(): number {
+    return this.clients.size;
+  }
+
+  stop(): void {
+    for (const socket of this.clients.values()) {
+      socket.destroy();
+    }
+    this.clients.clear();
+    this.server?.close();
+    this.server = null;
+    logger.info('IPC server stopped');
+  }
+}

package/src/learning/decay.ts

@@ -1,46 +1,46 @@
-import type { SolutionRepository } from '../db/repositories/solution.repository.js';
-import { wilsonScore } from './confidence-scorer.js';
-
-/**
- * Update confidence scores for all solutions based on their attempt history.
- */
-export function updateSolutionConfidences(solutionRepo: SolutionRepository): number {
-  const solutions = solutionRepo.getAll();
-  let updated = 0;
-
-  for (const sol of solutions) {
-    const total = sol.success_count + sol.fail_count;
-    if (total === 0) continue;
-
-    const newConfidence = wilsonScore(sol.success_count, total);
-    if (Math.abs(newConfidence - sol.confidence) > 0.001) {
-      solutionRepo.update(sol.id, { confidence: newConfidence });
-      updated++;
-    }
-  }
-
-  return updated;
-}
-
-/**
- * Compute relevance decay factor for a timestamp.
- */
-export function relevanceDecay(timestamp: string, halfLifeDays: number): number {
-  const ageDays = (Date.now() - new Date(timestamp).getTime()) / (1000 * 60 * 60 * 24);
-  return Math.pow(0.5, ageDays / halfLifeDays);
-}
-
-/**
- * Determine if a rule should be pruned based on its performance.
- */
-export function shouldPruneRule(
-  confidence: number,
-  rejectionCount: number,
-  totalUsage: number,
-  pruneThreshold: number,
-  maxRejectionRate: number,
-): boolean {
-  if (confidence < pruneThreshold) return true;
-  if (totalUsage > 0 && rejectionCount / totalUsage > maxRejectionRate) return true;
-  return false;
-}
+import type { SolutionRepository } from '../db/repositories/solution.repository.js';
+import { wilsonScore } from './confidence-scorer.js';
+
+/**
+ * Update confidence scores for all solutions based on their attempt history.
+ */
+export function updateSolutionConfidences(solutionRepo: SolutionRepository): number {
+  const solutions = solutionRepo.getAll();
+  let updated = 0;
+
+  for (const sol of solutions) {
+    const total = sol.success_count + sol.fail_count;
+    if (total === 0) continue;
+
+    const newConfidence = wilsonScore(sol.success_count, total);
+    if (Math.abs(newConfidence - sol.confidence) > 0.001) {
+      solutionRepo.update(sol.id, { confidence: newConfidence });
+      updated++;
+    }
+  }
+
+  return updated;
+}
+
+/**
+ * Compute relevance decay factor for a timestamp.
+ */
+export function relevanceDecay(timestamp: string, halfLifeDays: number): number {
+  const ageDays = (Date.now() - new Date(timestamp).getTime()) / (1000 * 60 * 60 * 24);
+  return Math.pow(0.5, ageDays / halfLifeDays);
+}
+
+/**
+ * Determine if a rule should be pruned based on its performance.
+ */
+export function shouldPruneRule(
+  confidence: number,
+  rejectionCount: number,
+  totalUsage: number,
+  pruneThreshold: number,
+  maxRejectionRate: number,
+): boolean {
+  if (confidence < pruneThreshold) return true;
+  if (totalUsage > 0 && rejectionCount / totalUsage > maxRejectionRate) return true;
+  return false;
+}

package/src/learning/pattern-extractor.ts

@@ -1,90 +1,90 @@
-import type { ErrorRecord } from '../types/error.types.js';
-import { tokenize } from '../matching/tokenizer.js';
-import { cosineSimilarity } from '../matching/similarity.js';
-
-export interface ErrorPattern {
-  errorType: string;
-  messageTemplate: string;
-  messageRegex: string;
-  filePattern: string | null;
-  occurrences: number;
-  errorIds: number[];
-  solutionIds: number[];
-  confidence: number;
-  successRate: number;
-}
-
-interface Centroid {
-  errorType: string;
-  tokens: string[];
-  errorIds: number[];
-  filePattern: string | null;
-}
-
-/**
- * Extract patterns from error records using centroid-based clustering.
- */
-export function extractPatterns(
-  errors: ErrorRecord[],
-  similarityThreshold: number = 0.7,
-): ErrorPattern[] {
-  const centroids: Centroid[] = [];
-
-  for (const error of errors) {
-    const tokens = tokenize(`${error.type} ${error.message}`);
-    let merged = false;
-
-    for (const centroid of centroids) {
-      if (centroid.errorType !== error.type) continue;
-
-      const sim = cosineSimilarity(centroid.tokens, tokens);
-      if (sim >= similarityThreshold) {
-        // Merge into existing centroid (running average)
-        const allTokens = [...centroid.tokens, ...tokens];
-        centroid.tokens = [...new Set(allTokens)];
-        centroid.errorIds.push(error.id);
-        if (!centroid.filePattern && error.file_path) {
-          centroid.filePattern = extractFilePattern(error.file_path);
-        }
-        merged = true;
-        break;
-      }
-    }
-
-    if (!merged) {
-      centroids.push({
-        errorType: error.type,
-        tokens,
-        errorIds: [error.id],
-        filePattern: error.file_path ? extractFilePattern(error.file_path) : null,
-      });
-    }
-  }
-
-  return centroids
-    .filter(c => c.errorIds.length >= 2)
-    .map(c => ({
-      errorType: c.errorType,
-      messageTemplate: c.tokens.join(' '),
-      messageRegex: buildRegex(c.tokens),
-      filePattern: c.filePattern,
-      occurrences: c.errorIds.length,
-      errorIds: c.errorIds,
-      solutionIds: [],
-      confidence: 0,
-      successRate: 0,
-    }));
-}
-
-function extractFilePattern(filePath: string): string {
-  // Extract the meaningful part: last directory + extension
-  const parts = filePath.replace(/\\/g, '/').split('/');
-  const fileName = parts[parts.length - 1] ?? '';
-  const ext = fileName.split('.').pop() ?? '';
-  return ext ? `*.${ext}` : '*';
-}
-
-function buildRegex(tokens: string[]): string {
-  const escaped = tokens.map(t => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
-  return escaped.join('.*');
-}
+import type { ErrorRecord } from '../types/error.types.js';
+import { tokenize } from '../matching/tokenizer.js';
+import { cosineSimilarity } from '../matching/similarity.js';
+
+export interface ErrorPattern {
+  errorType: string;
+  messageTemplate: string;
+  messageRegex: string;
+  filePattern: string | null;
+  occurrences: number;
+  errorIds: number[];
+  solutionIds: number[];
+  confidence: number;
+  successRate: number;
+}
+
+interface Centroid {
+  errorType: string;
+  tokens: string[];
+  errorIds: number[];
+  filePattern: string | null;
+}
+
+/**
+ * Extract patterns from error records using centroid-based clustering.
+ */
+export function extractPatterns(
+  errors: ErrorRecord[],
+  similarityThreshold: number = 0.7,
+): ErrorPattern[] {
+  const centroids: Centroid[] = [];
+
+  for (const error of errors) {
+    const tokens = tokenize(`${error.type} ${error.message}`);
+    let merged = false;
+
+    for (const centroid of centroids) {
+      if (centroid.errorType !== error.type) continue;
+
+      const sim = cosineSimilarity(centroid.tokens, tokens);
+      if (sim >= similarityThreshold) {
+        // Merge into existing centroid (running average)
+        const allTokens = [...centroid.tokens, ...tokens];
+        centroid.tokens = [...new Set(allTokens)];
+        centroid.errorIds.push(error.id);
+        if (!centroid.filePattern && error.file_path) {
+          centroid.filePattern = extractFilePattern(error.file_path);
+        }
+        merged = true;
+        break;
+      }
+    }
+
+    if (!merged) {
+      centroids.push({
+        errorType: error.type,
+        tokens,
+        errorIds: [error.id],
+        filePattern: error.file_path ? extractFilePattern(error.file_path) : null,
+      });
+    }
+  }
+
+  return centroids
+    .filter(c => c.errorIds.length >= 2)
+    .map(c => ({
+      errorType: c.errorType,
+      messageTemplate: c.tokens.join(' '),
+      messageRegex: buildRegex(c.tokens),
+      filePattern: c.filePattern,
+      occurrences: c.errorIds.length,
+      errorIds: c.errorIds,
+      solutionIds: [],
+      confidence: 0,
+      successRate: 0,
+    }));
+}
+
+function extractFilePattern(filePath: string): string {
+  // Extract the meaningful part: last directory + extension
+  const parts = filePath.replace(/\\/g, '/').split('/');
+  const fileName = parts[parts.length - 1] ?? '';
+  const ext = fileName.split('.').pop() ?? '';
+  return ext ? `*.${ext}` : '*';
+}
+
+function buildRegex(tokens: string[]): string {
+  const escaped = tokens.map(t => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  return escaped.join('.*');
+}