@timmeck/brain 1.1.1 → 1.8.0

package/src/cli/commands/doctor.ts

@@ -0,0 +1,118 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { getDataDir } from '../../utils/paths.js';
+import { IpcClient } from '../../ipc/client.js';
+import { getPipeName } from '../../utils/paths.js';
+import { c, icons, header, divider } from '../colors.js';
+
+function pass(label: string, detail?: string): void {
+  const extra = detail ? ` ${c.dim(detail)}` : '';
+  console.log(`  ${c.green(icons.check)}  ${label}${extra}`);
+}
+
+function fail(label: string, detail?: string): void {
+  const extra = detail ? ` ${c.dim(detail)}` : '';
+  console.log(`  ${c.red(icons.cross)}  ${label}${extra}`);
+}
+
+export function doctorCommand(): Command {
+  return new Command('doctor')
+    .description('Check Brain health: daemon, DB, MCP, hooks')
+    .action(async () => {
+      console.log(header('Brain Doctor', icons.brain));
+      console.log();
+
+      let allGood = true;
+
+      // 1. Daemon running?
+      const pidPath = path.join(getDataDir(), 'brain.pid');
+      let daemonRunning = false;
+      if (fs.existsSync(pidPath)) {
+        const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+        try {
+          process.kill(pid, 0);
+          daemonRunning = true;
+          pass('Daemon running', `PID ${pid}`);
+        } catch {
+          fail('Daemon not running', 'stale PID file');
+          allGood = false;
+        }
+      } else {
+        fail('Daemon not running', 'no PID file');
+        allGood = false;
+      }
+
+      // 2. DB reachable? (only if daemon running)
+      if (daemonRunning) {
+        const client = new IpcClient(getPipeName(), 3000);
+        try {
+          await client.connect();
+          await client.request('analytics.summary', {});
+          pass('Database reachable');
+        } catch {
+          fail('Database not reachable');
+          allGood = false;
+        } finally {
+          client.disconnect();
+        }
+      } else {
+        fail('Database not reachable', 'daemon not running');
+        allGood = false;
+      }
+
+      // 3. MCP configured?
+      const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+      let mcpConfigured = false;
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        if (settings.mcpServers?.brain || settings.mcpServers?.['brain-mcp']) {
+          mcpConfigured = true;
+          pass('MCP server configured');
+        } else {
+          fail('MCP server not configured', `edit ${settingsPath}`);
+          allGood = false;
+        }
+      } catch {
+        fail('MCP server not configured', 'settings.json not found');
+        allGood = false;
+      }
+
+      // 4. Hook active?
+      try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        const hooks = settings.hooks;
+        const hasPostToolUse = hooks?.PostToolUse?.some(
+          (h: { command?: string }) => h.command?.includes('brain') || h.command?.includes('post-tool-use'),
+        );
+        if (hasPostToolUse) {
+          pass('Auto-detect hook active');
+        } else {
+          fail('Auto-detect hook not configured', 'errors won\'t be tracked automatically');
+          allGood = false;
+        }
+      } catch {
+        fail('Auto-detect hook not configured');
+        allGood = false;
+      }
+
+      // 5. DB file size
+      const dbPath = path.join(getDataDir(), 'brain.db');
+      try {
+        const stat = fs.statSync(dbPath);
+        pass('Database file', `${(stat.size / 1024 / 1024).toFixed(1)} MB at ${dbPath}`);
+      } catch {
+        fail('Database file not found');
+        allGood = false;
+      }
+
+      console.log();
+      if (allGood) {
+        console.log(`  ${icons.ok}  ${c.success('All checks passed!')}`);
+      } else {
+        console.log(`  ${icons.warn}  ${c.warn('Some checks failed.')} Run ${c.cyan('brain start')} and check your MCP config.`);
+      }
+      console.log(`\n${divider()}`);
+    });
+}

package/src/cli/commands/explain.ts

