@timmeck/brain 1.0.0

package/src/db/repositories/error.repository.ts

@@ -0,0 +1,149 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { ErrorRecord } from '../../types/error.types.js';
+
+type CreateErrorData = Omit<ErrorRecord, 'id' | 'occurrence_count' | 'first_seen' | 'last_seen' | 'resolved' | 'resolved_at'>;
+type UpdateErrorData = Partial<Omit<ErrorRecord, 'id' | 'first_seen'>>;
+
+export class ErrorRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: this.db.prepare(`
+        INSERT INTO errors (project_id, terminal_id, fingerprint, type, message, raw_output, context, file_path, line_number, column_number)
+        VALUES (@project_id, @terminal_id, @fingerprint, @type, @message, @raw_output, @context, @file_path, @line_number, @column_number)
+      `),
+      getById: this.db.prepare(`
+        SELECT * FROM errors WHERE id = ?
+      `),
+      update: this.db.prepare(`
+        UPDATE errors
+        SET project_id = COALESCE(@project_id, project_id),
+            terminal_id = COALESCE(@terminal_id, terminal_id),
+            fingerprint = COALESCE(@fingerprint, fingerprint),
+            type = COALESCE(@type, type),
+            message = COALESCE(@message, message),
+            raw_output = COALESCE(@raw_output, raw_output),
+            context = COALESCE(@context, context),
+            file_path = COALESCE(@file_path, file_path),
+            line_number = COALESCE(@line_number, line_number),
+            column_number = COALESCE(@column_number, column_number),
+            occurrence_count = COALESCE(@occurrence_count, occurrence_count),
+            last_seen = COALESCE(@last_seen, last_seen),
+            resolved = COALESCE(@resolved, resolved),
+            resolved_at = COALESCE(@resolved_at, resolved_at)
+        WHERE id = @id
+      `),
+      delete: this.db.prepare(`
+        DELETE FROM errors WHERE id = ?
+      `),
+      findByFingerprint: this.db.prepare(`
+        SELECT * FROM errors WHERE fingerprint = ? ORDER BY last_seen DESC
+      `),
+      findByProject: this.db.prepare(`
+        SELECT * FROM errors WHERE project_id = ? ORDER BY last_seen DESC
+      `),
+      findUnresolvedAll: this.db.prepare(`
+        SELECT * FROM errors WHERE resolved = 0 ORDER BY last_seen DESC
+      `),
+      findUnresolvedByProject: this.db.prepare(`
+        SELECT * FROM errors WHERE resolved = 0 AND project_id = ? ORDER BY last_seen DESC
+      `),
+      countSinceAll: this.db.prepare(`
+        SELECT COUNT(*) as count FROM errors WHERE first_seen >= ?
+      `),
+      countSinceByProject: this.db.prepare(`
+        SELECT COUNT(*) as count FROM errors WHERE first_seen >= ? AND project_id = ?
+      `),
+      search: this.db.prepare(`
+        SELECT errors.* FROM errors
+        JOIN errors_fts ON errors.id = errors_fts.rowid
+        WHERE errors_fts MATCH ?
+        ORDER BY rank
+      `),
+      incrementOccurrence: this.db.prepare(`
+        UPDATE errors
+        SET occurrence_count = occurrence_count + 1,
+            last_seen = datetime('now')
+        WHERE id = ?
+      `),
+    };
+  }
+
+  create(data: CreateErrorData): number {
+    const result = this.stmts.create.run({
+      project_id: data.project_id,
+      terminal_id: data.terminal_id ?? null,
+      fingerprint: data.fingerprint,
+      type: data.type,
+      message: data.message,
+      raw_output: data.raw_output,
+      context: data.context ?? null,
+      file_path: data.file_path ?? null,
+      line_number: data.line_number ?? null,
+      column_number: data.column_number ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): ErrorRecord | undefined {
+    return this.stmts.getById.get(id) as ErrorRecord | undefined;
+  }
+
+  update(id: number, data: UpdateErrorData): void {
+    this.stmts.update.run({
+      id,
+      project_id: data.project_id ?? null,
+      terminal_id: data.terminal_id ?? null,
+      fingerprint: data.fingerprint ?? null,
+      type: data.type ?? null,
+      message: data.message ?? null,
+      raw_output: data.raw_output ?? null,
+      context: data.context ?? null,
+      file_path: data.file_path ?? null,
+      line_number: data.line_number ?? null,
+      column_number: data.column_number ?? null,
+      occurrence_count: data.occurrence_count ?? null,
+      last_seen: data.last_seen ?? null,
+      resolved: data.resolved ?? null,
+      resolved_at: data.resolved_at ?? null,
+    });
+  }
+
+  delete(id: number): void {
+    this.stmts.delete.run(id);
+  }
+
+  findByFingerprint(fingerprint: string): ErrorRecord[] {
+    return this.stmts.findByFingerprint.all(fingerprint) as ErrorRecord[];
+  }
+
+  findByProject(projectId: number): ErrorRecord[] {
+    return this.stmts.findByProject.all(projectId) as ErrorRecord[];
+  }
+
+  findUnresolved(projectId?: number): ErrorRecord[] {
+    if (projectId !== undefined) {
+      return this.stmts.findUnresolvedByProject.all(projectId) as ErrorRecord[];
+    }
+    return this.stmts.findUnresolvedAll.all() as ErrorRecord[];
+  }
+
+  countSince(since: string, projectId?: number): number {
+    if (projectId !== undefined) {
+      const row = this.stmts.countSinceByProject.get(since, projectId) as { count: number };
+      return row.count;
+    }
+    const row = this.stmts.countSinceAll.get(since) as { count: number };
+    return row.count;
+  }
+
+  search(query: string): ErrorRecord[] {
+    return this.stmts.search.all(query) as ErrorRecord[];
+  }
+
+  incrementOccurrence(id: number): void {
+    this.stmts.incrementOccurrence.run(id);
+  }
+}

package/src/db/repositories/insight.repository.ts

@@ -0,0 +1,78 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { InsightRecord } from '../../types/research.types.js';
+
+type InsightCreate = Omit<InsightRecord, 'id' | 'created_at'>;
+type InsightUpdate = Partial<Omit<InsightRecord, 'id' | 'created_at'>>;
+
+export class InsightRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO insights (type, title, description, evidence, priority, project_id, active, expires_at)
+        VALUES (@type, @title, @description, @evidence, @priority, @project_id, @active, @expires_at)
+      `),
+      getById: db.prepare('SELECT * FROM insights WHERE id = ?'),
+      delete: db.prepare('DELETE FROM insights WHERE id = ?'),
+      findActiveAll: db.prepare(
+        'SELECT * FROM insights WHERE active = 1 ORDER BY priority DESC, created_at DESC'
+      ),
+      findActiveByProject: db.prepare(
+        'SELECT * FROM insights WHERE active = 1 AND project_id = ? ORDER BY priority DESC, created_at DESC'
+      ),
+      findByType: db.prepare('SELECT * FROM insights WHERE type = ? ORDER BY priority DESC'),
+      findByPriority: db.prepare(
+        'SELECT * FROM insights WHERE priority >= ? ORDER BY priority DESC, created_at DESC'
+      ),
+      expire: db.prepare(
+        `UPDATE insights SET active = 0 WHERE active = 1 AND expires_at IS NOT NULL AND expires_at < datetime('now')`
+      ),
+    };
+  }
+
+  create(data: InsightCreate): number {
+    const result = this.stmts.create.run(data);
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): InsightRecord | undefined {
+    return this.stmts.getById.get(id) as InsightRecord | undefined;
+  }
+
+  update(id: number, data: InsightUpdate): boolean {
+    const fields = Object.keys(data).filter((key) => (data as Record<string, unknown>)[key] !== undefined);
+    if (fields.length === 0) return false;
+
+    const setClauses = fields.map((field) => `${field} = @${field}`).join(', ');
+    const stmt = this.db.prepare(`UPDATE insights SET ${setClauses} WHERE id = @id`);
+    const result = stmt.run({ ...data, id });
+    return result.changes > 0;
+  }
+
+  delete(id: number): boolean {
+    const result = this.stmts.delete.run(id);
+    return result.changes > 0;
+  }
+
+  findActive(projectId?: number): InsightRecord[] {
+    if (projectId !== undefined) {
+      return this.stmts.findActiveByProject.all(projectId) as InsightRecord[];
+    }
+    return this.stmts.findActiveAll.all() as InsightRecord[];
+  }
+
+  findByType(type: string): InsightRecord[] {
+    return this.stmts.findByType.all(type) as InsightRecord[];
+  }
+
+  findByPriority(minPriority: number): InsightRecord[] {
+    return this.stmts.findByPriority.all(minPriority) as InsightRecord[];
+  }
+
+  expire(): number {
+    const result = this.stmts.expire.run();
+    return result.changes;
+  }
+}

package/src/db/repositories/notification.repository.ts

@@ -0,0 +1,66 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface NotificationRecord {
+  id: number;
+  type: string;
+  title: string;
+  message: string;
+  priority: number;
+  project_id: number | null;
+  acknowledged: number;
+  acknowledged_at: string | null;
+  created_at: string;
+}
+
+type NotificationCreate = Omit<NotificationRecord, 'id' | 'acknowledged' | 'acknowledged_at' | 'created_at'>;
+
+export class NotificationRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO notifications (type, title, message, priority, project_id)
+        VALUES (@type, @title, @message, @priority, @project_id)
+      `),
+      getById: db.prepare('SELECT * FROM notifications WHERE id = ?'),
+      delete: db.prepare('DELETE FROM notifications WHERE id = ?'),
+      findUnacknowledgedAll: db.prepare(
+        'SELECT * FROM notifications WHERE acknowledged = 0 ORDER BY priority DESC, created_at DESC'
+      ),
+      findUnacknowledgedByProject: db.prepare(
+        'SELECT * FROM notifications WHERE acknowledged = 0 AND project_id = ? ORDER BY priority DESC, created_at DESC'
+      ),
+      acknowledge: db.prepare(
+        `UPDATE notifications SET acknowledged = 1, acknowledged_at = datetime('now') WHERE id = ?`
+      ),
+    };
+  }
+
+  create(data: NotificationCreate): number {
+    const result = this.stmts.create.run(data);
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): NotificationRecord | undefined {
+    return this.stmts.getById.get(id) as NotificationRecord | undefined;
+  }
+
+  delete(id: number): boolean {
+    const result = this.stmts.delete.run(id);
+    return result.changes > 0;
+  }
+
+  findUnacknowledged(projectId?: number): NotificationRecord[] {
+    if (projectId !== undefined) {
+      return this.stmts.findUnacknowledgedByProject.all(projectId) as NotificationRecord[];
+    }
+    return this.stmts.findUnacknowledgedAll.all() as NotificationRecord[];
+  }
+
+  acknowledge(id: number): boolean {
+    const result = this.stmts.acknowledge.run(id);
+    return result.changes > 0;
+  }
+}

