@timmeck/brain 1.0.0

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

@@ -0,0 +1,153 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { SynapseRecord } from '../../types/synapse.types.js';
+
+type SynapseCreate = Omit<SynapseRecord, 'id' | 'activation_count' | 'last_activated_at' | 'created_at' | 'updated_at'>;
+type SynapseUpdate = Partial<Omit<SynapseRecord, 'id' | 'created_at'>>;
+
+export class SynapseRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO synapses (source_type, source_id, target_type, target_id, synapse_type, weight, metadata)
+        VALUES (@source_type, @source_id, @target_type, @target_id, @synapse_type, @weight, @metadata)
+      `),
+      getById: db.prepare('SELECT * FROM synapses WHERE id = ?'),
+      delete: db.prepare('DELETE FROM synapses WHERE id = ?'),
+      getOutgoing: db.prepare(
+        'SELECT * FROM synapses WHERE source_type = ? AND source_id = ? ORDER BY weight DESC'
+      ),
+      getIncoming: db.prepare(
+        'SELECT * FROM synapses WHERE target_type = ? AND target_id = ? ORDER BY weight DESC'
+      ),
+      findConnected: db.prepare(`
+        SELECT * FROM synapses
+        WHERE (source_type = ? AND source_id = ?) OR (target_type = ? AND target_id = ?)
+        ORDER BY weight DESC
+      `),
+      findBySourceTarget: db.prepare(`
+        SELECT * FROM synapses
+        WHERE source_type = ? AND source_id = ? AND target_type = ? AND target_id = ? AND synapse_type = ?
+      `),
+      findInactiveSince: db.prepare(`
+        SELECT * FROM synapses WHERE last_activated_at < ?
+      `),
+      countNodes: db.prepare(`
+        SELECT COUNT(*) as count FROM (
+          SELECT source_type, source_id FROM synapses
+          UNION
+          SELECT target_type, target_id FROM synapses
+        )
+      `),
+      avgWeight: db.prepare('SELECT AVG(weight) as avg_weight FROM synapses'),
+      countByType: db.prepare('SELECT synapse_type, COUNT(*) as count FROM synapses GROUP BY synapse_type'),
+      totalCount: db.prepare('SELECT COUNT(*) as count FROM synapses'),
+      topByWeight: db.prepare('SELECT * FROM synapses ORDER BY weight DESC LIMIT ?'),
+    };
+  }
+
+  create(data: SynapseCreate): number {
+    const result = this.stmts.create.run({
+      source_type: data.source_type,
+      source_id: data.source_id,
+      target_type: data.target_type,
+      target_id: data.target_id,
+      synapse_type: data.synapse_type,
+      weight: data.weight,
+      metadata: data.metadata ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): SynapseRecord | undefined {
+    return this.stmts.getById.get(id) as SynapseRecord | undefined;
+  }
+
+  update(id: number, data: SynapseUpdate): boolean {
+    const fields = Object.keys(data).filter(
+      (key) => (data as Record<string, unknown>)[key] !== undefined
+    );
+    if (fields.length === 0) return false;
+
+    const setClauses = fields.map((field) => `${field} = @${field}`).join(', ');
+    const stmt = this.db.prepare(
+      `UPDATE synapses SET ${setClauses}, updated_at = datetime('now') WHERE id = @id`
+    );
+    const result = stmt.run({ ...data, id });
+    return result.changes > 0;
+  }
+
+  delete(id: number): boolean {
+    const result = this.stmts.delete.run(id);
+    return result.changes > 0;
+  }
+
+  getOutgoing(sourceType: string, sourceId: number): SynapseRecord[] {
+    return this.stmts.getOutgoing.all(sourceType, sourceId) as SynapseRecord[];
+  }
+
+  getIncoming(targetType: string, targetId: number): SynapseRecord[] {
+    return this.stmts.getIncoming.all(targetType, targetId) as SynapseRecord[];
+  }
+
+  findBySourceTarget(
+    sourceType: string,
+    sourceId: number,
+    targetType: string,
+    targetId: number,
+    synapseType: string,
+  ): SynapseRecord | undefined {
+    return this.stmts.findBySourceTarget.get(
+      sourceType, sourceId, targetType, targetId, synapseType
+    ) as SynapseRecord | undefined;
+  }
+
+  findByWeight(minWeight: number, maxWeight?: number): SynapseRecord[] {
+    if (maxWeight !== undefined) {
+      const stmt = this.db.prepare(
+        'SELECT * FROM synapses WHERE weight >= ? AND weight <= ? ORDER BY weight DESC'
+      );
+      return stmt.all(minWeight, maxWeight) as SynapseRecord[];
+    }
+    const stmt = this.db.prepare('SELECT * FROM synapses WHERE weight >= ? ORDER BY weight DESC');
+    return stmt.all(minWeight) as SynapseRecord[];
+  }
+
+  findConnected(nodeType: string, nodeId: number): SynapseRecord[] {
+    return this.stmts.findConnected.all(nodeType, nodeId, nodeType, nodeId) as SynapseRecord[];
+  }
+
+  findInactiveSince(cutoff: string): SynapseRecord[] {
+    return this.stmts.findInactiveSince.all(cutoff) as SynapseRecord[];
+  }
+
+  topByWeight(limit: number): SynapseRecord[] {
+    return this.stmts.topByWeight.all(limit) as SynapseRecord[];
+  }
+
+  countNodes(): number {
+    const row = this.stmts.countNodes.get() as { count: number };
+    return row.count;
+  }
+
+  totalCount(): number {
+    const row = this.stmts.totalCount.get() as { count: number };
+    return row.count;
+  }
+
+  avgWeight(): number {
+    const row = this.stmts.avgWeight.get() as { avg_weight: number | null };
+    return row.avg_weight ?? 0;
+  }
+
+  countByType(): Record<string, number> {
+    const rows = this.stmts.countByType.all() as Array<{ synapse_type: string; count: number }>;
+    const result: Record<string, number> = {};
+    for (const row of rows) {
+      result[row.synapse_type] = row.count;
+    }
+    return result;
+  }
+}

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

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

package/src/hooks/post-tool-use.ts

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

@@ -0,0 +1,117 @@
+#!/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`);
+      }
+    }
+
+    // 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

@@ -0,0 +1,53 @@
+#!/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';
+
+const program = new Command();
+
+program
+  .name('brain')
+  .description('Brain — Adaptive Error Memory & Code Intelligence System')
+  .version('1.0.0');
+
+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());
+
+// 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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,35 @@
+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);
+  }
+}