@@ -0,0 +1,83 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons } from '../colors.js';
+
+export function explainCommand(): Command {
+  return new Command('explain')
+    .description('Show everything Brain knows about an error')
+    .argument('<errorId>', 'Error ID to explain')
+    .action(async (errorId) => {
+      const id = parseInt(errorId, 10);
+      if (isNaN(id)) {
+        console.error(`${icons.error} Invalid error ID: ${errorId}`);
+        process.exit(1);
+      }
+
+      await withIpc(async (client) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const result: any = await client.request('analytics.explain', { errorId: id });
+
+        if (!result.error) {
+          console.error(`${icons.error} Error #${id} not found.`);
+          return;
+        }
+
+        const err = result.error;
+        console.log();
+        console.log(`${icons.brain}  ${c.heading(`Error #${err.id} — ${err.type}`)}`);
+        console.log(`${c.dim('─'.repeat(60))}`);
+        console.log(`  ${c.label('Message:')}   ${err.message}`);
+        console.log(`  ${c.label('File:')}      ${err.file_path ?? 'unknown'}`);
+        console.log(`  ${c.label('Context:')}   ${err.context ?? 'none'}`);
+        console.log(`  ${c.label('Seen:')}      ${err.occurrence_count}x (first: ${err.first_seen}, last: ${err.last_seen})`);
+        console.log(`  ${c.label('Resolved:')}  ${err.resolved ? c.success('Yes') : c.error('No')}`);
+        console.log(`  ${c.label('Synapses:')}  ${result.synapseConnections} connections`);
+
+        // Error Chain
+        if (result.chain.parents.length > 0 || result.chain.children.length > 0) {
+          console.log();
+          console.log(`  ${c.heading('Error Chain:')}`);
+          for (const p of result.chain.parents) {
+            console.log(`    ${c.dim('↑')} Caused by: #${p.id} ${p.type}: ${p.message.slice(0, 60)}`);
+          }
+          console.log(`    ${c.info('→')} #${err.id} ${err.type}`);
+          for (const ch of result.chain.children) {
+            console.log(`    ${c.dim('↓')} Led to: #${ch.id} ${ch.type}: ${ch.message.slice(0, 60)}`);
+          }
+        }
+
+        // Solutions
+        if (result.solutions.length > 0) {
+          console.log();
+          console.log(`  ${c.heading('Solutions:')}`);
+          for (const s of result.solutions) {
+            const rate = `${Math.round(s.successRate * 100)}%`;
+            console.log(`    ${icons.ok} #${s.id}: ${s.description.slice(0, 80)} (success: ${rate}, confidence: ${s.confidence.toFixed(2)})`);
+          }
+        } else {
+          console.log();
+          console.log(`  ${c.dim('No solutions found.')}`);
+        }
+
+        // Related Errors
+        if (result.relatedErrors.length > 0) {
+          console.log();
+          console.log(`  ${c.heading('Related Errors:')}`);
+          for (const r of result.relatedErrors.slice(0, 5)) {
+            console.log(`    ${c.dim('~')} #${r.id} ${r.type}: ${r.message.slice(0, 60)} (${Math.round(r.similarity * 100)}%)`);
+          }
+        }
+
+        // Rules
+        if (result.rules.length > 0) {
+          console.log();
+          console.log(`  ${c.heading('Applicable Rules:')}`);
+          for (const r of result.rules) {
+            console.log(`    ${icons.gear} #${r.id}: ${r.action} (confidence: ${r.confidence.toFixed(2)})`);
+          }
+        }
+
+        console.log();
+      });
+    });
+}

package/src/cli/commands/projects.ts