package/src/db/repositories/project.repository.ts

@@ -0,0 +1,93 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface ProjectRecord {
+  id: number;
+  name: string;
+  path: string | null;
+  language: string | null;
+  framework: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+type CreateProjectData = Omit<ProjectRecord, 'id' | 'created_at' | 'updated_at'>;
+type UpdateProjectData = Partial<Omit<ProjectRecord, 'id' | 'created_at'>>;
+
+export class ProjectRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: this.db.prepare(`
+        INSERT INTO projects (name, path, language, framework)
+        VALUES (@name, @path, @language, @framework)
+      `),
+      getById: this.db.prepare(`
+        SELECT * FROM projects WHERE id = ?
+      `),
+      update: this.db.prepare(`
+        UPDATE projects
+        SET name = COALESCE(@name, name),
+            path = COALESCE(@path, path),
+            language = COALESCE(@language, language),
+            framework = COALESCE(@framework, framework),
+            updated_at = datetime('now')
+        WHERE id = @id
+      `),
+      delete: this.db.prepare(`
+        DELETE FROM projects WHERE id = ?
+      `),
+      findByName: this.db.prepare(`
+        SELECT * FROM projects WHERE name = ?
+      `),
+      findByPath: this.db.prepare(`
+        SELECT * FROM projects WHERE path = ?
+      `),
+      getAll: this.db.prepare(`
+        SELECT * FROM projects ORDER BY name
+      `),
+    };
+  }
+
+  create(data: CreateProjectData): number {
+    const result = this.stmts.create.run({
+      name: data.name,
+      path: data.path ?? null,
+      language: data.language ?? null,
+      framework: data.framework ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): ProjectRecord | undefined {
+    return this.stmts.getById.get(id) as ProjectRecord | undefined;
+  }
+
+  update(id: number, data: UpdateProjectData): void {
+    this.stmts.update.run({
+      id,
+      name: data.name ?? null,
+      path: data.path ?? null,
+      language: data.language ?? null,
+      framework: data.framework ?? null,
+      updated_at: data.updated_at ?? null,
+    });
+  }
+
+  delete(id: number): void {
+    this.stmts.delete.run(id);
+  }
+
+  findByName(name: string): ProjectRecord | undefined {
+    return this.stmts.findByName.get(name) as ProjectRecord | undefined;
+  }
+
+  findByPath(path: string): ProjectRecord | undefined {
+    return this.stmts.findByPath.get(path) as ProjectRecord | undefined;
+  }
+
+  getAll(): ProjectRecord[] {
+    return this.stmts.getAll.all() as ProjectRecord[];
+  }
+}

package/src/db/repositories/rule.repository.ts

@@ -0,0 +1,108 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface RuleRecord {
+  id: number;
+  pattern: string;
+  action: string;
+  description: string | null;
+  confidence: number;
+  occurrences: number;
+  active: number;
+  project_id: number | null;
+  created_at: string;
+  updated_at: string;
+}
+
+type CreateRuleData = Omit<RuleRecord, 'id' | 'confidence' | 'occurrences' | 'active' | 'created_at' | 'updated_at'> & {
+  confidence?: number;
+  occurrences?: number;
+  active?: number;
+};
+type UpdateRuleData = Partial<Omit<RuleRecord, 'id' | 'created_at'>>;
+
+export class RuleRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: this.db.prepare(`
+        INSERT INTO rules (pattern, action, description, confidence, occurrences, active, project_id)
+        VALUES (@pattern, @action, @description, @confidence, @occurrences, @active, @project_id)
+      `),
+      getById: this.db.prepare(`
+        SELECT * FROM rules WHERE id = ?
+      `),
+      update: this.db.prepare(`
+        UPDATE rules
+        SET pattern = COALESCE(@pattern, pattern),
+            action = COALESCE(@action, action),
+            description = COALESCE(@description, description),
+            confidence = COALESCE(@confidence, confidence),
+            occurrences = COALESCE(@occurrences, occurrences),
+            active = COALESCE(@active, active),
+            project_id = COALESCE(@project_id, project_id),
+            updated_at = datetime('now')
+        WHERE id = @id
+      `),
+      delete: this.db.prepare(`
+        DELETE FROM rules WHERE id = ?
+      `),
+      findActiveAll: this.db.prepare(`
+        SELECT * FROM rules WHERE active = 1 ORDER BY confidence DESC
+      `),
+      findActiveByProject: this.db.prepare(`
+        SELECT * FROM rules WHERE active = 1 AND (project_id = ? OR project_id IS NULL) ORDER BY confidence DESC
+      `),
+      findByPattern: this.db.prepare(`
+        SELECT * FROM rules WHERE pattern = ?
+      `),
+    };
+  }
+
+  create(data: CreateRuleData): number {
+    const result = this.stmts.create.run({
+      pattern: data.pattern,
+      action: data.action,
+      description: data.description ?? null,
+      confidence: data.confidence ?? 0.5,
+      occurrences: data.occurrences ?? 0,
+      active: data.active ?? 1,
+      project_id: data.project_id ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): RuleRecord | undefined {
+    return this.stmts.getById.get(id) as RuleRecord | undefined;
+  }
+
+  update(id: number, data: UpdateRuleData): void {
+    this.stmts.update.run({
+      id,
+      pattern: data.pattern ?? null,
+      action: data.action ?? null,
+      description: data.description ?? null,
+      confidence: data.confidence ?? null,
+      occurrences: data.occurrences ?? null,
+      active: data.active ?? null,
+      project_id: data.project_id ?? null,
+      updated_at: data.updated_at ?? null,
+    });
+  }
+
+  delete(id: number): void {
+    this.stmts.delete.run(id);
+  }
+
+  findActive(projectId?: number): RuleRecord[] {
+    if (projectId !== undefined) {
+      return this.stmts.findActiveByProject.all(projectId) as RuleRecord[];
+    }
+    return this.stmts.findActiveAll.all() as RuleRecord[];
+  }
+
+  findByPattern(pattern: string): RuleRecord[] {
+    return this.stmts.findByPattern.all(pattern) as RuleRecord[];
+  }
+}

package/src/db/repositories/solution.repository.ts

@@ -0,0 +1,154 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { SolutionRecord, ErrorSolution, SolutionAttempt } from '../../types/solution.types.js';
+
+type CreateSolutionData = Omit<SolutionRecord, 'id' | 'success_count' | 'fail_count' | 'created_at' | 'updated_at'>;
+type UpdateSolutionData = Partial<Omit<SolutionRecord, 'id' | 'created_at'>>;
+
+interface AttemptData {
+  errorSolutionId: number;
+  terminalId?: number | null;
+  success: number;
+  output?: string | null;
+  durationMs?: number | null;
+}
+
+export class SolutionRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: this.db.prepare(`
+        INSERT INTO solutions (description, commands, code_change, source, confidence)
+        VALUES (@description, @commands, @code_change, @source, @confidence)
+      `),
+      getById: this.db.prepare(`
+        SELECT * FROM solutions WHERE id = ?
+      `),
+      update: this.db.prepare(`
+        UPDATE solutions
+        SET description = COALESCE(@description, description),
+            commands = COALESCE(@commands, commands),
+            code_change = COALESCE(@code_change, code_change),
+            source = COALESCE(@source, source),
+            confidence = COALESCE(@confidence, confidence),
+            success_count = COALESCE(@success_count, success_count),
+            fail_count = COALESCE(@fail_count, fail_count),
+            updated_at = datetime('now')
+        WHERE id = @id
+      `),
+      delete: this.db.prepare(`
+        DELETE FROM solutions WHERE id = ?
+      `),
+      findForError: this.db.prepare(`
+        SELECT s.* FROM solutions s
+        JOIN error_solutions es ON s.id = es.solution_id
+        WHERE es.error_id = ?
+        ORDER BY s.confidence DESC
+      `),
+      linkToError: this.db.prepare(`
+        INSERT OR IGNORE INTO error_solutions (error_id, solution_id)
+        VALUES (@error_id, @solution_id)
+      `),
+      recordAttempt: this.db.prepare(`
+        INSERT INTO solution_attempts (error_solution_id, terminal_id, success, output, duration_ms)
+        VALUES (@error_solution_id, @terminal_id, @success, @output, @duration_ms)
+      `),
+      getAttempts: this.db.prepare(`
+        SELECT * FROM solution_attempts WHERE error_solution_id = ? ORDER BY attempted_at DESC
+      `),
+      getAll: this.db.prepare(`
+        SELECT * FROM solutions
+      `),
+      successRate: this.db.prepare(`
+        SELECT
+          COUNT(*) as total,
+          SUM(CASE WHEN sa.success = 1 THEN 1 ELSE 0 END) as successes
+        FROM solution_attempts sa
+        JOIN error_solutions es ON sa.error_solution_id = es.id
+        WHERE es.solution_id = ?
+      `),
+      updateSuccessCount: this.db.prepare(`
+        UPDATE solutions
+        SET success_count = success_count + 1,
+            updated_at = datetime('now')
+        WHERE id = ?
+      `),
+      updateFailCount: this.db.prepare(`
+        UPDATE solutions
+        SET fail_count = fail_count + 1,
+            updated_at = datetime('now')
+        WHERE id = ?
+      `),
+    };
+  }
+
+  create(data: CreateSolutionData): number {
+    const result = this.stmts.create.run({
+      description: data.description,
+      commands: data.commands ?? null,
+      code_change: data.code_change ?? null,
+      source: data.source,
+      confidence: data.confidence,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): SolutionRecord | undefined {
+    return this.stmts.getById.get(id) as SolutionRecord | undefined;
+  }
+
+  update(id: number, data: UpdateSolutionData): void {
+    this.stmts.update.run({
+      id,
+      description: data.description ?? null,
+      commands: data.commands ?? null,
+      code_change: data.code_change ?? null,
+      source: data.source ?? null,
+      confidence: data.confidence ?? null,
+      success_count: data.success_count ?? null,
+      fail_count: data.fail_count ?? null,
+      updated_at: data.updated_at ?? null,
+    });
+  }
+
+  delete(id: number): void {
+    this.stmts.delete.run(id);
+  }
+
+  findForError(errorId: number): SolutionRecord[] {
+    return this.stmts.findForError.all(errorId) as SolutionRecord[];
+  }
+
+  linkToError(errorId: number, solutionId: number): void {
+    this.stmts.linkToError.run({
+      error_id: errorId,
+      solution_id: solutionId,
+    });
+  }
+
+  recordAttempt(data: AttemptData): number {
+    const result = this.stmts.recordAttempt.run({
+      error_solution_id: data.errorSolutionId,
+      terminal_id: data.terminalId ?? null,
+      success: data.success,
+      output: data.output ?? null,
+      duration_ms: data.durationMs ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getAttempts(errorSolutionId: number): SolutionAttempt[] {
+    return this.stmts.getAttempts.all(errorSolutionId) as SolutionAttempt[];
+  }
+
+  getAll(): SolutionRecord[] {
+    return this.stmts.getAll.all() as SolutionRecord[];
+  }
+
+  successRate(solutionId: number): number {
+    const row = this.stmts.successRate.get(solutionId) as { total: number; successes: number };
+    if (row.total === 0) return 0;
+    return row.successes / row.total;
+  }
+}