@timmeck/brain 1.9.0 → 2.1.0

package/src/ipc/router.ts

@@ -1,133 +0,0 @@
-import { getLogger } from '../utils/logger.js';
-
-const logger = getLogger();
-import type { ErrorService } from '../services/error.service.js';
-import type { SolutionService } from '../services/solution.service.js';
-import type { TerminalService } from '../services/terminal.service.js';
-import type { PreventionService } from '../services/prevention.service.js';
-import type { CodeService } from '../services/code.service.js';
-import type { SynapseService } from '../services/synapse.service.js';
-import type { ResearchService } from '../services/research.service.js';
-import type { NotificationService } from '../services/notification.service.js';
-import type { AnalyticsService } from '../services/analytics.service.js';
-import type { GitService } from '../services/git.service.js';
-import type { LearningEngine, LearningCycleResult } from '../learning/learning-engine.js';
-
-export interface Services {
-  error: ErrorService;
-  solution: SolutionService;
-  terminal: TerminalService;
-  prevention: PreventionService;
-  code: CodeService;
-  synapse: SynapseService;
-  research: ResearchService;
-  notification: NotificationService;
-  analytics: AnalyticsService;
-  git: GitService;
-  learning?: LearningEngine;
-}
-
-type MethodHandler = (params: unknown) => unknown;
-
-export class IpcRouter {
-  private methods: Map<string, MethodHandler>;
-
-  constructor(private services: Services) {
-    this.methods = this.buildMethodMap();
-  }
-
-  handle(method: string, params: unknown): unknown {
-    const handler = this.methods.get(method);
-    if (!handler) {
-      throw new Error(`Unknown method: ${method}`);
-    }
-
-    logger.debug(`IPC: ${method}`, { params });
-    const result = handler(params);
-    logger.debug(`IPC: ${method} → done`);
-    return result;
-  }
-
-  listMethods(): string[] {
-    return [...this.methods.keys()];
-  }
-
-  private buildMethodMap(): Map<string, MethodHandler> {
-    const s = this.services;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const p = (params: unknown) => params as any;
-
-    return new Map<string, MethodHandler>([
-      // Terminal Lifecycle
-      ['terminal.register',       (params) => s.terminal.register(p(params))],
-      ['terminal.heartbeat',      (params) => s.terminal.heartbeat(p(params).uuid)],
-      ['terminal.disconnect',     (params) => s.terminal.disconnect(p(params).uuid)],
-
-      // Error Brain
-      ['error.report',            (params) => s.error.report(p(params))],
-      ['error.query',             (params) => s.error.query(p(params))],
-      ['error.match',             (params) => s.error.matchSimilar(p(params).error_id ?? p(params).errorId)],
-      ['error.resolve',           (params) => s.error.resolve(p(params).error_id ?? p(params).errorId, p(params).solution_id ?? p(params).solutionId)],
-      ['error.get',               (params) => s.error.getById(p(params).id)],
-      ['error.chain',             (params) => s.error.getErrorChain(p(params).error_id ?? p(params).errorId ?? p(params).id)],
-
-      // Solutions
-      ['solution.report',         (params) => s.solution.report(p(params))],
-      ['solution.query',          (params) => s.solution.findForError(p(params).error_id ?? p(params).errorId)],
-      ['solution.rate',           (params) => s.solution.rateOutcome(p(params))],
-      ['solution.attempt',        (params) => s.solution.rateOutcome({ ...p(params), success: false })],
-      ['solution.efficiency',     () => s.solution.analyzeEfficiency()],
-
-      // Projects
-      ['project.list',            () => s.code.listProjects()],
-
-      // Code Brain
-      ['code.analyze',            (params) => s.code.analyzeAndRegister(p(params))],
-      ['code.find',               (params) => s.code.findReusable(p(params))],
-      ['code.similarity',         (params) => s.code.checkSimilarity(p(params).source, p(params).language)],
-      ['code.modules',            (params) => s.code.listModules(p(params)?.projectId, p(params)?.language, p(params)?.limit)],
-      ['code.get',                (params) => s.code.getById(p(params).id)],
-
-      // Prevention
-      ['prevention.check',        (params) => s.prevention.checkRules(p(params).errorType, p(params).message, p(params).projectId)],
-      ['prevention.antipatterns',  (params) => s.prevention.checkAntipatterns(p(params).errorType ?? '', p(params).message ?? p(params).error_output ?? '', p(params).projectId)],
-      ['prevention.checkCode',    (params) => s.prevention.checkCodeForPatterns(p(params).source, p(params).filePath)],
-
-      // Synapses
-      ['synapse.context',         (params) => s.synapse.getErrorContext(p(params).errorId ?? p(params).error_id ?? p(params).node_id)],
-      ['synapse.path',            (params) => s.synapse.findPath(p(params).from_type ?? p(params).fromType, p(params).from_id ?? p(params).fromId, p(params).to_type ?? p(params).toType, p(params).to_id ?? p(params).toId)],
-      ['synapse.related',         (params) => s.synapse.getRelated(p(params))],
-      ['synapse.stats',           () => s.synapse.getNetworkStats()],
-
-      // Research / Insights
-      ['research.insights',       (params) => s.research.getInsights(p(params))],
-      ['insight.rate',            (params) => s.research.rateInsight(p(params).id, p(params).rating, p(params).comment)],
-      ['research.suggest',        (params) => s.research.getInsights({ limit: 10, activeOnly: true, ...p(params) })],
-      ['research.trends',         (params) => s.research.getTrends(p(params)?.projectId, p(params)?.windowDays)],
-
-      // Notifications
-      ['notification.list',       (params) => s.notification.list(p(params)?.projectId)],
-      ['notification.ack',        (params) => s.notification.acknowledge(p(params).id)],
-
-      // Analytics
-      ['analytics.summary',       (params) => s.analytics.getSummary(p(params)?.projectId)],
-      ['analytics.network',       (params) => s.analytics.getNetworkOverview(p(params)?.limit)],
-      ['analytics.health',        (params) => s.analytics.computeHealthScore(p(params)?.projectId)],
-      ['analytics.timeline',      (params) => s.analytics.getTimeSeries(p(params)?.projectId, p(params)?.days)],
-      ['analytics.explain',       (params) => s.analytics.explainError(p(params).errorId ?? p(params).error_id)],
-
-      // Git
-      ['git.context',             (params) => s.git.getGitContext(p(params)?.cwd)],
-      ['git.linkError',           (params) => s.git.linkErrorToCommit(p(params).errorId, p(params).projectId, p(params).commitHash, p(params).relationship)],
-      ['git.errorCommits',        (params) => s.git.findIntroducingCommit(p(params).errorId ?? p(params).error_id)],
-      ['git.commitErrors',        (params) => s.git.findErrorsByCommit(p(params).commitHash ?? p(params).commit_hash)],
-      ['git.diff',                (params) => s.git.captureDiff(p(params)?.cwd)],
-
-      // Learning
-      ['learning.run',            () => {
-        if (!s.learning) throw new Error('Learning engine not available');
-        return s.learning.runCycle();
-      }],
-    ]);
-  }
-}

