@timmeck/brain 1.0.0

package/src/services/prevention.service.ts

@@ -0,0 +1,119 @@
+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 { getLogger } from '../utils/logger.js';
+
+export interface RuleCheckResult {
+  matched: boolean;
+  ruleId: number;
+  action: string;
+  description: string | null;
+  confidence: number;
+}
+
+export interface AntipatternCheckResult {
+  matched: boolean;
+  antipatternId: number;
+  pattern: string;
+  description: string;
+  severity: string;
+  suggestion: string | null;
+}
+
+export class PreventionService {
+  private logger = getLogger();
+
+  constructor(
+    private ruleRepo: RuleRepository,
+    private antipatternRepo: AntipatternRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  checkRules(errorType: string, message: string, projectId?: number): RuleCheckResult[] {
+    const rules = this.ruleRepo.findActive(projectId);
+    const results: RuleCheckResult[] = [];
+
+    for (const rule of rules) {
+      try {
+        const pattern = new RegExp(rule.pattern, 'i');
+        const input = `${errorType}: ${message}`;
+
+        if (pattern.test(input)) {
+          results.push({
+            matched: true,
+            ruleId: rule.id,
+            action: rule.action,
+            description: rule.description,
+            confidence: rule.confidence,
+          });
+
+          this.logger.debug(`Rule ${rule.id} matched: ${rule.pattern}`);
+        }
+      } catch {
+        // Invalid regex in rule pattern, skip
+        this.logger.warn(`Invalid regex in rule ${rule.id}: ${rule.pattern}`);
+      }
+    }
+
+    return results.sort((a, b) => b.confidence - a.confidence);
+  }
+
+  checkAntipatterns(errorType: string, message: string, projectId?: number): AntipatternCheckResult[] {
+    const antipatterns = projectId
+      ? [...this.antipatternRepo.findByProject(projectId), ...this.antipatternRepo.findGlobal()]
+      : this.antipatternRepo.findGlobal();
+
+    const results: AntipatternCheckResult[] = [];
+    const input = `${errorType}: ${message}`;
+
+    for (const ap of antipatterns) {
+      try {
+        const pattern = new RegExp(ap.pattern, 'i');
+        if (pattern.test(input)) {
+          results.push({
+            matched: true,
+            antipatternId: ap.id,
+            pattern: ap.pattern,
+            description: ap.description,
+            severity: ap.severity,
+            suggestion: ap.suggestion,
+          });
+        }
+      } catch {
+        this.logger.warn(`Invalid regex in antipattern ${ap.id}: ${ap.pattern}`);
+      }
+    }
+
+    return results;
+  }
+
+  createRule(data: {
+    pattern: string;
+    action: string;
+    description?: string;
+    confidence?: number;
+    projectId?: number;
+  }): number {
+    return this.ruleRepo.create({
+      pattern: data.pattern,
+      action: data.action,
+      description: data.description ?? null,
+      confidence: data.confidence ?? 0.5,
+      occurrences: 0,
+      active: 1,
+      project_id: data.projectId ?? null,
+    });
+  }
+
+  reportPrevention(ruleId: number, errorId: number): void {
+    const rule = this.ruleRepo.getById(ruleId);
+    if (rule) {
+      this.ruleRepo.update(ruleId, { occurrences: rule.occurrences + 1 });
+      this.synapseManager.strengthen(
+        { type: 'rule', id: ruleId },
+        { type: 'error', id: errorId },
+        'prevents',
+      );
+    }
+  }
+}

package/src/services/research.service.ts

@@ -0,0 +1,93 @@
+import type { InsightRecord } from '../types/research.types.js';
+import type { InsightRepository } from '../db/repositories/insight.repository.js';
+import type { ErrorRepository } from '../db/repositories/error.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface InsightQuery {
+  projectId?: number;
+  type?: string;
+  activeOnly?: boolean;
+  limit?: number;
+}
+
+export interface TrendResult {
+  errorType: string;
+  count: number;
+  direction: 'increasing' | 'decreasing' | 'stable';
+  period: string;
+}
+
+export class ResearchService {
+  private logger = getLogger();
+
+  constructor(
+    private insightRepo: InsightRepository,
+    private errorRepo: ErrorRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  getInsights(query: InsightQuery): InsightRecord[] {
+    if (query.type) {
+      return this.insightRepo.findByType(query.type);
+    }
+    if (query.activeOnly !== false) {
+      return this.insightRepo.findActive(query.projectId);
+    }
+    return this.insightRepo.findActive(query.projectId);
+  }
+
+  createInsight(data: {
+    type: string;
+    title: string;
+    description: string;
+    evidence?: string;
+    priority?: number;
+    projectId?: number;
+    expiresInDays?: number;
+  }): number {
+    const expiresAt = data.expiresInDays
+      ? new Date(Date.now() + data.expiresInDays * 86400000).toISOString()
+      : null;
+
+    const id = this.insightRepo.create({
+      type: data.type as InsightRecord['type'],
+      title: data.title,
+      description: data.description,
+      evidence: data.evidence ?? '[]',
+      priority: data.priority ?? 0,
+      project_id: data.projectId ?? null,
+      active: 1,
+      expires_at: expiresAt,
+    });
+
+    this.logger.info(`Insight created (id=${id}, type=${data.type})`);
+    return id;
+  }
+
+  getTrends(projectId?: number, windowDays: number = 7): TrendResult[] {
+    const now = new Date();
+    const currentStart = new Date(now.getTime() - windowDays * 86400000).toISOString();
+    const previousStart = new Date(now.getTime() - windowDays * 2 * 86400000).toISOString();
+
+    const currentCount = this.errorRepo.countSince(currentStart, projectId);
+    const previousCount = this.errorRepo.countSince(previousStart, projectId) - currentCount;
+
+    const direction = currentCount > previousCount * 1.2
+      ? 'increasing' as const
+      : currentCount < previousCount * 0.8
+        ? 'decreasing' as const
+        : 'stable' as const;
+
+    return [{
+      errorType: 'all',
+      count: currentCount,
+      direction,
+      period: `${windowDays}d`,
+    }];
+  }
+
+  expireOldInsights(): number {
+    return this.insightRepo.expire();
+  }
+}

package/src/services/solution.service.ts

@@ -0,0 +1,116 @@
+import type { SolutionRecord } from '../types/solution.types.js';
+import type { SolutionRepository } from '../db/repositories/solution.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import { getEventBus } from '../utils/events.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface ReportSolutionInput {
+  errorId: number;
+  description: string;
+  commands?: string;
+  codeChange?: string;
+  source?: string;
+}
+
+export interface RateOutcomeInput {
+  errorId: number;
+  solutionId: number;
+  success: boolean;
+  terminalId?: number;
+  output?: string;
+  durationMs?: number;
+}
+
+export class SolutionService {
+  private logger = getLogger();
+  private eventBus = getEventBus();
+
+  constructor(
+    private solutionRepo: SolutionRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  report(input: ReportSolutionInput): number {
+    const solutionId = this.solutionRepo.create({
+      description: input.description,
+      commands: input.commands ?? null,
+      code_change: input.codeChange ?? null,
+      source: input.source ?? 'manual',
+      confidence: 0.5,
+    });
+
+    this.solutionRepo.linkToError(input.errorId, solutionId);
+
+    // Create synapse: solution solves error
+    this.synapseManager.strengthen(
+      { type: 'solution', id: solutionId },
+      { type: 'error', id: input.errorId },
+      'solves',
+    );
+
+    this.eventBus.emit('solution:created', { solutionId });
+    this.logger.info(`Solution reported (id=${solutionId}) for error ${input.errorId}`);
+
+    return solutionId;
+  }
+
+  rateOutcome(input: RateOutcomeInput): void {
+    // Record the attempt
+    const errorSolutions = this.solutionRepo.findForError(input.errorId);
+    const link = errorSolutions.find(s => s.id === input.solutionId);
+    if (!link) {
+      this.solutionRepo.linkToError(input.errorId, input.solutionId);
+    }
+
+    // Find the error_solution link id via DB
+    this.solutionRepo.recordAttempt({
+      errorSolutionId: input.errorId, // will be resolved via link
+      terminalId: input.terminalId,
+      success: input.success ? 1 : 0,
+      output: input.output,
+      durationMs: input.durationMs,
+    });
+
+    // Update synapse
+    if (input.success) {
+      this.synapseManager.strengthen(
+        { type: 'solution', id: input.solutionId },
+        { type: 'error', id: input.errorId },
+        'solves',
+        { outcome: 'success' },
+      );
+      // Update solution confidence based on success rate
+      const rate = this.solutionRepo.successRate(input.solutionId);
+      this.solutionRepo.update(input.solutionId, { confidence: rate });
+    } else {
+      const synapse = this.synapseManager.find(
+        { type: 'solution', id: input.solutionId },
+        { type: 'error', id: input.errorId },
+        'solves',
+      );
+      if (synapse) {
+        this.synapseManager.weaken(synapse.id, 0.7);
+      }
+      const rate = this.solutionRepo.successRate(input.solutionId);
+      this.solutionRepo.update(input.solutionId, { confidence: rate });
+    }
+
+    this.eventBus.emit('solution:applied', {
+      errorId: input.errorId,
+      solutionId: input.solutionId,
+      success: input.success,
+    });
+  }
+
+  findForError(errorId: number): SolutionRecord[] {
+    return this.solutionRepo.findForError(errorId);
+  }
+
+  getById(id: number): SolutionRecord | undefined {
+    return this.solutionRepo.getById(id);
+  }
+
+  successRate(solutionId: number): number {
+    return this.solutionRepo.successRate(solutionId);
+  }
+}

package/src/services/synapse.service.ts

@@ -0,0 +1,59 @@
+import type { NodeType, SynapseRecord, NetworkStats } from '../types/synapse.types.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import type { ActivationResult } from '../synapses/activation.js';
+import type { SynapsePath } from '../synapses/pathfinder.js';
+
+export interface ErrorContext {
+  solutions: ActivationResult[];
+  relatedErrors: ActivationResult[];
+  relevantModules: ActivationResult[];
+  preventionRules: ActivationResult[];
+  insights: ActivationResult[];
+}
+
+export interface RelatedQuery {
+  nodeType: NodeType;
+  nodeId: number;
+  maxDepth?: number;
+  minWeight?: number;
+}
+
+export class SynapseService {
+  constructor(private manager: SynapseManager) {}
+
+  getErrorContext(errorId: number): ErrorContext {
+    return this.manager.getErrorContext(errorId);
+  }
+
+  findPath(
+    fromType: NodeType,
+    fromId: number,
+    toType: NodeType,
+    toId: number,
+  ): SynapsePath | null {
+    return this.manager.findPath(
+      { type: fromType, id: fromId },
+      { type: toType, id: toId },
+    );
+  }
+
+  getRelated(query: RelatedQuery): ActivationResult[] {
+    return this.manager.activate(
+      { type: query.nodeType, id: query.nodeId },
+      query.maxDepth,
+      query.minWeight,
+    );
+  }
+
+  getNetworkStats(): NetworkStats {
+    return this.manager.getNetworkStats();
+  }
+
+  getStrongestSynapses(limit?: number): SynapseRecord[] {
+    return this.manager.getStrongestSynapses(limit);
+  }
+
+  runDecay(): { decayed: number; pruned: number } {
+    return this.manager.runDecay();
+  }
+}

package/src/services/terminal.service.ts

@@ -0,0 +1,81 @@
+import type { TerminalRepository } from '../db/repositories/terminal.repository.js';
+import { getEventBus } from '../utils/events.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface RegisterTerminalInput {
+  uuid: string;
+  projectId?: number;
+  pid?: number;
+  shell?: string;
+  cwd?: string;
+}
+
+export class TerminalService {
+  private logger = getLogger();
+  private eventBus = getEventBus();
+
+  constructor(
+    private terminalRepo: TerminalRepository,
+    private staleTimeout: number,
+  ) {}
+
+  register(input: RegisterTerminalInput): number {
+    const existing = this.terminalRepo.findByUuid(input.uuid);
+    if (existing) {
+      this.terminalRepo.update(existing.id, {
+        last_seen: new Date().toISOString(),
+        disconnected_at: null,
+        project_id: input.projectId ?? existing.project_id,
+        cwd: input.cwd ?? existing.cwd,
+      });
+      this.logger.info(`Terminal reconnected (id=${existing.id}, uuid=${input.uuid})`);
+      this.eventBus.emit('terminal:connected', { terminalId: existing.id, uuid: input.uuid });
+      return existing.id;
+    }
+
+    const id = this.terminalRepo.create({
+      uuid: input.uuid,
+      project_id: input.projectId ?? null,
+      pid: input.pid ?? null,
+      shell: input.shell ?? null,
+      cwd: input.cwd ?? null,
+    });
+
+    this.logger.info(`Terminal registered (id=${id}, uuid=${input.uuid})`);
+    this.eventBus.emit('terminal:connected', { terminalId: id, uuid: input.uuid });
+    return id;
+  }
+
+  heartbeat(uuid: string): void {
+    const terminal = this.terminalRepo.findByUuid(uuid);
+    if (terminal) {
+      this.terminalRepo.update(terminal.id, {
+        last_seen: new Date().toISOString(),
+      });
+    }
+  }
+
+  disconnect(uuid: string): void {
+    const terminal = this.terminalRepo.findByUuid(uuid);
+    if (terminal) {
+      this.terminalRepo.update(terminal.id, {
+        disconnected_at: new Date().toISOString(),
+      });
+      this.eventBus.emit('terminal:disconnected', { terminalId: terminal.id });
+      this.logger.info(`Terminal disconnected (id=${terminal.id}, uuid=${uuid})`);
+    }
+  }
+
+  cleanup(): number {
+    const cutoff = new Date(Date.now() - this.staleTimeout).toISOString();
+    const count = this.terminalRepo.cleanupStale(cutoff);
+    if (count > 0) {
+      this.logger.info(`Cleaned up ${count} stale terminal(s)`);
+    }
+    return count;
+  }
+
+  getConnected() {
+    return this.terminalRepo.findConnected();
+  }
+}

package/src/synapses/activation.ts

@@ -0,0 +1,80 @@
+import type { NodeType } from '../types/synapse.types.js';
+import type { SynapseRepository } from '../db/repositories/synapse.repository.js';
+
+export interface ActivationNode {
+  type: NodeType;
+  id: number;
+}
+
+export interface ActivationResult {
+  node: ActivationNode;
+  activation: number;
+  depth: number;
+  path: string[];
+}
+
+export function spreadingActivation(
+  repo: SynapseRepository,
+  startNode: ActivationNode,
+  maxDepth: number = 3,
+  minWeight: number = 0.2,
+): ActivationResult[] {
+  const visited = new Set<string>();
+  const results: ActivationResult[] = [];
+
+  const queue: Array<{
+    node: ActivationNode;
+    depth: number;
+    pathWeight: number;
+    path: string[];
+  }> = [{ node: startNode, depth: 0, pathWeight: 1.0, path: [] }];
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const key = `${current.node.type}:${current.node.id}`;
+
+    if (visited.has(key)) continue;
+    if (current.depth > maxDepth) continue;
+    if (current.pathWeight < minWeight) continue;
+
+    visited.add(key);
+
+    if (current.depth > 0) {
+      results.push({
+        node: current.node,
+        activation: current.pathWeight,
+        depth: current.depth,
+        path: current.path,
+      });
+    }
+
+    const outgoing = repo.getOutgoing(current.node.type, current.node.id);
+    const incoming = repo.getIncoming(current.node.type, current.node.id);
+
+    for (const synapse of outgoing) {
+      const nextWeight = current.pathWeight * synapse.weight;
+      if (nextWeight >= minWeight) {
+        queue.push({
+          node: { type: synapse.target_type, id: synapse.target_id },
+          depth: current.depth + 1,
+          pathWeight: nextWeight,
+          path: [...current.path, `--${synapse.synapse_type}-->`],
+        });
+      }
+    }
+
+    for (const synapse of incoming) {
+      const nextWeight = current.pathWeight * synapse.weight;
+      if (nextWeight >= minWeight) {
+        queue.push({
+          node: { type: synapse.source_type, id: synapse.source_id },
+          depth: current.depth + 1,
+          pathWeight: nextWeight,
+          path: [...current.path, `<--${synapse.synapse_type}--`],
+        });
+      }
+    }
+  }
+
+  return results.sort((a, b) => b.activation - a.activation);
+}

