@timmeck/brain 1.0.0

package/src/db/migrations/001_core_schema.ts

@@ -0,0 +1,120 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      path TEXT,
+      language TEXT,
+      framework TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS terminals (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      uuid TEXT NOT NULL UNIQUE,
+      project_id INTEGER,
+      pid INTEGER,
+      shell TEXT,
+      cwd TEXT,
+      connected_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_seen TEXT NOT NULL DEFAULT (datetime('now')),
+      disconnected_at TEXT,
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE SET NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS errors (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL,
+      terminal_id INTEGER,
+      fingerprint TEXT NOT NULL,
+      type TEXT NOT NULL,
+      message TEXT NOT NULL,
+      raw_output TEXT NOT NULL,
+      context TEXT,
+      file_path TEXT,
+      line_number INTEGER,
+      column_number INTEGER,
+      occurrence_count INTEGER NOT NULL DEFAULT 1,
+      first_seen TEXT NOT NULL DEFAULT (datetime('now')),
+      last_seen TEXT NOT NULL DEFAULT (datetime('now')),
+      resolved INTEGER NOT NULL DEFAULT 0,
+      resolved_at TEXT,
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+      FOREIGN KEY (terminal_id) REFERENCES terminals(id) ON DELETE SET NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS stack_frames (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      error_id INTEGER NOT NULL,
+      frame_index INTEGER NOT NULL,
+      file TEXT NOT NULL,
+      line INTEGER NOT NULL,
+      "column" INTEGER,
+      function_name TEXT,
+      source TEXT,
+      FOREIGN KEY (error_id) REFERENCES errors(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS solutions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      description TEXT NOT NULL,
+      commands TEXT,
+      code_change TEXT,
+      source TEXT NOT NULL DEFAULT 'manual',
+      confidence REAL NOT NULL DEFAULT 0.5,
+      success_count INTEGER NOT NULL DEFAULT 0,
+      fail_count INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS error_solutions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      error_id INTEGER NOT NULL,
+      solution_id INTEGER NOT NULL,
+      applied_at TEXT,
+      success INTEGER,
+      FOREIGN KEY (error_id) REFERENCES errors(id) ON DELETE CASCADE,
+      FOREIGN KEY (solution_id) REFERENCES solutions(id) ON DELETE CASCADE,
+      UNIQUE(error_id, solution_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS solution_attempts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      error_solution_id INTEGER NOT NULL,
+      terminal_id INTEGER,
+      attempted_at TEXT NOT NULL DEFAULT (datetime('now')),
+      success INTEGER NOT NULL DEFAULT 0,
+      output TEXT,
+      duration_ms INTEGER,
+      FOREIGN KEY (error_solution_id) REFERENCES error_solutions(id) ON DELETE CASCADE,
+      FOREIGN KEY (terminal_id) REFERENCES terminals(id) ON DELETE SET NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS error_chains (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      parent_error_id INTEGER NOT NULL,
+      child_error_id INTEGER NOT NULL,
+      relationship TEXT NOT NULL DEFAULT 'causes',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (parent_error_id) REFERENCES errors(id) ON DELETE CASCADE,
+      FOREIGN KEY (child_error_id) REFERENCES errors(id) ON DELETE CASCADE,
+      UNIQUE(parent_error_id, child_error_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_errors_fingerprint ON errors(fingerprint);
+    CREATE INDEX IF NOT EXISTS idx_errors_project ON errors(project_id);
+    CREATE INDEX IF NOT EXISTS idx_errors_type ON errors(type);
+    CREATE INDEX IF NOT EXISTS idx_errors_resolved ON errors(resolved);
+    CREATE INDEX IF NOT EXISTS idx_errors_last_seen ON errors(last_seen);
+    CREATE INDEX IF NOT EXISTS idx_stack_frames_error ON stack_frames(error_id);
+    CREATE INDEX IF NOT EXISTS idx_error_solutions_error ON error_solutions(error_id);
+    CREATE INDEX IF NOT EXISTS idx_error_solutions_solution ON error_solutions(solution_id);
+    CREATE INDEX IF NOT EXISTS idx_solution_attempts_es ON solution_attempts(error_solution_id);
+    CREATE INDEX IF NOT EXISTS idx_terminals_uuid ON terminals(uuid);
+    CREATE INDEX IF NOT EXISTS idx_terminals_project ON terminals(project_id);
+  `);
+}

package/src/db/migrations/002_learning_schema.ts

@@ -0,0 +1,38 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS rules (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      pattern TEXT NOT NULL,
+      action TEXT NOT NULL,
+      description TEXT,
+      confidence REAL NOT NULL DEFAULT 0.5,
+      occurrences INTEGER NOT NULL DEFAULT 0,
+      active INTEGER NOT NULL DEFAULT 1,
+      project_id INTEGER,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE SET NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS antipatterns (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      pattern TEXT NOT NULL,
+      description TEXT NOT NULL,
+      severity TEXT NOT NULL DEFAULT 'warning',
+      suggestion TEXT,
+      occurrences INTEGER NOT NULL DEFAULT 0,
+      project_id INTEGER,
+      global INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_rules_pattern ON rules(pattern);
+    CREATE INDEX IF NOT EXISTS idx_rules_active ON rules(active);
+    CREATE INDEX IF NOT EXISTS idx_rules_project ON rules(project_id);
+    CREATE INDEX IF NOT EXISTS idx_antipatterns_project ON antipatterns(project_id);
+    CREATE INDEX IF NOT EXISTS idx_antipatterns_global ON antipatterns(global);
+  `);
+}

package/src/db/migrations/003_code_schema.ts

@@ -0,0 +1,53 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS code_modules (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL,
+      name TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      language TEXT NOT NULL,
+      fingerprint TEXT NOT NULL,
+      description TEXT,
+      source_hash TEXT NOT NULL,
+      lines_of_code INTEGER NOT NULL DEFAULT 0,
+      complexity INTEGER,
+      reusability_score REAL NOT NULL DEFAULT 0.0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS module_usages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      module_id INTEGER NOT NULL,
+      used_in_project_id INTEGER NOT NULL,
+      used_in_file TEXT NOT NULL,
+      usage_type TEXT NOT NULL DEFAULT 'import',
+      first_used TEXT NOT NULL DEFAULT (datetime('now')),
+      last_used TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (module_id) REFERENCES code_modules(id) ON DELETE CASCADE,
+      FOREIGN KEY (used_in_project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS module_similarities (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      module_a_id INTEGER NOT NULL,
+      module_b_id INTEGER NOT NULL,
+      similarity_score REAL NOT NULL,
+      computed_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (module_a_id) REFERENCES code_modules(id) ON DELETE CASCADE,
+      FOREIGN KEY (module_b_id) REFERENCES code_modules(id) ON DELETE CASCADE,
+      UNIQUE(module_a_id, module_b_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_code_modules_project ON code_modules(project_id);
+    CREATE INDEX IF NOT EXISTS idx_code_modules_fingerprint ON code_modules(fingerprint);
+    CREATE INDEX IF NOT EXISTS idx_code_modules_language ON code_modules(language);
+    CREATE INDEX IF NOT EXISTS idx_module_usages_module ON module_usages(module_id);
+    CREATE INDEX IF NOT EXISTS idx_module_usages_project ON module_usages(used_in_project_id);
+    CREATE INDEX IF NOT EXISTS idx_module_similarities_a ON module_similarities(module_a_id);
+    CREATE INDEX IF NOT EXISTS idx_module_similarities_b ON module_similarities(module_b_id);
+  `);
+}

package/src/db/migrations/004_synapses_schema.ts

@@ -0,0 +1,57 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS synapses (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_type TEXT NOT NULL,
+      source_id INTEGER NOT NULL,
+      target_type TEXT NOT NULL,
+      target_id INTEGER NOT NULL,
+      synapse_type TEXT NOT NULL,
+      weight REAL NOT NULL DEFAULT 0.5,
+      metadata TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(source_type, source_id, target_type, target_id, synapse_type)
+    );
+
+    CREATE TABLE IF NOT EXISTS insights (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL,
+      evidence TEXT NOT NULL DEFAULT '[]',
+      priority INTEGER NOT NULL DEFAULT 0,
+      project_id INTEGER,
+      active INTEGER NOT NULL DEFAULT 1,
+      expires_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE SET NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS notifications (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      title TEXT NOT NULL,
+      message TEXT NOT NULL,
+      priority INTEGER NOT NULL DEFAULT 0,
+      project_id INTEGER,
+      acknowledged INTEGER NOT NULL DEFAULT 0,
+      acknowledged_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_synapses_source ON synapses(source_type, source_id);
+    CREATE INDEX IF NOT EXISTS idx_synapses_target ON synapses(target_type, target_id);
+    CREATE INDEX IF NOT EXISTS idx_synapses_type ON synapses(synapse_type);
+    CREATE INDEX IF NOT EXISTS idx_synapses_weight ON synapses(weight);
+    CREATE INDEX IF NOT EXISTS idx_insights_type ON insights(type);
+    CREATE INDEX IF NOT EXISTS idx_insights_project ON insights(project_id);
+    CREATE INDEX IF NOT EXISTS idx_insights_active ON insights(active);
+    CREATE INDEX IF NOT EXISTS idx_insights_priority ON insights(priority);
+    CREATE INDEX IF NOT EXISTS idx_notifications_acknowledged ON notifications(acknowledged);
+    CREATE INDEX IF NOT EXISTS idx_notifications_project ON notifications(project_id);
+  `);
+}

package/src/db/migrations/005_fts_indexes.ts

@@ -0,0 +1,78 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    -- Full-text search for errors
+    CREATE VIRTUAL TABLE IF NOT EXISTS errors_fts USING fts5(
+      type, message, raw_output, context, file_path,
+      content='errors',
+      content_rowid='id'
+    );
+
+    -- Sync triggers for errors_fts
+    CREATE TRIGGER IF NOT EXISTS errors_ai AFTER INSERT ON errors BEGIN
+      INSERT INTO errors_fts(rowid, type, message, raw_output, context, file_path)
+      VALUES (new.id, new.type, new.message, new.raw_output, new.context, new.file_path);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS errors_ad AFTER DELETE ON errors BEGIN
+      INSERT INTO errors_fts(errors_fts, rowid, type, message, raw_output, context, file_path)
+      VALUES ('delete', old.id, old.type, old.message, old.raw_output, old.context, old.file_path);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS errors_au AFTER UPDATE ON errors BEGIN
+      INSERT INTO errors_fts(errors_fts, rowid, type, message, raw_output, context, file_path)
+      VALUES ('delete', old.id, old.type, old.message, old.raw_output, old.context, old.file_path);
+      INSERT INTO errors_fts(rowid, type, message, raw_output, context, file_path)
+      VALUES (new.id, new.type, new.message, new.raw_output, new.context, new.file_path);
+    END;
+
+    -- Full-text search for solutions
+    CREATE VIRTUAL TABLE IF NOT EXISTS solutions_fts USING fts5(
+      description, commands, code_change,
+      content='solutions',
+      content_rowid='id'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS solutions_ai AFTER INSERT ON solutions BEGIN
+      INSERT INTO solutions_fts(rowid, description, commands, code_change)
+      VALUES (new.id, new.description, new.commands, new.code_change);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS solutions_ad AFTER DELETE ON solutions BEGIN
+      INSERT INTO solutions_fts(solutions_fts, rowid, description, commands, code_change)
+      VALUES ('delete', old.id, old.description, old.commands, old.code_change);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS solutions_au AFTER UPDATE ON solutions BEGIN
+      INSERT INTO solutions_fts(solutions_fts, rowid, description, commands, code_change)
+      VALUES ('delete', old.id, old.description, old.commands, old.code_change);
+      INSERT INTO solutions_fts(rowid, description, commands, code_change)
+      VALUES (new.id, new.description, new.commands, new.code_change);
+    END;
+
+    -- Full-text search for code modules
+    CREATE VIRTUAL TABLE IF NOT EXISTS code_modules_fts USING fts5(
+      name, file_path, description, language,
+      content='code_modules',
+      content_rowid='id'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS code_modules_ai AFTER INSERT ON code_modules BEGIN
+      INSERT INTO code_modules_fts(rowid, name, file_path, description, language)
+      VALUES (new.id, new.name, new.file_path, new.description, new.language);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS code_modules_ad AFTER DELETE ON code_modules BEGIN
+      INSERT INTO code_modules_fts(code_modules_fts, rowid, name, file_path, description, language)
+      VALUES ('delete', old.id, old.name, old.file_path, old.description, old.language);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS code_modules_au AFTER UPDATE ON code_modules BEGIN
+      INSERT INTO code_modules_fts(code_modules_fts, rowid, name, file_path, description, language)
+      VALUES ('delete', old.id, old.name, old.file_path, old.description, old.language);
+      INSERT INTO code_modules_fts(rowid, name, file_path, description, language)
+      VALUES (new.id, new.name, new.file_path, new.description, new.language);
+    END;
+  `);
+}

package/src/db/migrations/006_synapses_phase3.ts

@@ -0,0 +1,17 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  // Add activation_count and last_activated_at columns
+  const columns = db.pragma('table_info(synapses)') as Array<{ name: string }>;
+  const colNames = columns.map(c => c.name);
+
+  if (!colNames.includes('activation_count')) {
+    db.exec(`ALTER TABLE synapses ADD COLUMN activation_count INTEGER NOT NULL DEFAULT 1`);
+  }
+  if (!colNames.includes('last_activated_at')) {
+    db.exec(`ALTER TABLE synapses ADD COLUMN last_activated_at TEXT NOT NULL DEFAULT (datetime('now'))`);
+  }
+
+  // Add index for decay queries
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_synapses_last_activated ON synapses(last_activated_at)`);
+}

package/src/db/migrations/index.ts

@@ -0,0 +1,64 @@
+import type Database from 'better-sqlite3';
+import { getLogger } from '../../utils/logger.js';
+import { up as coreSchema } from './001_core_schema.js';
+import { up as learningSchema } from './002_learning_schema.js';
+import { up as codeSchema } from './003_code_schema.js';
+import { up as synapsesSchema } from './004_synapses_schema.js';
+import { up as ftsIndexes } from './005_fts_indexes.js';
+import { up as synapsesPhase3 } from './006_synapses_phase3.js';
+
+interface Migration {
+  version: number;
+  name: string;
+  up: (db: Database.Database) => void;
+}
+
+const migrations: Migration[] = [
+  { version: 1, name: '001_core_schema', up: coreSchema },
+  { version: 2, name: '002_learning_schema', up: learningSchema },
+  { version: 3, name: '003_code_schema', up: codeSchema },
+  { version: 4, name: '004_synapses_schema', up: synapsesSchema },
+  { version: 5, name: '005_fts_indexes', up: ftsIndexes },
+  { version: 6, name: '006_synapses_phase3', up: synapsesPhase3 },
+];
+
+function ensureMigrationsTable(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS migrations (
+      version INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+
+function getCurrentVersion(db: Database.Database): number {
+  const row = db.prepare('SELECT MAX(version) as version FROM migrations').get() as { version: number | null } | undefined;
+  return row?.version ?? 0;
+}
+
+export function runMigrations(db: Database.Database): void {
+  const logger = getLogger();
+  ensureMigrationsTable(db);
+
+  const currentVersion = getCurrentVersion(db);
+  const pending = migrations.filter(m => m.version > currentVersion);
+
+  if (pending.length === 0) {
+    logger.info('Database is up to date');
+    return;
+  }
+
+  logger.info(`Running ${pending.length} migration(s) from version ${currentVersion}`);
+
+  const runAll = db.transaction(() => {
+    for (const migration of pending) {
+      logger.info(`Applying migration ${migration.name}`);
+      migration.up(db);
+      db.prepare('INSERT INTO migrations (version, name) VALUES (?, ?)').run(migration.version, migration.name);
+    }
+  });
+
+  runAll();
+  logger.info(`Migrations complete. Now at version ${pending[pending.length - 1]!.version}`);
+}

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

@@ -0,0 +1,66 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface AntipatternRecord {
+  id: number;
+  pattern: string;
+  description: string;
+  severity: string;
+  suggestion: string | null;
+  occurrences: number;
+  project_id: number | null;
+  global: number;
+  created_at: string;
+}
+
+type AntipatternCreate = Omit<AntipatternRecord, 'id' | 'created_at'>;
+type AntipatternUpdate = Partial<Omit<AntipatternRecord, 'id' | 'created_at'>>;
+
+export class AntipatternRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO antipatterns (pattern, description, severity, suggestion, occurrences, project_id, global)
+        VALUES (@pattern, @description, @severity, @suggestion, @occurrences, @project_id, @global)
+      `),
+      getById: db.prepare('SELECT * FROM antipatterns WHERE id = ?'),
+      delete: db.prepare('DELETE FROM antipatterns WHERE id = ?'),
+      findByProject: db.prepare('SELECT * FROM antipatterns WHERE project_id = ? ORDER BY occurrences DESC'),
+      findGlobal: db.prepare('SELECT * FROM antipatterns WHERE global = 1 ORDER BY occurrences DESC'),
+    };
+  }
+
+  create(data: AntipatternCreate): number {
+    const result = this.stmts.create.run(data);
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): AntipatternRecord | undefined {
+    return this.stmts.getById.get(id) as AntipatternRecord | undefined;
+  }
+
+  update(id: number, data: AntipatternUpdate): 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 antipatterns 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;
+  }
+
+  findByProject(projectId: number): AntipatternRecord[] {
+    return this.stmts.findByProject.all(projectId) as AntipatternRecord[];
+  }
+
+  findGlobal(): AntipatternRecord[] {
+    return this.stmts.findGlobal.all() as AntipatternRecord[];
+  }
+}

package/src/db/repositories/code-module.repository.ts

@@ -0,0 +1,80 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { CodeModuleRecord } from '../../types/code.types.js';
+
+type CodeModuleCreate = Omit<CodeModuleRecord, 'id' | 'created_at' | 'updated_at'>;
+type CodeModuleUpdate = Partial<Omit<CodeModuleRecord, 'id' | 'created_at'>>;
+
+export class CodeModuleRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO code_modules (project_id, name, file_path, language, fingerprint, description, source_hash, lines_of_code, complexity, reusability_score)
+        VALUES (@project_id, @name, @file_path, @language, @fingerprint, @description, @source_hash, @lines_of_code, @complexity, @reusability_score)
+      `),
+      getById: db.prepare('SELECT * FROM code_modules WHERE id = ?'),
+      delete: db.prepare('DELETE FROM code_modules WHERE id = ?'),
+      findByFingerprint: db.prepare('SELECT * FROM code_modules WHERE fingerprint = ?'),
+      findByProject: db.prepare('SELECT * FROM code_modules WHERE project_id = ? ORDER BY name ASC'),
+      countAll: db.prepare('SELECT COUNT(*) as count FROM code_modules'),
+      search: db.prepare(`
+        SELECT cm.* FROM code_modules cm
+        JOIN code_modules_fts fts ON cm.id = fts.rowid
+        WHERE code_modules_fts MATCH ?
+        ORDER BY rank
+      `),
+    };
+  }
+
+  create(data: CodeModuleCreate): number {
+    const result = this.stmts.create.run(data);
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): CodeModuleRecord | undefined {
+    return this.stmts.getById.get(id) as CodeModuleRecord | undefined;
+  }
+
+  update(id: number, data: CodeModuleUpdate): 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 code_modules 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;
+  }
+
+  findByFingerprint(fingerprint: string): CodeModuleRecord | undefined {
+    return this.stmts.findByFingerprint.get(fingerprint) as CodeModuleRecord | undefined;
+  }
+
+  findByLanguage(language: string, limit?: number): CodeModuleRecord[] {
+    const sql = limit
+      ? 'SELECT * FROM code_modules WHERE language = ? ORDER BY name ASC LIMIT ?'
+      : 'SELECT * FROM code_modules WHERE language = ? ORDER BY name ASC';
+    const stmt = this.db.prepare(sql);
+    return (limit ? stmt.all(language, limit) : stmt.all(language)) as CodeModuleRecord[];
+  }
+
+  findByProject(projectId: number): CodeModuleRecord[] {
+    return this.stmts.findByProject.all(projectId) as CodeModuleRecord[];
+  }
+
+  search(query: string): CodeModuleRecord[] {
+    return this.stmts.search.all(query) as CodeModuleRecord[];
+  }
+
+  countAll(): number {
+    return (this.stmts.countAll.get() as { count: number }).count;
+  }
+}