@timmeck/brain 1.2.0 → 1.8.0

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;
+  `);
+}

package/src/db/migrations/index.ts

@@ -6,6 +6,9 @@ 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';
+import { up as feedbackSchema } from './007_feedback.js';
+import { up as gitIntegration } from './008_git_integration.js';
+import { up as embeddings } from './009_embeddings.js';
 
 interface Migration {
   version: number;
@@ -20,6 +23,9 @@ const migrations: Migration[] = [
   { version: 4, name: '004_synapses_schema', up: synapsesSchema },
   { version: 5, name: '005_fts_indexes', up: ftsIndexes },
   { version: 6, name: '006_synapses_phase3', up: synapsesPhase3 },
+  { version: 7, name: '007_feedback', up: feedbackSchema },
+  { version: 8, name: '008_git_integration', up: gitIntegration },
+  { version: 9, name: '009_embeddings', up: embeddings },
 ];
 
 function ensureMigrationsTable(db: Database.Database): void {

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

@@ -26,6 +26,33 @@ export class CodeModuleRepository {
         WHERE code_modules_fts MATCH ?
         ORDER BY rank
       `),
+      upsertSimilarity: db.prepare(`
+        INSERT INTO module_similarities (module_a_id, module_b_id, similarity_score)
+        VALUES (@module_a_id, @module_b_id, @similarity_score)
+        ON CONFLICT(module_a_id, module_b_id)
+        DO UPDATE SET similarity_score = @similarity_score, computed_at = datetime('now')
+      `),
+      findSimilarModules: db.prepare(`
+        SELECT ms.*, cm.name, cm.file_path, cm.language, cm.reusability_score
+        FROM module_similarities ms
+        JOIN code_modules cm ON (
+          CASE WHEN ms.module_a_id = ? THEN ms.module_b_id ELSE ms.module_a_id END
+        ) = cm.id
+        WHERE ms.module_a_id = ? OR ms.module_b_id = ?
+        ORDER BY ms.similarity_score DESC
+        LIMIT ?
+      `),
+      findHighSimilarityPairs: db.prepare(`
+        SELECT ms.*,
+          a.name as a_name, a.file_path as a_path,
+          b.name as b_name, b.file_path as b_path
+        FROM module_similarities ms
+        JOIN code_modules a ON ms.module_a_id = a.id
+        JOIN code_modules b ON ms.module_b_id = b.id
+        WHERE ms.similarity_score >= ?
+        ORDER BY ms.similarity_score DESC
+        LIMIT ?
+      `),
     };
   }
 
@@ -86,4 +113,30 @@ export class CodeModuleRepository {
   countAll(): number {
     return (this.stmts.countAll.get() as { count: number }).count;
   }
+
+  upsertSimilarity(moduleAId: number, moduleBId: number, score: number): void {
+    // Always store with smaller id first for consistency
+    const [a, b] = moduleAId < moduleBId ? [moduleAId, moduleBId] : [moduleBId, moduleAId];
+    this.stmts.upsertSimilarity.run({
+      module_a_id: a,
+      module_b_id: b,
+      similarity_score: score,
+    });
+  }
+
+  findSimilarModules(moduleId: number, limit: number = 10): Array<{ module_id: number; similarity_score: number; name: string; file_path: string }> {
+    return this.stmts.findSimilarModules.all(moduleId, moduleId, moduleId, limit) as Array<{
+      module_id: number; similarity_score: number; name: string; file_path: string;
+    }>;
+  }
+
+  findHighSimilarityPairs(minScore: number = 0.75, limit: number = 50): Array<{
+    module_a_id: number; module_b_id: number; similarity_score: number;
+    a_name: string; a_path: string; b_name: string; b_path: string;
+  }> {
+    return this.stmts.findHighSimilarityPairs.all(minScore, limit) as Array<{
+      module_a_id: number; module_b_id: number; similarity_score: number;
+      a_name: string; a_path: string; b_name: string; b_path: string;
+    }>;
+  }
 }

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

@@ -14,6 +14,22 @@ export class ErrorRepository {
         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)
       `),
+      createChain: this.db.prepare(`
+        INSERT OR IGNORE INTO error_chains (parent_error_id, child_error_id, relationship)
+        VALUES (@parent_error_id, @child_error_id, @relationship)
+      `),
+      findChainChildren: this.db.prepare(
+        'SELECT e.* FROM errors e JOIN error_chains ec ON e.id = ec.child_error_id WHERE ec.parent_error_id = ?'
+      ),
+      findChainParents: this.db.prepare(
+        'SELECT e.* FROM errors e JOIN error_chains ec ON e.id = ec.parent_error_id WHERE ec.child_error_id = ?'
+      ),
+      findRecentByProject: this.db.prepare(
+        'SELECT * FROM errors WHERE project_id = ? AND first_seen >= ? ORDER BY first_seen DESC LIMIT ?'
+      ),
+      findAllPaginated: this.db.prepare(
+        'SELECT * FROM errors ORDER BY last_seen DESC LIMIT ? OFFSET ?'
+      ),
       getById: this.db.prepare(`
         SELECT * FROM errors WHERE id = ?
       `),
@@ -146,4 +162,28 @@ export class ErrorRepository {
   incrementOccurrence(id: number): void {
     this.stmts.incrementOccurrence.run(id);
   }
+
+  createChain(parentErrorId: number, childErrorId: number, relationship: string = 'caused_by_fix'): void {
+    this.stmts.createChain.run({
+      parent_error_id: parentErrorId,
+      child_error_id: childErrorId,
+      relationship,
+    });
+  }
+
+  findChainChildren(errorId: number): ErrorRecord[] {
+    return this.stmts.findChainChildren.all(errorId) as ErrorRecord[];
+  }
+
+  findChainParents(errorId: number): ErrorRecord[] {
+    return this.stmts.findChainParents.all(errorId) as ErrorRecord[];
+  }
+
+  findRecentByProject(projectId: number, since: string, limit: number = 10): ErrorRecord[] {
+    return this.stmts.findRecentByProject.all(projectId, since, limit) as ErrorRecord[];
+  }
+
+  findAll(limit: number = 100, offset: number = 0): ErrorRecord[] {
+    return this.stmts.findAllPaginated.all(limit, offset) as ErrorRecord[];
+  }
 }

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

@@ -75,4 +75,25 @@ export class InsightRepository {
     const result = this.stmts.expire.run();
     return result.changes;
   }
+
+  rate(id: number, rating: number, comment?: string): boolean {
+    const stmt = this.db.prepare(
+      `UPDATE insights SET rating = ?, rating_comment = ?, rated_at = datetime('now') WHERE id = ?`
+    );
+    const result = stmt.run(rating, comment ?? null, id);
+    return result.changes > 0;
+  }
+
+  findRated(minRating?: number): InsightRecord[] {
+    if (minRating !== undefined) {
+      const stmt = this.db.prepare(
+        'SELECT * FROM insights WHERE rating IS NOT NULL AND rating >= ? ORDER BY rating DESC'
+      );
+      return stmt.all(minRating) as InsightRecord[];
+    }
+    const stmt = this.db.prepare(
+      'SELECT * FROM insights WHERE rating IS NOT NULL ORDER BY rating DESC'
+    );
+    return stmt.all() as InsightRecord[];
+  }
 }