@timmeck/brain 1.9.0 → 2.1.0

package/src/services/notification.service.ts

@@ -1,41 +0,0 @@
-import type { NotificationRepository, NotificationRecord } from '../db/repositories/notification.repository.js';
-import { getLogger } from '../utils/logger.js';
-
-export interface CreateNotificationInput {
-  type: string;
-  title: string;
-  message: string;
-  priority?: number;
-  projectId?: number;
-}
-
-export class NotificationService {
-  private logger = getLogger();
-
-  constructor(private notificationRepo: NotificationRepository) {}
-
-  create(input: CreateNotificationInput): number {
-    const id = this.notificationRepo.create({
-      type: input.type,
-      title: input.title,
-      message: input.message,
-      priority: input.priority ?? 0,
-      project_id: input.projectId ?? null,
-    });
-
-    this.logger.info(`Notification created (id=${id}, type=${input.type})`);
-    return id;
-  }
-
-  list(projectId?: number): NotificationRecord[] {
-    return this.notificationRepo.findUnacknowledged(projectId);
-  }
-
-  acknowledge(id: number): void {
-    this.notificationRepo.acknowledge(id);
-  }
-
-  getById(id: number): NotificationRecord | undefined {
-    return this.notificationRepo.getById(id);
-  }
-}

package/src/services/prevention.service.ts

@@ -1,159 +0,0 @@
-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,
-    });
-  }
-
-  checkCodeForPatterns(source: string, filePath?: string): { warnings: Array<{ message: string; severity: string; ruleId?: number }> } {
-    const warnings: Array<{ message: string; severity: string; ruleId?: number }> = [];
-
-    // Check antipatterns against the code itself
-    const globalAntipatterns = this.antipatternRepo.findGlobal();
-    for (const ap of globalAntipatterns) {
-      try {
-        const pattern = new RegExp(ap.pattern, 'i');
-        if (pattern.test(source)) {
-          warnings.push({
-            message: `Code matches known error pattern: ${ap.description}${ap.suggestion ? `. Suggestion: ${ap.suggestion}` : ''}`,
-            severity: ap.severity,
-            ruleId: undefined,
-          });
-        }
-      } catch {
-        // Invalid regex, skip
-      }
-    }
-
-    // Check active rules
-    const rules = this.ruleRepo.findActive();
-    for (const rule of rules) {
-      try {
-        const pattern = new RegExp(rule.pattern, 'i');
-        if (pattern.test(source)) {
-          warnings.push({
-            message: `Code matches learned rule: ${rule.description ?? rule.pattern}. Action: ${rule.action}`,
-            severity: 'warning',
-            ruleId: rule.id,
-          });
-        }
-      } catch {
-        // Invalid regex, skip
-      }
-    }
-
-    return { warnings: warnings.slice(0, 5) };
-  }
-
-  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

@@ -1,98 +0,0 @@
-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();
-  }
-
-  rateInsight(id: number, rating: number, comment?: string): boolean {
-    const clamped = Math.max(-1, Math.min(1, rating)); // -1 (bad), 0 (neutral), 1 (useful)
-    return this.insightRepo.rate(id, clamped, comment);
-  }
-}

package/src/services/solution.service.ts

@@ -1,174 +0,0 @@
-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);
-  }
-
-  analyzeEfficiency(): {
-    avgDurationMs: number;
-    slowSolutions: Array<{ solutionId: number; avgDuration: number; description: string }>;
-    successRateOverall: number;
-    totalAttempts: number;
-  } {
-    const allSolutions = this.solutionRepo.getAll();
-    let totalDuration = 0;
-    let totalAttempts = 0;
-    let totalSuccessRate = 0;
-    let solutionCount = 0;
-    const solutionDurations: Array<{ solutionId: number; avgDuration: number; description: string }> = [];
-
-    for (const solution of allSolutions) {
-      const rate = this.solutionRepo.successRate(solution.id);
-      if (solution.success_count + solution.fail_count > 0) {
-        totalSuccessRate += rate;
-        solutionCount++;
-      }
-
-      // Check attempts for duration data
-      const attempts = this.solutionRepo.getAttempts(solution.id);
-      if (attempts.length > 0) {
-        let solDuration = 0;
-        let solAttemptCount = 0;
-        for (const attempt of attempts) {
-          if (attempt.duration_ms && attempt.duration_ms > 0) {
-            solDuration += attempt.duration_ms;
-            solAttemptCount++;
-            totalDuration += attempt.duration_ms;
-            totalAttempts++;
-          }
-        }
-        if (solAttemptCount > 0) {
-          solutionDurations.push({
-            solutionId: solution.id,
-            avgDuration: solDuration / solAttemptCount,
-            description: solution.description,
-          });
-        }
-      }
-    }
-
-    // Find slow solutions (above 2x average)
-    const avgDurationMs = totalAttempts > 0 ? totalDuration / totalAttempts : 0;
-    const slowSolutions = solutionDurations
-      .filter(s => s.avgDuration > avgDurationMs * 2)
-      .sort((a, b) => b.avgDuration - a.avgDuration)
-      .slice(0, 10);
-
-    return {
-      avgDurationMs,
-      slowSolutions,
-      successRateOverall: solutionCount > 0 ? totalSuccessRate / solutionCount : 0,
-      totalAttempts,
-    };
-  }
-}

package/src/services/synapse.service.ts

@@ -1,59 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

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