@timmeck/brain 1.9.0 → 2.0.0

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();

package/src/ipc/client.ts

@@ -1,118 +0,0 @@
-import net from 'node:net';
-import { randomUUID } from 'node:crypto';
-import type { IpcMessage } from '../types/ipc.types.js';
-import { encodeMessage, MessageDecoder } from './protocol.js';
-import { getPipeName } from '../utils/paths.js';
-
-interface PendingRequest {
-  resolve: (result: unknown) => void;
-  reject: (err: Error) => void;
-  timer: ReturnType<typeof setTimeout>;
-}
-
-export class IpcClient {
-  private socket: net.Socket | null = null;
-  private decoder = new MessageDecoder();
-  private pending = new Map<string, PendingRequest>();
-  private onNotification?: (msg: IpcMessage) => void;
-
-  constructor(
-    private pipeName: string = getPipeName(),
-    private timeout: number = 5000,
-  ) {}
-
-  connect(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      this.socket = net.createConnection(this.pipeName, () => {
-        resolve();
-      });
-
-      this.socket.on('data', (chunk) => {
-        const messages = this.decoder.feed(chunk);
-        for (const msg of messages) {
-          this.handleMessage(msg);
-        }
-      });
-
-      this.socket.on('error', (err) => {
-        reject(err);
-        // Reject all pending requests
-        for (const [id, req] of this.pending) {
-          clearTimeout(req.timer);
-          req.reject(new Error(`Connection error: ${err.message}`));
-          this.pending.delete(id);
-        }
-      });
-
-      this.socket.on('close', () => {
-        for (const [id, req] of this.pending) {
-          clearTimeout(req.timer);
-          req.reject(new Error('Connection closed'));
-          this.pending.delete(id);
-        }
-        this.socket = null;
-      });
-    });
-  }
-
-  request(method: string, params?: unknown): Promise<unknown> {
-    return new Promise((resolve, reject) => {
-      if (!this.socket || this.socket.destroyed) {
-        return reject(new Error('Not connected'));
-      }
-
-      const id = randomUUID();
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error(`Request timeout: ${method} (${this.timeout}ms)`));
-      }, this.timeout);
-
-      this.pending.set(id, { resolve, reject, timer });
-
-      const msg: IpcMessage = {
-        id,
-        type: 'request',
-        method,
-        params,
-      };
-      this.socket.write(encodeMessage(msg));
-    });
-  }
-
-  setNotificationHandler(handler: (msg: IpcMessage) => void): void {
-    this.onNotification = handler;
-  }
-
-  disconnect(): void {
-    for (const [id, req] of this.pending) {
-      clearTimeout(req.timer);
-      req.reject(new Error('Client disconnecting'));
-      this.pending.delete(id);
-    }
-    this.socket?.destroy();
-    this.socket = null;
-    this.decoder.reset();
-  }
-
-  get connected(): boolean {
-    return this.socket !== null && !this.socket.destroyed;
-  }
-
-  private handleMessage(msg: IpcMessage): void {
-    if (msg.type === 'response') {
-      const req = this.pending.get(msg.id);
-      if (!req) return;
-
-      clearTimeout(req.timer);
-      this.pending.delete(msg.id);
-
-      if (msg.error) {
-        req.reject(new Error(msg.error.message));
-      } else {
-        req.resolve(msg.result);
-      }
-    } else if (msg.type === 'notification') {
-      this.onNotification?.(msg);
-    }
-  }
-}

package/src/ipc/protocol.ts

@@ -1,35 +0,0 @@
-import { Buffer } from 'node:buffer';
-import type { IpcMessage } from '../types/ipc.types.js';
-
-export function encodeMessage(msg: IpcMessage): Buffer {
-  const json = JSON.stringify(msg);
-  const payload = Buffer.from(json, 'utf8');
-  const frame = Buffer.alloc(4 + payload.length);
-  frame.writeUInt32BE(payload.length, 0);
-  payload.copy(frame, 4);
-  return frame;
-}
-
-export class MessageDecoder {
-  private buffer = Buffer.alloc(0);
-
-  feed(chunk: Buffer): IpcMessage[] {
-    this.buffer = Buffer.concat([this.buffer, chunk]);
-    const messages: IpcMessage[] = [];
-
-    while (this.buffer.length >= 4) {
-      const length = this.buffer.readUInt32BE(0);
-      if (this.buffer.length < 4 + length) break;
-
-      const json = this.buffer.subarray(4, 4 + length).toString('utf8');
-      this.buffer = this.buffer.subarray(4 + length);
-      messages.push(JSON.parse(json) as IpcMessage);
-    }
-
-    return messages;
-  }
-
-  reset(): void {
-    this.buffer = Buffer.alloc(0);
-  }
-}