@timmeck/brain 1.9.0 → 2.0.0

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

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

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

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

@@ -1,163 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { Statement } from 'better-sqlite3';
-import type { SynapseRecord } from '../../types/synapse.types.js';
-
-type SynapseCreate = Omit<SynapseRecord, 'id' | 'activation_count' | 'last_activated_at' | 'created_at' | 'updated_at'>;
-type SynapseUpdate = Partial<Omit<SynapseRecord, 'id' | 'created_at'>>;
-
-export class SynapseRepository {
-  private stmts: Record<string, Statement>;
-
-  constructor(private db: Database.Database) {
-    this.stmts = {
-      create: db.prepare(`
-        INSERT INTO synapses (source_type, source_id, target_type, target_id, synapse_type, weight, metadata)
-        VALUES (@source_type, @source_id, @target_type, @target_id, @synapse_type, @weight, @metadata)
-      `),
-      getById: db.prepare('SELECT * FROM synapses WHERE id = ?'),
-      delete: db.prepare('DELETE FROM synapses WHERE id = ?'),
-      getOutgoing: db.prepare(
-        'SELECT * FROM synapses WHERE source_type = ? AND source_id = ? ORDER BY weight DESC'
-      ),
-      getIncoming: db.prepare(
-        'SELECT * FROM synapses WHERE target_type = ? AND target_id = ? ORDER BY weight DESC'
-      ),
-      findConnected: db.prepare(`
-        SELECT * FROM synapses
-        WHERE (source_type = ? AND source_id = ?) OR (target_type = ? AND target_id = ?)
-        ORDER BY weight DESC
-      `),
-      findBySourceTarget: db.prepare(`
-        SELECT * FROM synapses
-        WHERE source_type = ? AND source_id = ? AND target_type = ? AND target_id = ? AND synapse_type = ?
-      `),
-      findInactiveSince: db.prepare(`
-        SELECT * FROM synapses WHERE last_activated_at < ?
-      `),
-      countNodes: db.prepare(`
-        SELECT COUNT(*) as count FROM (
-          SELECT source_type, source_id FROM synapses
-          UNION
-          SELECT target_type, target_id FROM synapses
-        )
-      `),
-      avgWeight: db.prepare('SELECT AVG(weight) as avg_weight FROM synapses'),
-      countByType: db.prepare('SELECT synapse_type, COUNT(*) as count FROM synapses GROUP BY synapse_type'),
-      totalCount: db.prepare('SELECT COUNT(*) as count FROM synapses'),
-      topByWeight: db.prepare('SELECT * FROM synapses ORDER BY weight DESC LIMIT ?'),
-      topDiverse: db.prepare(`
-        SELECT * FROM (
-          SELECT *, ROW_NUMBER() OVER (PARTITION BY synapse_type ORDER BY weight DESC) as rn
-          FROM synapses
-        ) WHERE rn <= ? ORDER BY weight DESC
-      `),
-    };
-  }
-
-  create(data: SynapseCreate): number {
-    const result = this.stmts.create.run({
-      source_type: data.source_type,
-      source_id: data.source_id,
-      target_type: data.target_type,
-      target_id: data.target_id,
-      synapse_type: data.synapse_type,
-      weight: data.weight,
-      metadata: data.metadata ?? null,
-    });
-    return result.lastInsertRowid as number;
-  }
-
-  getById(id: number): SynapseRecord | undefined {
-    return this.stmts.getById.get(id) as SynapseRecord | undefined;
-  }
-
-  update(id: number, data: SynapseUpdate): 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 synapses SET ${setClauses}, updated_at = datetime('now') 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;
-  }
-
-  getOutgoing(sourceType: string, sourceId: number): SynapseRecord[] {
-    return this.stmts.getOutgoing.all(sourceType, sourceId) as SynapseRecord[];
-  }
-
-  getIncoming(targetType: string, targetId: number): SynapseRecord[] {
-    return this.stmts.getIncoming.all(targetType, targetId) as SynapseRecord[];
-  }
-
-  findBySourceTarget(
-    sourceType: string,
-    sourceId: number,
-    targetType: string,
-    targetId: number,
-    synapseType: string,
-  ): SynapseRecord | undefined {
-    return this.stmts.findBySourceTarget.get(
-      sourceType, sourceId, targetType, targetId, synapseType
-    ) as SynapseRecord | undefined;
-  }
-
-  findByWeight(minWeight: number, maxWeight?: number): SynapseRecord[] {
-    if (maxWeight !== undefined) {
-      const stmt = this.db.prepare(
-        'SELECT * FROM synapses WHERE weight >= ? AND weight <= ? ORDER BY weight DESC'
-      );
-      return stmt.all(minWeight, maxWeight) as SynapseRecord[];
-    }
-    const stmt = this.db.prepare('SELECT * FROM synapses WHERE weight >= ? ORDER BY weight DESC');
-    return stmt.all(minWeight) as SynapseRecord[];
-  }
-
-  findConnected(nodeType: string, nodeId: number): SynapseRecord[] {
-    return this.stmts.findConnected.all(nodeType, nodeId, nodeType, nodeId) as SynapseRecord[];
-  }
-
-  findInactiveSince(cutoff: string): SynapseRecord[] {
-    return this.stmts.findInactiveSince.all(cutoff) as SynapseRecord[];
-  }
-
-  topByWeight(limit: number): SynapseRecord[] {
-    return this.stmts.topByWeight.all(limit) as SynapseRecord[];
-  }
-
-  topDiverse(perType: number): SynapseRecord[] {
-    return this.stmts.topDiverse.all(perType) as SynapseRecord[];
-  }
-
-  countNodes(): number {
-    const row = this.stmts.countNodes.get() as { count: number };
-    return row.count;
-  }
-
-  totalCount(): number {
-    const row = this.stmts.totalCount.get() as { count: number };
-    return row.count;
-  }
-
-  avgWeight(): number {
-    const row = this.stmts.avgWeight.get() as { avg_weight: number | null };
-    return row.avg_weight ?? 0;
-  }
-
-  countByType(): Record<string, number> {
-    const rows = this.stmts.countByType.all() as Array<{ synapse_type: string; count: number }>;
-    const result: Record<string, number> = {};
-    for (const row of rows) {
-      result[row.synapse_type] = row.count;
-    }
-    return result;
-  }
-}

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