package/src/synapses/decay.ts

@@ -0,0 +1,38 @@
+import type { SynapseRepository } from '../db/repositories/synapse.repository.js';
+
+export interface DecayConfig {
+  decayHalfLifeDays: number;
+  decayAfterDays: number;
+  pruneThreshold: number;
+}
+
+export function timeDecayFactor(lastActivatedAt: string, halfLifeDays: number): number {
+  const now = Date.now();
+  const activated = new Date(lastActivatedAt).getTime();
+  const ageDays = (now - activated) / (1000 * 60 * 60 * 24);
+  return Math.pow(0.5, ageDays / halfLifeDays);
+}
+
+export function decayAll(repo: SynapseRepository, config: DecayConfig): { decayed: number; pruned: number } {
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - config.decayAfterDays);
+
+  const stale = repo.findInactiveSince(cutoff.toISOString());
+  let pruned = 0;
+  let decayed = 0;
+
+  for (const synapse of stale) {
+    const factor = timeDecayFactor(synapse.last_activated_at, config.decayHalfLifeDays);
+    const newWeight = synapse.weight * factor;
+
+    if (newWeight < config.pruneThreshold) {
+      repo.delete(synapse.id);
+      pruned++;
+    } else {
+      repo.update(synapse.id, { weight: newWeight });
+      decayed++;
+    }
+  }
+
+  return { decayed, pruned };
+}