package/src/ipc/server.ts

@@ -1,176 +0,0 @@
-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/confidence-scorer.ts

@@ -1,80 +0,0 @@
-/**
- * Wilson Score Interval for low-sample-size confidence.
- * Prevents unrealistic 100% from single success/failure.
- */
-export function wilsonScore(successes: number, total: number, z: number = 1.96): number {
-  if (total === 0) return 0;
-
-  const p = successes / total;
-  const z2 = z * z;
-  const n = total;
-
-  const numerator = p + z2 / (2 * n);
-  const denominator = 1 + z2 / n;
-  const margin = z * Math.sqrt((p * (1 - p) + z2 / (4 * n)) / n) / denominator;
-
-  // Lower bound of Wilson interval = conservative estimate
-  return Math.max(0, numerator / denominator - margin);
-}
-
-/**
- * Time-decayed confidence: recent successes count more.
- */
-export function timeDecayedConfidence(
-  successes: number,
-  total: number,
-  lastUsedAt: string,
-  halfLifeDays: number,
-): number {
-  const base = wilsonScore(successes, total);
-  const ageDays = (Date.now() - new Date(lastUsedAt).getTime()) / (1000 * 60 * 60 * 24);
-  const decay = Math.pow(0.5, ageDays / halfLifeDays);
-  return base * decay;
-}
-
-/**
- * Combined confidence from success rate + usage frequency + recency.
- */
-export function computeConfidence(
-  successCount: number,
-  failCount: number,
-  lastUsedAt: string,
-  halfLifeDays: number = 30,
-): number {
-  const total = successCount + failCount;
-  if (total === 0) return 0;
-  return timeDecayedConfidence(successCount, total, lastUsedAt, halfLifeDays);
-}
-
-export interface AdaptiveThresholds {
-  minOccurrences: number;
-  minSuccessRate: number;
-  minConfidence: number;
-  pruneThreshold: number;
-}
-
-/**
- * Compute adaptive thresholds based on data volume.
- * Users with lots of data need stricter thresholds; users with little data need looser ones.
- */
-export function computeAdaptiveThresholds(
-  totalErrors: number,
-  totalSolutions: number,
-  baseConfig: { minOccurrences: number; minSuccessRate: number; minConfidence: number; pruneThreshold: number },
-): AdaptiveThresholds {
-  // Scale factor: 1.0 at 50 errors, increases with more data
-  const errorScale = Math.min(2.0, Math.max(0.5, totalErrors / 50));
-  const solutionScale = Math.min(2.0, Math.max(0.5, totalSolutions / 20));
-  const dataScale = (errorScale + solutionScale) / 2;
-
-  return {
-    // More data → require more occurrences before learning
-    minOccurrences: Math.max(2, Math.round(baseConfig.minOccurrences * dataScale)),
-    // More data → can afford higher success rate requirement
-    minSuccessRate: Math.min(0.95, baseConfig.minSuccessRate * (0.85 + dataScale * 0.15)),
-    // More data → higher confidence threshold
-    minConfidence: Math.min(0.90, baseConfig.minConfidence * (0.85 + dataScale * 0.15)),
-    // More data → stricter pruning
-    pruneThreshold: Math.max(0.10, baseConfig.pruneThreshold * (1.1 - dataScale * 0.1)),
-  };
-}