@@ -0,0 +1,42 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { c, icons, header, divider, table } from '../colors.js';
+
+export function projectsCommand(): Command {
+  return new Command('projects')
+    .description('List all imported projects with stats')
+    .action(async () => {
+      await withIpc(async (client) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const projects = await client.request('project.list', {}) as any[];
+
+        console.log(header('Projects', icons.module));
+
+        if (projects.length === 0) {
+          console.log(`\n  ${c.dim('No projects imported yet.')} Use ${c.cyan('brain import <dir>')} to get started.`);
+          console.log(`\n${divider()}`);
+          return;
+        }
+
+        console.log();
+
+        const rows: string[][] = [
+          [c.dim('  #'), c.dim('Name'), c.dim('Language'), c.dim('Modules'), c.dim('Path')],
+        ];
+
+        for (const p of projects) {
+          rows.push([
+            c.dimmer(`  ${p.id}`),
+            c.value(p.name),
+            p.language ? c.cyan(p.language) : c.dim('—'),
+            c.green(String(p.moduleCount)),
+            p.path ? c.dim(p.path) : c.dim('—'),
+          ]);
+        }
+
+        console.log(table(rows, [5, 24, 14, 9, 40]));
+        console.log(`\n  ${c.label('Total:')} ${c.value(String(projects.length))} projects, ${c.green(String(projects.reduce((s: number, p: any) => s + p.moduleCount, 0)))} modules`);
+        console.log(`\n${divider()}`);
+      });
+    });
+}

package/src/code/analyzer.ts