package/src/synapses/hebbian.ts

@@ -0,0 +1,69 @@
+import type { SynapseRecord, NodeType, SynapseType } from '../types/synapse.types.js';
+import type { SynapseRepository } from '../db/repositories/synapse.repository.js';
+
+export interface HebbianConfig {
+  initialWeight: number;
+  learningRate: number;
+  pruneThreshold: number;
+}
+
+export interface NodeRef {
+  type: NodeType;
+  id: number;
+}
+
+export function strengthen(
+  repo: SynapseRepository,
+  source: NodeRef,
+  target: NodeRef,
+  synapseType: SynapseType,
+  config: HebbianConfig,
+  context?: Record<string, unknown>,
+): SynapseRecord {
+  const existing = repo.findBySourceTarget(
+    source.type, source.id, target.type, target.id, synapseType,
+  );
+
+  if (existing) {
+    // Hebbian: weight grows logarithmically, saturates at 1.0
+    const newWeight = Math.min(
+      1.0,
+      existing.weight + (1.0 - existing.weight) * config.learningRate,
+    );
+    repo.update(existing.id, {
+      weight: newWeight,
+      activation_count: existing.activation_count + 1,
+      last_activated_at: new Date().toISOString(),
+    });
+    return { ...existing, weight: newWeight, activation_count: existing.activation_count + 1 };
+  }
+
+  const id = repo.create({
+    source_type: source.type,
+    source_id: source.id,
+    target_type: target.type,
+    target_id: target.id,
+    synapse_type: synapseType,
+    weight: config.initialWeight,
+    metadata: context ? JSON.stringify(context) : null,
+  });
+
+  return repo.getById(id)!;
+}
+
+export function weaken(
+  repo: SynapseRepository,
+  synapseId: number,
+  config: HebbianConfig,
+  factor: number = 0.5,
+): void {
+  const synapse = repo.getById(synapseId);
+  if (!synapse) return;
+
+  const newWeight = synapse.weight * factor;
+  if (newWeight < config.pruneThreshold) {
+    repo.delete(synapseId);
+  } else {
+    repo.update(synapseId, { weight: newWeight });
+  }
+}