package/src/learning/decay.ts

@@ -1,46 +0,0 @@
-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/learning-engine.ts

@@ -1,170 +0,0 @@
-import type { LearningConfig } from '../types/config.types.js';
-import type { ErrorRepository } from '../db/repositories/error.repository.js';
-import type { SolutionRepository } from '../db/repositories/solution.repository.js';
-import type { RuleRepository } from '../db/repositories/rule.repository.js';
-import type { AntipatternRepository } from '../db/repositories/antipattern.repository.js';
-import type { SynapseManager } from '../synapses/synapse-manager.js';
-import { extractPatterns } from './pattern-extractor.js';
-import { generateRules, persistRules } from './rule-generator.js';
-import { shouldPruneRule } from './decay.js';
-import { computeAdaptiveThresholds, type AdaptiveThresholds } from './confidence-scorer.js';
-import { getLogger } from '../utils/logger.js';
-
-export interface LearningCycleResult {
-  newPatterns: number;
-  updatedRules: number;
-  prunedRules: number;
-  newAntipatterns: number;
-  duration: number;
-}
-
-export class LearningEngine {
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private logger = getLogger();
-  private lastCycleAt: string | null = null;
-
-  constructor(
-    private config: LearningConfig,
-    private errorRepo: ErrorRepository,
-    private solutionRepo: SolutionRepository,
-    private ruleRepo: RuleRepository,
-    private antipatternRepo: AntipatternRepository,
-    private synapseManager: SynapseManager,
-  ) {}
-
-  start(): void {
-    this.logger.info(`Learning engine starting (interval: ${this.config.intervalMs}ms)`);
-    this.timer = setInterval(() => this.runCycle(), this.config.intervalMs);
-  }
-
-  stop(): void {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    this.logger.info('Learning engine stopped');
-  }
-
-  runCycle(): LearningCycleResult {
-    const start = Date.now();
-    this.logger.info('Learning cycle starting');
-
-    const result: LearningCycleResult = {
-      newPatterns: 0,
-      updatedRules: 0,
-      prunedRules: 0,
-      newAntipatterns: 0,
-      duration: 0,
-    };
-
-    // Phase 0: Compute adaptive thresholds
-    const totalErrors = this.errorRepo.findUnresolved().length + this.errorRepo.countSince(new Date(0).toISOString());
-    const totalSolutions = this.solutionRepo.getAll().length;
-    const adaptive = computeAdaptiveThresholds(totalErrors, totalSolutions, this.config);
-    this.logger.debug(`Adaptive thresholds: minOcc=${adaptive.minOccurrences}, minSuccess=${adaptive.minSuccessRate.toFixed(2)}, minConf=${adaptive.minConfidence.toFixed(2)}`);
-
-    // Phase 1: Collect recent errors
-    const since = this.lastCycleAt ?? new Date(Date.now() - this.config.intervalMs).toISOString();
-    const recentErrors = this.errorRepo.findUnresolved();
-
-    // Phase 2: Extract patterns
-    const patterns = extractPatterns(recentErrors, adaptive.minSuccessRate);
-    result.newPatterns = patterns.length;
-
-    // Phase 3: Enrich patterns with solution data
-    for (const pattern of patterns) {
-      let totalSuccess = 0;
-      let totalAttempts = 0;
-
-      for (const errorId of pattern.errorIds) {
-        const solutions = this.solutionRepo.findForError(errorId);
-        pattern.solutionIds.push(...solutions.map(s => s.id));
-
-        for (const sol of solutions) {
-          const rate = this.solutionRepo.successRate(sol.id);
-          totalSuccess += rate;
-          totalAttempts++;
-        }
-      }
-
-      pattern.successRate = totalAttempts > 0 ? totalSuccess / totalAttempts : 0;
-      pattern.confidence = Math.min(
-        0.95,
-        pattern.successRate * 0.6 + Math.min(1, pattern.occurrences / 10) * 0.4,
-      );
-    }
-
-    // Phase 4: Generate rules from patterns (using adaptive thresholds)
-    const adaptiveConfig = { ...this.config, ...adaptive };
-    const rules = generateRules(patterns, adaptiveConfig);
-    result.updatedRules = persistRules(rules, this.ruleRepo);
-
-    // Phase 5: Prune weak rules (using adaptive thresholds)
-    const activeRules = this.ruleRepo.findActive();
-    for (const rule of activeRules) {
-      if (shouldPruneRule(
-        rule.confidence,
-        0, // rejection count not tracked yet
-        rule.occurrences,
-        adaptive.pruneThreshold,
-        this.config.maxRejectionRate,
-      )) {
-        this.ruleRepo.update(rule.id, { active: 0 });
-        result.prunedRules++;
-      }
-    }
-
-    // Phase 6: Detect antipatterns
-    result.newAntipatterns = this.detectAntipatterns();
-
-    // Phase 7: Run synapse decay
-    this.synapseManager.runDecay();
-
-    this.lastCycleAt = new Date().toISOString();
-    result.duration = Date.now() - start;
-    this.logger.info(`Learning cycle complete: ${result.newPatterns} patterns, ${result.updatedRules} rules, ${result.prunedRules} pruned, ${result.newAntipatterns} antipatterns (${result.duration}ms)`);
-
-    return result;
-  }
-
-  private detectAntipatterns(): number {
-    const unresolvedErrors = this.errorRepo.findUnresolved();
-    const recurring = unresolvedErrors.filter(e => e.occurrence_count >= this.config.minOccurrences);
-    let count = 0;
-
-    for (const error of recurring) {
-      const solutions = this.solutionRepo.findForError(error.id);
-      const allFailed = solutions.length > 0 && solutions.every(s => {
-        const rate = this.solutionRepo.successRate(s.id);
-        return rate < 0.3;
-      });
-
-      if (solutions.length >= 2 && allFailed) {
-        // Check if antipattern already exists
-        const existing = this.antipatternRepo.findByProject(error.project_id);
-        const alreadyDetected = existing.some(ap =>
-          ap.pattern.includes(error.type) && ap.description.includes(error.message.substring(0, 30))
-        );
-
-        if (!alreadyDetected) {
-          this.antipatternRepo.create({
-            pattern: `${error.type}.*${error.message.substring(0, 40).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`,
-            description: `Recurring error without solution: ${error.type}: ${error.message}`,
-            severity: solutions.length >= 4 ? 'critical' : 'warning',
-            suggestion: null,
-            occurrences: error.occurrence_count,
-            project_id: error.project_id,
-            global: 0,
-          });
-          count++;
-        }
-      }
-    }
-
-    return count;
-  }
-
-  getLastCycleAt(): string | null {
-    return this.lastCycleAt;
-  }
-}

package/src/learning/pattern-extractor.ts

@@ -1,90 +0,0 @@
-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('.*');
-}