@@ -10,6 +10,7 @@ export interface AnalysisResult {
   isPure: boolean;
   hasTypeAnnotations: boolean;
   linesOfCode: number;
+  complexity: number;
 }
 
 const SIDE_EFFECT_PATTERNS = [
@@ -37,6 +38,7 @@ export function analyzeCode(source: string, language: string): AnalysisResult {
   const isPure = checkPurity(source);
   const typed = parser.hasTypeAnnotations(source);
   const linesOfCode = source.split('\n').filter(l => l.trim().length > 0).length;
+  const complexity = computeCyclomaticComplexity(source, language);
 
   return {
     exports,
@@ -45,9 +47,47 @@ export function analyzeCode(source: string, language: string): AnalysisResult {
     isPure,
     hasTypeAnnotations: typed,
     linesOfCode,
+    complexity,
   };
 }
 
+/**
+ * Computes cyclomatic complexity: counts decision points in the code.
+ * CC = 1 + number of decision points (if, else if, for, while, case, catch, &&, ||, ?:)
+ */
+export function computeCyclomaticComplexity(source: string, language: string): number {
+  // Remove comments and strings to avoid false positives
+  const cleaned = source
+    .replace(/\/\/.*$/gm, '')           // single-line comments
+    .replace(/\/\*[\s\S]*?\*\//g, '')   // multi-line comments
+    .replace(/#.*$/gm, '')              // Python comments
+    .replace(/(["'`])(?:(?!\1|\\).|\\.)*\1/g, '""'); // strings
+
+  let complexity = 1; // Base complexity
+
+  // Language-agnostic decision point patterns
+  const patterns = [
+    /\bif\b/g,
+    /\belse\s+if\b/g,
+    /\belif\b/g,
+    /\bfor\b/g,
+    /\bwhile\b/g,
+    /\bcase\b/g,
+    /\bcatch\b/g,
+    /\bexcept\b/g,
+    /&&/g,
+    /\|\|/g,
+    /\?\s*[^:]/g, // ternary operator (not type annotations)
+  ];
+
+  for (const pattern of patterns) {
+    const matches = cleaned.match(pattern);
+    if (matches) complexity += matches.length;
+  }
+
+  return complexity;
+}
+
 export function checkPurity(source: string): boolean {
   return !SIDE_EFFECT_PATTERNS.some(p => source.includes(p));
 }

package/src/code/matcher.ts

@@ -1,12 +1,12 @@
 import type { CodeModuleRecord } from '../types/code.types.js';
 import { fingerprintCode } from './fingerprint.js';
 import { tokenize } from '../matching/tokenizer.js';
-import { cosineSimilarity, jaccardSimilarity } from '../matching/similarity.js';
+import { cosineSimilarity } from '../matching/similarity.js';
 
 export interface CodeMatchResult {
   moduleId: number;
   score: number;
-  matchType: 'exact' | 'structural' | 'semantic';
+  matchType: 'exact' | 'structural' | 'semantic' | 'vector';
 }
 
 export function findExactMatches(
@@ -62,3 +62,68 @@ export function findSemanticMatches(
     .filter(r => r.score >= threshold)
     .sort((a, b) => b.score - a.score);
 }
+
+/**
+ * Find matches using pre-computed vector embeddings.
+ * Vector scores are computed externally (by the EmbeddingEngine) and passed in.
+ */
+export function findVectorMatches(
+  vectorScores: Map<number, number>,
+  threshold: number = 0.5,
+): CodeMatchResult[] {
+  const results: CodeMatchResult[] = [];
+
+  for (const [moduleId, score] of vectorScores) {
+    if (score >= threshold) {
+      results.push({ moduleId, score, matchType: 'vector' });
+    }
+  }
+
+  return results.sort((a, b) => b.score - a.score);
+}
+
+/**
+ * Hybrid search: combine structural + semantic + vector matches,
+ * deduplicating and taking the highest score per module.
+ */
+export function findHybridMatches(
+  source: string,
+  language: string,
+  description: string,
+  candidates: CodeModuleRecord[],
+  vectorScores?: Map<number, number>,
+): CodeMatchResult[] {
+  const scoreMap = new Map<number, CodeMatchResult>();
+
+  // Structural matches (highest priority)
+  for (const match of findStructuralMatches(source, language, candidates, 0.5)) {
+    const existing = scoreMap.get(match.moduleId);
+    if (!existing || match.score > existing.score) {
+      scoreMap.set(match.moduleId, match);
+    }
+  }
+
+  // Semantic matches
+  for (const match of findSemanticMatches(description, candidates, 0.3)) {
+    const existing = scoreMap.get(match.moduleId);
+    if (!existing || match.score > existing.score) {
+      scoreMap.set(match.moduleId, match);
+    }
+  }
+
+  // Vector matches (if available)
+  if (vectorScores && vectorScores.size > 0) {
+    for (const match of findVectorMatches(vectorScores, 0.4)) {
+      const existing = scoreMap.get(match.moduleId);
+      if (!existing) {
+        scoreMap.set(match.moduleId, match);
+      } else {
+        // Boost existing matches that also have high vector similarity
+        const vectorBoost = match.score * 0.15;
+        existing.score = Math.min(1.0, existing.score + vectorBoost);
+      }
+    }
+  }
+
+  return [...scoreMap.values()].sort((a, b) => b.score - a.score);
+}

package/src/code/scorer.ts

@@ -6,6 +6,7 @@ export interface CodeUnitForScoring {
   exports: ExportInfo[];
   internalDeps: string[];
   hasTypeAnnotations: boolean;
+  complexity?: number;
 }
 
 interface ReusabilitySignal {
@@ -17,7 +18,7 @@ interface ReusabilitySignal {
 const REUSABILITY_SIGNALS: ReusabilitySignal[] = [
   {
     name: 'single_responsibility',
-    weight: 0.25,
+    weight: 0.20,
     check: (code) => {
       const count = code.exports.length;
       if (count === 0) return 0;
@@ -88,6 +89,17 @@ const REUSABILITY_SIGNALS: ReusabilitySignal[] = [
       return 0.1;
     },
   },
+  {
+    name: 'low_complexity',
+    weight: 0.10,
+    check: (code) => {
+      const cc = code.complexity ?? 1;
+      if (cc <= 5) return 1.0;
+      if (cc <= 10) return 0.7;
+      if (cc <= 20) return 0.4;
+      return 0.1;
+    },
+  },
 ];
 
 export const MODULE_THRESHOLD = 0.60;

package/src/config.ts

@@ -10,6 +10,21 @@ const defaults: BrainConfig = {
     pipeName: getPipeName(),
     timeout: 5000,
   },
+  api: {
+    port: 7777,
+    enabled: true,
+  },
+  mcpHttp: {
+    port: 7778,
+    enabled: true,
+  },
+  embeddings: {
+    enabled: true,
+    modelName: 'Xenova/all-MiniLM-L6-v2',
+    cacheDir: path.join(getDataDir(), 'models'),
+    sweepIntervalMs: 300_000, // 5 minutes
+    batchSize: 50,
+  },
   learning: {
     intervalMs: 900_000,
     minOccurrences: 3,
@@ -27,6 +42,8 @@ const defaults: BrainConfig = {
     fingerprintFields: ['type', 'message', 'file_path'],
     similarityThreshold: 0.8,
     maxResults: 10,
+    crossProjectMatching: true,
+    crossProjectWeight: 0.7,
   },
   code: {
     supportedLanguages: ['typescript', 'javascript', 'python', 'rust', 'go'],
@@ -74,6 +91,13 @@ function applyEnvOverrides(config: BrainConfig): void {
   if (process.env['BRAIN_DB_PATH']) config.dbPath = process.env['BRAIN_DB_PATH'];
   if (process.env['BRAIN_LOG_LEVEL']) config.log.level = process.env['BRAIN_LOG_LEVEL'];
   if (process.env['BRAIN_PIPE_NAME']) config.ipc.pipeName = process.env['BRAIN_PIPE_NAME'];
+  if (process.env['BRAIN_API_PORT']) config.api.port = Number(process.env['BRAIN_API_PORT']);
+  if (process.env['BRAIN_API_ENABLED']) config.api.enabled = process.env['BRAIN_API_ENABLED'] !== 'false';
+  if (process.env['BRAIN_API_KEY']) config.api.apiKey = process.env['BRAIN_API_KEY'];
+  if (process.env['BRAIN_MCP_HTTP_PORT']) config.mcpHttp.port = Number(process.env['BRAIN_MCP_HTTP_PORT']);
+  if (process.env['BRAIN_MCP_HTTP_ENABLED']) config.mcpHttp.enabled = process.env['BRAIN_MCP_HTTP_ENABLED'] !== 'false';
+  if (process.env['BRAIN_EMBEDDINGS_ENABLED']) config.embeddings.enabled = process.env['BRAIN_EMBEDDINGS_ENABLED'] !== 'false';
+  if (process.env['BRAIN_EMBEDDINGS_MODEL']) config.embeddings.modelName = process.env['BRAIN_EMBEDDINGS_MODEL'];
 }
 
 function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): void {

package/src/dashboard/server.ts

@@ -0,0 +1,142 @@
+import http from 'node:http';
+import { getEventBus } from '../utils/events.js';
+import { getLogger } from '../utils/logger.js';
+
+export interface DashboardServerOptions {
+  port: number;
+  getDashboardHtml: () => string;
+  getStats: () => unknown;
+}
+
+export class DashboardServer {
+  private server: http.Server | null = null;
+  private clients: Set<http.ServerResponse> = new Set();
+  private logger = getLogger();
+
+  constructor(private options: DashboardServerOptions) {}
+
+  start(): void {
+    const { port, getDashboardHtml, getStats } = this.options;
+    const bus = getEventBus();
+
+    this.server = http.createServer((req, res) => {
+      const url = new URL(req.url ?? '/', `http://localhost:${port}`);
+
+      // CORS
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+
+      if (url.pathname === '/events') {
+        // SSE endpoint
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+        });
+        res.write('data: {"type":"connected"}\n\n');
+
+        this.clients.add(res);
+        req.on('close', () => this.clients.delete(res));
+        return;
+      }
+
+      if (url.pathname === '/api/stats') {
+        const stats = getStats();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(stats));
+        return;
+      }
+
+      if (url.pathname === '/' || url.pathname === '/dashboard') {
+        const html = getDashboardHtml();
+        // Inject SSE script into the dashboard
+        const sseScript = `
+<script>
+(function(){
+  const evtSource = new EventSource('/events');
+  evtSource.onmessage = function(e) {
+    try {
+      const data = JSON.parse(e.data);
+      if (data.type === 'stats_update') {
+        // Update stat cards
+        document.querySelectorAll('.stat-number').forEach(el => {
+          const key = el.parentElement?.querySelector('.stat-label')?.textContent?.toLowerCase();
+          if (key && data.stats[key] !== undefined) {
+            el.textContent = Number(data.stats[key]).toLocaleString();
+          }
+        });
+      }
+      if (data.type === 'event') {
+        // Flash the activity dot
+        const dot = document.querySelector('.activity-dot');
+        if (dot) { dot.style.background = '#ff5577'; setTimeout(() => dot.style.background = '', 500); }
+      }
+    } catch {}
+  };
+  evtSource.onerror = function() { setTimeout(() => location.reload(), 5000); };
+})();
+</script>`;
+        const liveHtml = html.replace('</body>', sseScript + '</body>');
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(liveHtml);
+        return;
+      }
+
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not Found');
+    });
+
+    // Forward Brain events to SSE clients
+    const eventNames = [
+      'error:reported', 'error:resolved', 'solution:applied',
+      'solution:created', 'module:registered', 'module:updated',
+      'synapse:created', 'synapse:strengthened',
+      'insight:created', 'rule:learned',
+    ] as const;
+
+    for (const eventName of eventNames) {
+      bus.on(eventName, (data: unknown) => {
+        this.broadcast({ type: 'event', event: eventName, data });
+      });
+    }
+
+    // Periodic stats broadcast (every 30s)
+    setInterval(() => {
+      if (this.clients.size > 0) {
+        const stats = getStats();
+        this.broadcast({ type: 'stats_update', stats });
+      }
+    }, 30_000);
+
+    this.server.listen(port, () => {
+      this.logger.info(`Dashboard server started on http://localhost:${port}`);
+    });
+  }
+
+  stop(): void {
+    for (const client of this.clients) {
+      client.end();
+    }
+    this.clients.clear();
+    this.server?.close();
+    this.server = null;
+    this.logger.info('Dashboard server stopped');
+  }
+
+  private broadcast(data: unknown): void {
+    const msg = `data: ${JSON.stringify(data)}\n\n`;
+    for (const client of this.clients) {
+      try {
+        client.write(msg);
+      } catch {
+        this.clients.delete(client);
+      }
+    }
+  }
+}

package/src/db/migrations/007_feedback.ts

@@ -0,0 +1,13 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    ALTER TABLE insights ADD COLUMN rating INTEGER DEFAULT NULL;
+    ALTER TABLE insights ADD COLUMN rating_comment TEXT DEFAULT NULL;
+    ALTER TABLE insights ADD COLUMN rated_at TEXT DEFAULT NULL;
+
+    ALTER TABLE rules ADD COLUMN rating INTEGER DEFAULT NULL;
+    ALTER TABLE rules ADD COLUMN rating_comment TEXT DEFAULT NULL;
+    ALTER TABLE rules ADD COLUMN rated_at TEXT DEFAULT NULL;
+  `);
+}

package/src/db/migrations/008_git_integration.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 git_commits (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL,
+      commit_hash TEXT NOT NULL,
+      message TEXT NOT NULL,
+      author TEXT,
+      timestamp TEXT NOT NULL,
+      files_changed INTEGER NOT NULL DEFAULT 0,
+      insertions INTEGER NOT NULL DEFAULT 0,
+      deletions INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+      UNIQUE(project_id, commit_hash)
+    );
+
+    CREATE TABLE IF NOT EXISTS error_commits (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      error_id INTEGER NOT NULL,
+      commit_hash TEXT NOT NULL,
+      relationship TEXT NOT NULL DEFAULT 'introduced_by',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (error_id) REFERENCES errors(id) ON DELETE CASCADE,
+      UNIQUE(error_id, commit_hash, relationship)
+    );
+
+    ALTER TABLE errors ADD COLUMN git_diff TEXT DEFAULT NULL;
+    ALTER TABLE errors ADD COLUMN git_branch TEXT DEFAULT NULL;
+
+    CREATE INDEX IF NOT EXISTS idx_git_commits_project ON git_commits(project_id);
+    CREATE INDEX IF NOT EXISTS idx_git_commits_hash ON git_commits(commit_hash);
+    CREATE INDEX IF NOT EXISTS idx_error_commits_error ON error_commits(error_id);
+    CREATE INDEX IF NOT EXISTS idx_error_commits_hash ON error_commits(commit_hash);
+  `);
+}

package/src/db/migrations/009_embeddings.ts

@@ -0,0 +1,8 @@
+import type Database from 'better-sqlite3';
+
+export function up(db: Database.Database): void {
+  db.exec(`
+    ALTER TABLE errors ADD COLUMN embedding BLOB DEFAULT NULL;
+    ALTER TABLE code_modules ADD COLUMN embedding BLOB DEFAULT NULL;
+  `);
+}