@timmeck/brain 1.0.0 → 1.1.1

package/src/services/error.service.ts

@@ -1,164 +1,164 @@
-import type { ErrorRecord } from '../types/error.types.js';
-import type { ErrorRepository } from '../db/repositories/error.repository.js';
-import type { ProjectRepository } from '../db/repositories/project.repository.js';
-import type { SynapseManager } from '../synapses/synapse-manager.js';
-import { parseError } from '../parsing/error-parser.js';
-import { generateFingerprint } from '../matching/fingerprint.js';
-import { matchError, type MatchResult } from '../matching/error-matcher.js';
-import { getEventBus } from '../utils/events.js';
-import { getLogger } from '../utils/logger.js';
-
-export interface ReportErrorInput {
-  project: string;
-  errorOutput: string;
-  filePath?: string;
-  terminalId?: number;
-}
-
-export interface ErrorQueryInput {
-  projectId?: number;
-  resolved?: boolean;
-  search?: string;
-  limit?: number;
-}
-
-export class ErrorService {
-  private logger = getLogger();
-  private eventBus = getEventBus();
-
-  constructor(
-    private errorRepo: ErrorRepository,
-    private projectRepo: ProjectRepository,
-    private synapseManager: SynapseManager,
-  ) {}
-
-  report(input: ReportErrorInput): { errorId: number; isNew: boolean; matches: MatchResult[] } {
-    // 1. Ensure project exists
-    let project = this.projectRepo.findByName(input.project);
-    if (!project) {
-      const id = this.projectRepo.create({ name: input.project, path: null, language: null, framework: null });
-      project = this.projectRepo.getById(id)!;
-    }
-
-    // 2. Parse the error
-    const parsed = parseError(input.errorOutput);
-    if (!parsed) {
-      this.logger.warn('Could not parse error output');
-      const errorId = this.errorRepo.create({
-        project_id: project.id,
-        terminal_id: input.terminalId ?? null,
-        fingerprint: '',
-        type: 'UnknownError',
-        message: input.errorOutput.split('\n')[0] ?? input.errorOutput,
-        raw_output: input.errorOutput,
-        context: null,
-        file_path: input.filePath ?? null,
-        line_number: null,
-        column_number: null,
-      });
-      return { errorId, isNew: true, matches: [] };
-    }
-
-    // 3. Generate fingerprint
-    const fingerprint = generateFingerprint(parsed.errorType, parsed.message, parsed.frames);
-
-    // 4. Check for existing error with same fingerprint
-    const existing = this.errorRepo.findByFingerprint(fingerprint);
-    if (existing.length > 0) {
-      const err = existing[0]!;
-      this.errorRepo.incrementOccurrence(err.id);
-      this.logger.info(`Known error (id=${err.id}), occurrence incremented`);
-
-      // Strengthen synapse
-      this.synapseManager.strengthen(
-        { type: 'error', id: err.id },
-        { type: 'project', id: project.id },
-        'co_occurs',
-      );
-
-      return { errorId: err.id, isNew: false, matches: [] };
-    }
-
-    // 5. Create new error record
-    const errorId = this.errorRepo.create({
-      project_id: project.id,
-      terminal_id: input.terminalId ?? null,
-      fingerprint,
-      type: parsed.errorType,
-      message: parsed.message,
-      raw_output: input.errorOutput,
-      context: null,
-      file_path: parsed.sourceFile ?? input.filePath ?? null,
-      line_number: parsed.sourceLine ?? null,
-      column_number: null,
-    });
-
-    // 6. Create synapse: error ↔ project
-    this.synapseManager.strengthen(
-      { type: 'error', id: errorId },
-      { type: 'project', id: project.id },
-      'co_occurs',
-    );
-
-    // 7. Find similar errors
-    const candidates = this.errorRepo.findByProject(project.id)
-      .filter(e => e.id !== errorId);
-    const newError = this.errorRepo.getById(errorId)!;
-    const matches = matchError(newError, candidates);
-
-    // 8. Create similarity synapses for strong matches
-    for (const match of matches.filter(m => m.isStrong)) {
-      this.synapseManager.strengthen(
-        { type: 'error', id: errorId },
-        { type: 'error', id: match.errorId },
-        'similar_to',
-      );
-    }
-
-    this.eventBus.emit('error:reported', { errorId, projectId: project.id, fingerprint });
-    this.logger.info(`New error reported (id=${errorId}, type=${parsed.errorType})`);
-
-    return { errorId, isNew: true, matches };
-  }
-
-  query(input: ErrorQueryInput): ErrorRecord[] {
-    if (input.search) {
-      return this.errorRepo.search(input.search);
-    }
-    if (input.resolved === false) {
-      return this.errorRepo.findUnresolved(input.projectId);
-    }
-    if (input.projectId) {
-      return this.errorRepo.findByProject(input.projectId);
-    }
-    return [];
-  }
-
-  matchSimilar(errorId: number): MatchResult[] {
-    const error = this.errorRepo.getById(errorId);
-    if (!error) return [];
-
-    const candidates = this.errorRepo.findByProject(error.project_id)
-      .filter(e => e.id !== errorId);
-    return matchError(error, candidates);
-  }
-
-  resolve(errorId: number, solutionId?: number): void {
-    this.errorRepo.update(errorId, {
-      resolved: 1,
-      resolved_at: new Date().toISOString(),
-    });
-
-    if (solutionId) {
-      this.eventBus.emit('error:resolved', { errorId, solutionId });
-    }
-  }
-
-  getById(id: number): ErrorRecord | undefined {
-    return this.errorRepo.getById(id);
-  }
-
-  countSince(since: string, projectId?: number): number {
-    return this.errorRepo.countSince(since, projectId);
-  }
-}
+import type { ErrorRecord } from '../types/error.types.js';
+import type { ErrorRepository } from '../db/repositories/error.repository.js';
+import type { ProjectRepository } from '../db/repositories/project.repository.js';
+import type { SynapseManager } from '../synapses/synapse-manager.js';
+import { parseError } from '../parsing/error-parser.js';
+import { generateFingerprint } from '../matching/fingerprint.js';
+import { matchError, type MatchResult } from '../matching/error-matcher.js';
+import { getEventBus } from '../utils/events.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface ReportErrorInput {
+  project: string;
+  errorOutput: string;
+  filePath?: string;
+  terminalId?: number;
+}
+
+export interface ErrorQueryInput {
+  projectId?: number;
+  resolved?: boolean;
+  search?: string;
+  limit?: number;
+}
+
+export class ErrorService {
+  private logger = getLogger();
+  private eventBus = getEventBus();
+
+  constructor(
+    private errorRepo: ErrorRepository,
+    private projectRepo: ProjectRepository,
+    private synapseManager: SynapseManager,
+  ) {}
+
+  report(input: ReportErrorInput): { errorId: number; isNew: boolean; matches: MatchResult[] } {
+    // 1. Ensure project exists
+    let project = this.projectRepo.findByName(input.project);
+    if (!project) {
+      const id = this.projectRepo.create({ name: input.project, path: null, language: null, framework: null });
+      project = this.projectRepo.getById(id)!;
+    }
+
+    // 2. Parse the error
+    const parsed = parseError(input.errorOutput);
+    if (!parsed) {
+      this.logger.warn('Could not parse error output');
+      const errorId = this.errorRepo.create({
+        project_id: project.id,
+        terminal_id: input.terminalId ?? null,
+        fingerprint: '',
+        type: 'UnknownError',
+        message: input.errorOutput.split('\n')[0] ?? input.errorOutput,
+        raw_output: input.errorOutput,
+        context: null,
+        file_path: input.filePath ?? null,
+        line_number: null,
+        column_number: null,
+      });
+      return { errorId, isNew: true, matches: [] };
+    }
+
+    // 3. Generate fingerprint
+    const fingerprint = generateFingerprint(parsed.errorType, parsed.message, parsed.frames);
+
+    // 4. Check for existing error with same fingerprint
+    const existing = this.errorRepo.findByFingerprint(fingerprint);
+    if (existing.length > 0) {
+      const err = existing[0]!;
+      this.errorRepo.incrementOccurrence(err.id);
+      this.logger.info(`Known error (id=${err.id}), occurrence incremented`);
+
+      // Strengthen synapse
+      this.synapseManager.strengthen(
+        { type: 'error', id: err.id },
+        { type: 'project', id: project.id },
+        'co_occurs',
+      );
+
+      return { errorId: err.id, isNew: false, matches: [] };
+    }
+
+    // 5. Create new error record
+    const errorId = this.errorRepo.create({
+      project_id: project.id,
+      terminal_id: input.terminalId ?? null,
+      fingerprint,
+      type: parsed.errorType,
+      message: parsed.message,
+      raw_output: input.errorOutput,
+      context: null,
+      file_path: parsed.sourceFile ?? input.filePath ?? null,
+      line_number: parsed.sourceLine ?? null,
+      column_number: null,
+    });
+
+    // 6. Create synapse: error ↔ project
+    this.synapseManager.strengthen(
+      { type: 'error', id: errorId },
+      { type: 'project', id: project.id },
+      'co_occurs',
+    );
+
+    // 7. Find similar errors
+    const candidates = this.errorRepo.findByProject(project.id)
+      .filter(e => e.id !== errorId);
+    const newError = this.errorRepo.getById(errorId)!;
+    const matches = matchError(newError, candidates);
+
+    // 8. Create similarity synapses for strong matches
+    for (const match of matches.filter(m => m.isStrong)) {
+      this.synapseManager.strengthen(
+        { type: 'error', id: errorId },
+        { type: 'error', id: match.errorId },
+        'similar_to',
+      );
+    }
+
+    this.eventBus.emit('error:reported', { errorId, projectId: project.id, fingerprint });
+    this.logger.info(`New error reported (id=${errorId}, type=${parsed.errorType})`);
+
+    return { errorId, isNew: true, matches };
+  }
+
+  query(input: ErrorQueryInput): ErrorRecord[] {
+    if (input.search) {
+      return this.errorRepo.search(input.search);
+    }
+    if (input.resolved === false) {
+      return this.errorRepo.findUnresolved(input.projectId);
+    }
+    if (input.projectId) {
+      return this.errorRepo.findByProject(input.projectId);
+    }
+    return [];
+  }
+
+  matchSimilar(errorId: number): MatchResult[] {
+    const error = this.errorRepo.getById(errorId);
+    if (!error) return [];
+
+    const candidates = this.errorRepo.findByProject(error.project_id)
+      .filter(e => e.id !== errorId);
+    return matchError(error, candidates);
+  }
+
+  resolve(errorId: number, solutionId?: number): void {
+    this.errorRepo.update(errorId, {
+      resolved: 1,
+      resolved_at: new Date().toISOString(),
+    });
+
+    if (solutionId) {
+      this.eventBus.emit('error:resolved', { errorId, solutionId });
+    }
+  }
+
+  getById(id: number): ErrorRecord | undefined {
+    return this.errorRepo.getById(id);
+  }
+
+  countSince(since: string, projectId?: number): number {
+    return this.errorRepo.countSince(since, projectId);
+  }
+}

package/src/services/notification.service.ts

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