@@ -1,101 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { Statement } from 'better-sqlite3';
-
-export interface TerminalRecord {
-  id: number;
-  uuid: string;
-  project_id: number | null;
-  pid: number | null;
-  shell: string | null;
-  cwd: string | null;
-  connected_at: string;
-  last_seen: string;
-  disconnected_at: string | null;
-}
-
-type CreateTerminalData = Omit<TerminalRecord, 'id' | 'connected_at' | 'last_seen' | 'disconnected_at'>;
-type UpdateTerminalData = Partial<Omit<TerminalRecord, 'id' | 'connected_at'>>;
-
-export class TerminalRepository {
-  private stmts: Record<string, Statement>;
-
-  constructor(private db: Database.Database) {
-    this.stmts = {
-      create: this.db.prepare(`
-        INSERT INTO terminals (uuid, project_id, pid, shell, cwd)
-        VALUES (@uuid, @project_id, @pid, @shell, @cwd)
-      `),
-      getById: this.db.prepare(`
-        SELECT * FROM terminals WHERE id = ?
-      `),
-      update: this.db.prepare(`
-        UPDATE terminals
-        SET project_id = COALESCE(@project_id, project_id),
-            pid = COALESCE(@pid, pid),
-            shell = COALESCE(@shell, shell),
-            cwd = COALESCE(@cwd, cwd),
-            last_seen = COALESCE(@last_seen, last_seen),
-            disconnected_at = COALESCE(@disconnected_at, disconnected_at)
-        WHERE id = @id
-      `),
-      delete: this.db.prepare(`
-        DELETE FROM terminals WHERE id = ?
-      `),
-      findByUuid: this.db.prepare(`
-        SELECT * FROM terminals WHERE uuid = ?
-      `),
-      findConnected: this.db.prepare(`
-        SELECT * FROM terminals WHERE disconnected_at IS NULL ORDER BY connected_at DESC
-      `),
-      cleanupStale: this.db.prepare(`
-        UPDATE terminals
-        SET disconnected_at = datetime('now')
-        WHERE disconnected_at IS NULL AND last_seen < ?
-      `),
-    };
-  }
-
-  create(data: CreateTerminalData): number {
-    const result = this.stmts.create.run({
-      uuid: data.uuid,
-      project_id: data.project_id ?? null,
-      pid: data.pid ?? null,
-      shell: data.shell ?? null,
-      cwd: data.cwd ?? null,
-    });
-    return result.lastInsertRowid as number;
-  }
-
-  getById(id: number): TerminalRecord | undefined {
-    return this.stmts.getById.get(id) as TerminalRecord | undefined;
-  }
-
-  update(id: number, data: UpdateTerminalData): void {
-    this.stmts.update.run({
-      id,
-      project_id: data.project_id ?? null,
-      pid: data.pid ?? null,
-      shell: data.shell ?? null,
-      cwd: data.cwd ?? null,
-      last_seen: data.last_seen ?? null,
-      disconnected_at: data.disconnected_at ?? null,
-    });
-  }
-
-  delete(id: number): void {
-    this.stmts.delete.run(id);
-  }
-
-  findByUuid(uuid: string): TerminalRecord | undefined {
-    return this.stmts.findByUuid.get(uuid) as TerminalRecord | undefined;
-  }
-
-  findConnected(): TerminalRecord[] {
-    return this.stmts.findConnected.all() as TerminalRecord[];
-  }
-
-  cleanupStale(olderThan: string): number {
-    const result = this.stmts.cleanupStale.run(olderThan);
-    return result.changes;
-  }
-}