@timmeck/brain 1.0.0

package/src/ipc/router.ts

@@ -0,0 +1,106 @@
+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';
+
+export interface Services {
+  error: ErrorService;
+  solution: SolutionService;
+  terminal: TerminalService;
+  prevention: PreventionService;
+  code: CodeService;
+  synapse: SynapseService;
+  research: ResearchService;
+  notification: NotificationService;
+  analytics: AnalyticsService;
+}
+
+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)],
+
+      // 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 })],
+
+      // 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)],
+      ['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)],
+
+      // 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))],
+      ['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)],
+    ]);
+  }
+}

package/src/ipc/server.ts

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

package/src/learning/confidence-scorer.ts

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

package/src/learning/decay.ts

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

package/src/learning/learning-engine.ts

@@ -0,0 +1,162 @@
+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 { 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 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, 0.7);
+    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
+    const rules = generateRules(patterns, this.config);
+    result.updatedRules = persistRules(rules, this.ruleRepo);
+
+    // Phase 5: Prune weak rules
+    const activeRules = this.ruleRepo.findActive();
+    for (const rule of activeRules) {
+      if (shouldPruneRule(
+        rule.confidence,
+        0, // rejection count not tracked yet
+        rule.occurrences,
+        this.config.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

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

package/src/learning/rule-generator.ts

@@ -0,0 +1,74 @@
+import type { LearningConfig } from '../types/config.types.js';
+import type { RuleRepository } from '../db/repositories/rule.repository.js';
+import type { ErrorPattern } from './pattern-extractor.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface GeneratedRule {
+  pattern: string;
+  action: string;
+  description: string;
+  confidence: number;
+  sourceErrorIds: number[];
+}
+
+/**
+ * Generate prevention rules from extracted patterns.
+ */
+export function generateRules(
+  patterns: ErrorPattern[],
+  config: LearningConfig,
+): GeneratedRule[] {
+  return patterns
+    .filter(p =>
+      p.occurrences >= config.minOccurrences &&
+      p.confidence >= config.minConfidence,
+    )
+    .map(pattern => ({
+      pattern: pattern.messageRegex,
+      action: pattern.confidence >= 0.90
+        ? `Auto-fix available for ${pattern.errorType}`
+        : `Suggestion: check ${pattern.errorType} pattern (${pattern.occurrences} occurrences)`,
+      description: `Auto-generated from ${pattern.occurrences} occurrences of ${pattern.errorType}`,
+      confidence: pattern.confidence,
+      sourceErrorIds: pattern.errorIds,
+    }));
+}
+
+/**
+ * Persist generated rules to the database.
+ */
+export function persistRules(
+  rules: GeneratedRule[],
+  ruleRepo: RuleRepository,
+  projectId?: number,
+): number {
+  const logger = getLogger();
+  let created = 0;
+
+  for (const rule of rules) {
+    // Check if similar rule already exists
+    const existing = ruleRepo.findByPattern(rule.pattern);
+    if (existing.length > 0) {
+      // Update confidence of existing rule
+      const best = existing[0]!;
+      if (rule.confidence > best.confidence) {
+        ruleRepo.update(best.id, { confidence: rule.confidence });
+      }
+      continue;
+    }
+
+    ruleRepo.create({
+      pattern: rule.pattern,
+      action: rule.action,
+      description: rule.description,
+      confidence: rule.confidence,
+      occurrences: 0,
+      active: 1,
+      project_id: projectId ?? null,
+    });
+    created++;
+    logger.info(`New rule generated: ${rule.pattern.substring(0, 50)}...`);
+  }
+
+  return created;
+}