@timmeck/brain 1.8.0 → 1.8.2

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

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

package/src/embeddings/engine.ts

@@ -1,217 +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 code module matching (sync) */
-  computeModuleVectorScores(query: string, language?: string): Map<number, number> {
-    const scores = new Map<number, number>();
-    // This needs async embedding — use cached if available
-    // For now, return empty (vector search for modules is done during sweep)
-    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));
+  }
+}