@timmeck/brain 1.8.5 → 2.0.0

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

@@ -1,101 +0,0 @@
-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,238 +0,0 @@
-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/hooks/post-tool-use.ts

@@ -1,92 +0,0 @@
-#!/usr/bin/env node
-
-// PostToolUse hook for Bash tool — auto-detects errors and reports to Brain
-// Configured in .claude/settings.json:
-// { "hooks": { "PostToolUse": [{ "matcher": { "tool_name": "Bash" }, "command": "node <brain-dist>/hooks/post-tool-use.js" }] } }
-
-import { IpcClient } from '../ipc/client.js';
-import { getPipeName } from '../utils/paths.js';
-
-interface HookInput {
-  tool_name: string;
-  tool_input: { command?: string };
-  tool_output: string;
-  exit_code?: number;
-}
-
-const ERROR_PATTERNS = [
-  /Error:/i,
-  /error\[E\d+\]/,
-  /Traceback \(most recent call last\)/,
-  /FATAL|PANIC/i,
-  /npm ERR!/,
-  /SyntaxError|TypeError|ReferenceError|RangeError/,
-  /ENOENT|EACCES|ECONNREFUSED|ETIMEDOUT/,
-  /ModuleNotFoundError|ImportError/,
-  /failed to compile/i,
-  /BUILD FAILED/i,
-  /Cannot find module/,
-  /command not found/,
-  /Permission denied/,
-];
-
-function isError(input: HookInput): boolean {
-  if (input.exit_code !== undefined && input.exit_code !== 0) return true;
-  return ERROR_PATTERNS.some(p => p.test(input.tool_output));
-}
-
-function readStdin(): Promise<string> {
-  return new Promise((resolve) => {
-    let data = '';
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => resolve(data));
-  });
-}
-
-async function main(): Promise<void> {
-  const raw = await readStdin();
-  if (!raw.trim()) return;
-
-  let input: HookInput;
-  try {
-    input = JSON.parse(raw);
-  } catch {
-    return;
-  }
-
-  if (!isError(input)) return;
-
-  const client = new IpcClient(getPipeName(), 3000);
-  try {
-    await client.connect();
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const result: any = await client.request('error.report', {
-      project: 'auto-detected',
-      errorOutput: input.tool_output,
-      command: input.tool_input?.command,
-      workingDirectory: process.cwd(),
-    });
-
-    if (result.matches?.length > 0) {
-      const best = result.matches[0];
-      process.stderr.write(`Brain: Similar error found (#${best.errorId}, ${Math.round(best.score * 100)}% match)\n`);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const antipatterns: any = await client.request('prevention.antipatterns', {
-      errorType: '',
-      message: input.tool_output,
-    });
-    if (antipatterns?.length > 0 && antipatterns[0].matched) {
-      process.stderr.write(`Brain WARNING: Known anti-pattern: ${antipatterns[0].description}\n`);
-    }
-  } catch {
-    // Hook must never block workflow
-  } finally {
-    client.disconnect();
-  }
-}
-
-main();

package/src/hooks/post-write.ts

@@ -1,129 +0,0 @@
-#!/usr/bin/env node
-
-// PostToolUse hook for Write/Edit tool — auto-analyzes code for reusability
-// Configured in .claude/settings.json:
-// { "hooks": { "PostToolUse": [{ "matcher": { "tool_name": "Write" }, "command": "node <brain-dist>/hooks/post-write.js" }] } }
-
-import { IpcClient } from '../ipc/client.js';
-import { getPipeName } from '../utils/paths.js';
-
-interface HookInput {
-  tool_name: string;
-  tool_input: { file_path?: string; content?: string };
-  tool_output: string;
-}
-
-const SOURCE_EXTENSIONS = new Set([
-  '.ts', '.tsx', '.js', '.jsx', '.py', '.rs', '.go',
-  '.java', '.c', '.cpp', '.h', '.hpp', '.rb', '.sh',
-]);
-
-const IGNORE_PATHS = [
-  'node_modules', 'dist', '.git', '__pycache__',
-  'vendor', 'build', '.next', 'coverage',
-];
-
-function isSourceFile(filePath: string): boolean {
-  const ext = filePath.slice(filePath.lastIndexOf('.'));
-  if (!SOURCE_EXTENSIONS.has(ext)) return false;
-  return !IGNORE_PATHS.some(p => filePath.includes(p));
-}
-
-function detectProject(filePath: string): string {
-  const normalized = filePath.replace(/\\/g, '/');
-  // Extract project name from path — look for common project root indicators
-  const parts = normalized.split('/');
-  // Find the directory just above src/, lib/, app/ etc., or use the parent of the file
-  for (let i = parts.length - 1; i >= 0; i--) {
-    if (['src', 'lib', 'app', 'components', 'pages', 'tests', 'test'].includes(parts[i]) && i > 0) {
-      return parts[i - 1];
-    }
-  }
-  // Fallback: use the directory two levels up from the file, or immediate parent
-  return parts[Math.max(parts.length - 3, 0)] || 'default';
-}
-
-function detectLanguage(filePath: string): string {
-  const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
-  const map: Record<string, string> = {
-    ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
-    py: 'python', rs: 'rust', go: 'go', java: 'java',
-    c: 'c', cpp: 'cpp', h: 'c', hpp: 'cpp',
-    rb: 'ruby', sh: 'shell',
-  };
-  return map[ext] ?? ext;
-}
-
-function readStdin(): Promise<string> {
-  return new Promise((resolve) => {
-    let data = '';
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (chunk) => { data += chunk; });
-    process.stdin.on('end', () => resolve(data));
-  });
-}
-
-async function main(): Promise<void> {
-  const raw = await readStdin();
-  if (!raw.trim()) return;
-
-  let input: HookInput;
-  try {
-    input = JSON.parse(raw);
-  } catch {
-    return;
-  }
-
-  const filePath = input.tool_input?.file_path;
-  if (!filePath || !isSourceFile(filePath)) return;
-
-  const client = new IpcClient(getPipeName(), 3000);
-  try {
-    await client.connect();
-
-    // Check for similar existing code
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const similarities: any = await client.request('code.similarity', {
-      source: input.tool_input.content ?? '',
-      language: detectLanguage(filePath),
-    });
-
-    if (similarities?.length > 0) {
-      const best = similarities[0];
-      if (best.score > 0.8) {
-        process.stderr.write(`Brain: Very similar code exists (module #${best.moduleId}, ${Math.round(best.score * 100)}% match). Consider reusing.\n`);
-      }
-    }
-
-    // Proactive Prevention: check if written code matches error-causing patterns
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const prevention: any = await client.request('prevention.checkCode', {
-      source: input.tool_input.content ?? '',
-      filePath,
-    });
-    if (prevention?.warnings?.length > 0) {
-      for (const warning of prevention.warnings.slice(0, 3)) {
-        process.stderr.write(`Brain WARNING: ${warning.message}\n`);
-      }
-    }
-
-    // Auto-register the written file into Brain
-    const fileName = filePath.replace(/\\/g, '/').split('/').pop() ?? 'unknown';
-    const projectName = detectProject(filePath);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const result: any = await client.request('code.analyze', {
-      project: projectName,
-      name: fileName,
-      filePath,
-      language: detectLanguage(filePath),
-      source: input.tool_input.content ?? '',
-    });
-    process.stderr.write(`Brain: Registered ${fileName} (score: ${result.reusabilityScore?.toFixed(2) ?? '?'}, ${result.isNew ? 'new' : 'updated'})\n`);
-  } catch {
-    // Hook must never block workflow
-  } finally {
-    client.disconnect();
-  }
-}
-
-main();

package/src/index.ts

@@ -1,63 +0,0 @@
-#!/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();