@timmeck/brain 1.8.1 → 1.8.2

package/src/embeddings/engine.ts

@@ -1,238 +1,238 @@
-import path from 'node:path';
-import type Database from 'better-sqlite3';
-import { getLogger } from '../utils/logger.js';
-
-export interface EmbeddingConfig {
-  enabled: boolean;
-  modelName: string;
-  cacheDir: string;
-  sweepIntervalMs: number;
-  batchSize: number;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Pipeline = any;
-
-export class EmbeddingEngine {
-  private pipeline: Pipeline = null;
-  private ready = false;
-  private loading = false;
-  private logger = getLogger();
-  private sweepTimer: ReturnType<typeof setInterval> | null = null;
-
-  constructor(
-    private config: EmbeddingConfig,
-    private db: Database.Database,
-  ) {}
-
-  async initialize(): Promise<void> {
-    if (!this.config.enabled || this.loading || this.ready) return;
-
-    this.loading = true;
-    try {
-      const { pipeline, env } = await import('@huggingface/transformers');
-      env.cacheDir = this.config.cacheDir;
-
-      this.pipeline = await pipeline(
-        'feature-extraction',
-        this.config.modelName,
-        { dtype: 'q8' },
-      );
-
-      this.ready = true;
-      this.logger.info(`Embedding model loaded: ${this.config.modelName}`);
-    } catch (err) {
-      this.logger.warn(`Failed to load embedding model (will retry): ${err}`);
-      this.ready = false;
-    } finally {
-      this.loading = false;
-    }
-  }
-
-  /** Start background embedding sweep */
-  start(): void {
-    if (!this.config.enabled) return;
-
-    // Initialize model in background
-    this.initialize().then(() => {
-      if (this.ready) {
-        // Run initial sweep
-        this.sweep().catch(err => this.logger.error('Embedding sweep error:', err));
-      }
-    });
-
-    // Periodic sweep for new entries
-    this.sweepTimer = setInterval(() => {
-      if (this.ready) {
-        this.sweep().catch(err => this.logger.error('Embedding sweep error:', err));
-      }
-    }, this.config.sweepIntervalMs);
-  }
-
-  stop(): void {
-    if (this.sweepTimer) {
-      clearInterval(this.sweepTimer);
-      this.sweepTimer = null;
-    }
-  }
-
-  isReady(): boolean {
-    return this.ready;
-  }
-
-  /** Generate embedding for a single text */
-  async embed(text: string): Promise<Float32Array | null> {
-    if (!this.ready || !this.pipeline) return null;
-
-    try {
-      const output = await this.pipeline(text, { pooling: 'mean', normalize: true });
-      const data = output.tolist()[0] as number[];
-      return new Float32Array(data);
-    } catch (err) {
-      this.logger.error(`Embedding error: ${err}`);
-      return null;
-    }
-  }
-
-  /** Generate embeddings for a batch of texts */
-  async embedBatch(texts: string[]): Promise<(Float32Array | null)[]> {
-    if (!this.ready || !this.pipeline || texts.length === 0) return texts.map(() => null);
-
-    try {
-      const output = await this.pipeline(texts, { pooling: 'mean', normalize: true });
-      const list = output.tolist() as number[][];
-      return list.map(v => new Float32Array(v));
-    } catch (err) {
-      this.logger.error(`Batch embedding error: ${err}`);
-      return texts.map(() => null);
-    }
-  }
-
-  /** Compute and store embeddings for entries that don't have them yet */
-  async sweep(): Promise<{ errors: number; modules: number }> {
-    let errorsProcessed = 0;
-    let modulesProcessed = 0;
-
-    // Process errors without embeddings
-    const pendingErrors = this.db.prepare(
-      'SELECT id, type, message, context FROM errors WHERE embedding IS NULL ORDER BY id DESC LIMIT ?'
-    ).all(this.config.batchSize) as Array<{ id: number; type: string; message: string; context: string | null }>;
-
-    if (pendingErrors.length > 0) {
-      const texts = pendingErrors.map(e =>
-        [e.type, e.message, e.context].filter(Boolean).join(' ')
-      );
-      const embeddings = await this.embedBatch(texts);
-
-      const updateStmt = this.db.prepare('UPDATE errors SET embedding = ? WHERE id = ?');
-      for (let i = 0; i < pendingErrors.length; i++) {
-        const emb = embeddings[i];
-        if (emb) {
-          updateStmt.run(EmbeddingEngine.serialize(emb), pendingErrors[i]!.id);
-          errorsProcessed++;
-        }
-      }
-    }
-
-    // Process code modules without embeddings
-    const pendingModules = this.db.prepare(
-      'SELECT id, name, description, file_path FROM code_modules WHERE embedding IS NULL ORDER BY id DESC LIMIT ?'
-    ).all(this.config.batchSize) as Array<{ id: number; name: string; description: string | null; file_path: string }>;
-
-    if (pendingModules.length > 0) {
-      const texts = pendingModules.map(m =>
-        [m.name, m.description, m.file_path].filter(Boolean).join(' ')
-      );
-      const embeddings = await this.embedBatch(texts);
-
-      const updateStmt = this.db.prepare('UPDATE code_modules SET embedding = ? WHERE id = ?');
-      for (let i = 0; i < pendingModules.length; i++) {
-        const emb = embeddings[i];
-        if (emb) {
-          updateStmt.run(EmbeddingEngine.serialize(emb), pendingModules[i]!.id);
-          modulesProcessed++;
-        }
-      }
-    }
-
-    if (errorsProcessed > 0 || modulesProcessed > 0) {
-      this.logger.info(`Embedding sweep: ${errorsProcessed} errors, ${modulesProcessed} modules processed`);
-    }
-
-    return { errors: errorsProcessed, modules: modulesProcessed };
-  }
-
-  /** Load vector scores for error matching (sync - reads pre-computed embeddings from DB) */
-  computeErrorVectorScores(errorId: number, projectId: number): Map<number, number> {
-    const scores = new Map<number, number>();
-
-    const errorRow = this.db.prepare(
-      'SELECT embedding FROM errors WHERE id = ?'
-    ).get(errorId) as { embedding: Buffer | null } | undefined;
-
-    if (!errorRow?.embedding) return scores;
-
-    const incoming = EmbeddingEngine.deserialize(errorRow.embedding);
-
-    const candidates = this.db.prepare(
-      'SELECT id, embedding FROM errors WHERE project_id = ? AND id != ? AND embedding IS NOT NULL'
-    ).all(projectId, errorId) as Array<{ id: number; embedding: Buffer }>;
-
-    for (const c of candidates) {
-      const candidate = EmbeddingEngine.deserialize(c.embedding);
-      scores.set(c.id, EmbeddingEngine.similarity(incoming, candidate));
-    }
-
-    return scores;
-  }
-
-  /** Load vector scores for module-to-module matching (sync - reads pre-computed embeddings from DB) */
-  computeModuleVectorScores(moduleId: number, language?: string): Map<number, number> {
-    const scores = new Map<number, number>();
-
-    const moduleRow = this.db.prepare(
-      'SELECT embedding FROM code_modules WHERE id = ?'
-    ).get(moduleId) as { embedding: Buffer | null } | undefined;
-
-    if (!moduleRow?.embedding) return scores;
-
-    const incoming = EmbeddingEngine.deserialize(moduleRow.embedding);
-
-    let sql = 'SELECT id, embedding FROM code_modules WHERE id != ? AND embedding IS NOT NULL';
-    const params: unknown[] = [moduleId];
-    if (language) {
-      sql += ' AND language = ?';
-      params.push(language);
-    }
-
-    const candidates = this.db.prepare(sql).all(...params) as Array<{ id: number; embedding: Buffer }>;
-
-    for (const c of candidates) {
-      const candidate = EmbeddingEngine.deserialize(c.embedding);
-      scores.set(c.id, EmbeddingEngine.similarity(incoming, candidate));
-    }
-
-    return scores;
-  }
-
-  /** Serialize Float32Array to Buffer for SQLite BLOB storage */
-  static serialize(embedding: Float32Array): Buffer {
-    return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
-  }
-
-  /** Deserialize SQLite BLOB to Float32Array */
-  static deserialize(buffer: Buffer): Float32Array {
-    const copy = Buffer.from(buffer);
-    return new Float32Array(copy.buffer, copy.byteOffset, copy.length / 4);
-  }
-
-  /** Cosine similarity (embeddings are L2-normalized, so dot product = cosine) */
-  static similarity(a: Float32Array, b: Float32Array): number {
-    if (a.length !== b.length) return 0;
-    let dot = 0;
-    for (let i = 0; i < a.length; i++) {
-      dot += a[i]! * b[i]!;
-    }
-    return Math.max(0, Math.min(1, dot));
-  }
-}
+import path from 'node:path';
+import type Database from 'better-sqlite3';
+import { getLogger } from '../utils/logger.js';
+
+export interface EmbeddingConfig {
+  enabled: boolean;
+  modelName: string;
+  cacheDir: string;
+  sweepIntervalMs: number;
+  batchSize: number;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Pipeline = any;
+
+export class EmbeddingEngine {
+  private pipeline: Pipeline = null;
+  private ready = false;
+  private loading = false;
+  private logger = getLogger();
+  private sweepTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(
+    private config: EmbeddingConfig,
+    private db: Database.Database,
+  ) {}
+
+  async initialize(): Promise<void> {
+    if (!this.config.enabled || this.loading || this.ready) return;
+
+    this.loading = true;
+    try {
+      const { pipeline, env } = await import('@huggingface/transformers');
+      env.cacheDir = this.config.cacheDir;
+
+      this.pipeline = await pipeline(
+        'feature-extraction',
+        this.config.modelName,
+        { dtype: 'q8' },
+      );
+
+      this.ready = true;
+      this.logger.info(`Embedding model loaded: ${this.config.modelName}`);
+    } catch (err) {
+      this.logger.warn(`Failed to load embedding model (will retry): ${err}`);
+      this.ready = false;
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  /** Start background embedding sweep */
+  start(): void {
+    if (!this.config.enabled) return;
+
+    // Initialize model in background
+    this.initialize().then(() => {
+      if (this.ready) {
+        // Run initial sweep
+        this.sweep().catch(err => this.logger.error('Embedding sweep error:', err));
+      }
+    });
+
+    // Periodic sweep for new entries
+    this.sweepTimer = setInterval(() => {
+      if (this.ready) {
+        this.sweep().catch(err => this.logger.error('Embedding sweep error:', err));
+      }
+    }, this.config.sweepIntervalMs);
+  }
+
+  stop(): void {
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+  }
+
+  isReady(): boolean {
+    return this.ready;
+  }
+
+  /** Generate embedding for a single text */
+  async embed(text: string): Promise<Float32Array | null> {
+    if (!this.ready || !this.pipeline) return null;
+
+    try {
+      const output = await this.pipeline(text, { pooling: 'mean', normalize: true });
+      const data = output.tolist()[0] as number[];
+      return new Float32Array(data);
+    } catch (err) {
+      this.logger.error(`Embedding error: ${err}`);
+      return null;
+    }
+  }
+
+  /** Generate embeddings for a batch of texts */
+  async embedBatch(texts: string[]): Promise<(Float32Array | null)[]> {
+    if (!this.ready || !this.pipeline || texts.length === 0) return texts.map(() => null);
+
+    try {
+      const output = await this.pipeline(texts, { pooling: 'mean', normalize: true });
+      const list = output.tolist() as number[][];
+      return list.map(v => new Float32Array(v));
+    } catch (err) {
+      this.logger.error(`Batch embedding error: ${err}`);
+      return texts.map(() => null);
+    }
+  }
+
+  /** Compute and store embeddings for entries that don't have them yet */
+  async sweep(): Promise<{ errors: number; modules: number }> {
+    let errorsProcessed = 0;
+    let modulesProcessed = 0;
+
+    // Process errors without embeddings
+    const pendingErrors = this.db.prepare(
+      'SELECT id, type, message, context FROM errors WHERE embedding IS NULL ORDER BY id DESC LIMIT ?'
+    ).all(this.config.batchSize) as Array<{ id: number; type: string; message: string; context: string | null }>;
+
+    if (pendingErrors.length > 0) {
+      const texts = pendingErrors.map(e =>
+        [e.type, e.message, e.context].filter(Boolean).join(' ')
+      );
+      const embeddings = await this.embedBatch(texts);
+
+      const updateStmt = this.db.prepare('UPDATE errors SET embedding = ? WHERE id = ?');
+      for (let i = 0; i < pendingErrors.length; i++) {
+        const emb = embeddings[i];
+        if (emb) {
+          updateStmt.run(EmbeddingEngine.serialize(emb), pendingErrors[i]!.id);
+          errorsProcessed++;
+        }
+      }
+    }
+
+    // Process code modules without embeddings
+    const pendingModules = this.db.prepare(
+      'SELECT id, name, description, file_path FROM code_modules WHERE embedding IS NULL ORDER BY id DESC LIMIT ?'
+    ).all(this.config.batchSize) as Array<{ id: number; name: string; description: string | null; file_path: string }>;
+
+    if (pendingModules.length > 0) {
+      const texts = pendingModules.map(m =>
+        [m.name, m.description, m.file_path].filter(Boolean).join(' ')
+      );
+      const embeddings = await this.embedBatch(texts);
+
+      const updateStmt = this.db.prepare('UPDATE code_modules SET embedding = ? WHERE id = ?');
+      for (let i = 0; i < pendingModules.length; i++) {
+        const emb = embeddings[i];
+        if (emb) {
+          updateStmt.run(EmbeddingEngine.serialize(emb), pendingModules[i]!.id);
+          modulesProcessed++;
+        }
+      }
+    }
+
+    if (errorsProcessed > 0 || modulesProcessed > 0) {
+      this.logger.info(`Embedding sweep: ${errorsProcessed} errors, ${modulesProcessed} modules processed`);
+    }
+
+    return { errors: errorsProcessed, modules: modulesProcessed };
+  }
+
+  /** Load vector scores for error matching (sync - reads pre-computed embeddings from DB) */
+  computeErrorVectorScores(errorId: number, projectId: number): Map<number, number> {
+    const scores = new Map<number, number>();
+
+    const errorRow = this.db.prepare(
+      'SELECT embedding FROM errors WHERE id = ?'
+    ).get(errorId) as { embedding: Buffer | null } | undefined;
+
+    if (!errorRow?.embedding) return scores;
+
+    const incoming = EmbeddingEngine.deserialize(errorRow.embedding);
+
+    const candidates = this.db.prepare(
+      'SELECT id, embedding FROM errors WHERE project_id = ? AND id != ? AND embedding IS NOT NULL'
+    ).all(projectId, errorId) as Array<{ id: number; embedding: Buffer }>;
+
+    for (const c of candidates) {
+      const candidate = EmbeddingEngine.deserialize(c.embedding);
+      scores.set(c.id, EmbeddingEngine.similarity(incoming, candidate));
+    }
+
+    return scores;
+  }
+
+  /** Load vector scores for module-to-module matching (sync - reads pre-computed embeddings from DB) */
+  computeModuleVectorScores(moduleId: number, language?: string): Map<number, number> {
+    const scores = new Map<number, number>();
+
+    const moduleRow = this.db.prepare(
+      'SELECT embedding FROM code_modules WHERE id = ?'
+    ).get(moduleId) as { embedding: Buffer | null } | undefined;
+
+    if (!moduleRow?.embedding) return scores;
+
+    const incoming = EmbeddingEngine.deserialize(moduleRow.embedding);
+
+    let sql = 'SELECT id, embedding FROM code_modules WHERE id != ? AND embedding IS NOT NULL';
+    const params: unknown[] = [moduleId];
+    if (language) {
+      sql += ' AND language = ?';
+      params.push(language);
+    }
+
+    const candidates = this.db.prepare(sql).all(...params) as Array<{ id: number; embedding: Buffer }>;
+
+    for (const c of candidates) {
+      const candidate = EmbeddingEngine.deserialize(c.embedding);
+      scores.set(c.id, EmbeddingEngine.similarity(incoming, candidate));
+    }
+
+    return scores;
+  }
+
+  /** Serialize Float32Array to Buffer for SQLite BLOB storage */
+  static serialize(embedding: Float32Array): Buffer {
+    return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+  }
+
+  /** Deserialize SQLite BLOB to Float32Array */
+  static deserialize(buffer: Buffer): Float32Array {
+    const copy = Buffer.from(buffer);
+    return new Float32Array(copy.buffer, copy.byteOffset, copy.length / 4);
+  }
+
+  /** Cosine similarity (embeddings are L2-normalized, so dot product = cosine) */
+  static similarity(a: Float32Array, b: Float32Array): number {
+    if (a.length !== b.length) return 0;
+    let dot = 0;
+    for (let i = 0; i < a.length; i++) {
+      dot += a[i]! * b[i]!;
+    }
+    return Math.max(0, Math.min(1, dot));
+  }
+}

package/src/index.ts

@@ -1,63 +1,63 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { startCommand } from './cli/commands/start.js';
-import { stopCommand } from './cli/commands/stop.js';
-import { statusCommand } from './cli/commands/status.js';
-import { queryCommand } from './cli/commands/query.js';
-import { modulesCommand } from './cli/commands/modules.js';
-import { insightsCommand } from './cli/commands/insights.js';
-import { networkCommand } from './cli/commands/network.js';
-import { exportCommand } from './cli/commands/export.js';
-import { importCommand } from './cli/commands/import.js';
-import { dashboardCommand } from './cli/commands/dashboard.js';
-import { learnCommand } from './cli/commands/learn.js';
-import { configCommand } from './cli/commands/config.js';
-import { projectsCommand } from './cli/commands/projects.js';
-import { doctorCommand } from './cli/commands/doctor.js';
-import { explainCommand } from './cli/commands/explain.js';
-
-const program = new Command();
-
-program
-  .name('brain')
-  .description('Brain — Adaptive Error Memory & Code Intelligence System')
-  .version('1.8.1');
-
-program.addCommand(startCommand());
-program.addCommand(stopCommand());
-program.addCommand(statusCommand());
-program.addCommand(queryCommand());
-program.addCommand(modulesCommand());
-program.addCommand(insightsCommand());
-program.addCommand(networkCommand());
-program.addCommand(exportCommand());
-program.addCommand(importCommand());
-program.addCommand(dashboardCommand());
-program.addCommand(learnCommand());
-program.addCommand(configCommand());
-program.addCommand(projectsCommand());
-program.addCommand(doctorCommand());
-program.addCommand(explainCommand());
-
-// Hidden command: run MCP server (called by Claude Code)
-program
-  .command('mcp-server')
-  .description('Start MCP server (stdio transport, used by Claude Code)')
-  .action(async () => {
-    const { startMcpServer } = await import('./mcp/server.js');
-    await startMcpServer();
-  });
-
-// Hidden command: run daemon in foreground (called by start command)
-program
-  .command('daemon')
-  .description('Run daemon in foreground')
-  .option('-c, --config <path>', 'Config file path')
-  .action(async (opts) => {
-    const { BrainCore } = await import('./brain.js');
-    const core = new BrainCore();
-    core.start(opts.config);
-  });
-
-program.parse();
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { startCommand } from './cli/commands/start.js';
+import { stopCommand } from './cli/commands/stop.js';
+import { statusCommand } from './cli/commands/status.js';
+import { queryCommand } from './cli/commands/query.js';
+import { modulesCommand } from './cli/commands/modules.js';
+import { insightsCommand } from './cli/commands/insights.js';
+import { networkCommand } from './cli/commands/network.js';
+import { exportCommand } from './cli/commands/export.js';
+import { importCommand } from './cli/commands/import.js';
+import { dashboardCommand } from './cli/commands/dashboard.js';
+import { learnCommand } from './cli/commands/learn.js';
+import { configCommand } from './cli/commands/config.js';
+import { projectsCommand } from './cli/commands/projects.js';
+import { doctorCommand } from './cli/commands/doctor.js';
+import { explainCommand } from './cli/commands/explain.js';
+
+const program = new Command();
+
+program
+  .name('brain')
+  .description('Brain — Adaptive Error Memory & Code Intelligence System')
+  .version('1.8.1');
+
+program.addCommand(startCommand());
+program.addCommand(stopCommand());
+program.addCommand(statusCommand());
+program.addCommand(queryCommand());
+program.addCommand(modulesCommand());
+program.addCommand(insightsCommand());
+program.addCommand(networkCommand());
+program.addCommand(exportCommand());
+program.addCommand(importCommand());
+program.addCommand(dashboardCommand());
+program.addCommand(learnCommand());
+program.addCommand(configCommand());
+program.addCommand(projectsCommand());
+program.addCommand(doctorCommand());
+program.addCommand(explainCommand());
+
+// Hidden command: run MCP server (called by Claude Code)
+program
+  .command('mcp-server')
+  .description('Start MCP server (stdio transport, used by Claude Code)')
+  .action(async () => {
+    const { startMcpServer } = await import('./mcp/server.js');
+    await startMcpServer();
+  });
+
+// Hidden command: run daemon in foreground (called by start command)
+program
+  .command('daemon')
+  .description('Run daemon in foreground')
+  .option('-c, --config <path>', 'Config file path')
+  .action(async (opts) => {
+    const { BrainCore } = await import('./brain.js');
+    const core = new BrainCore();
+    core.start(opts.config);
+  });
+
+program.parse();