@timmeck/brain 1.0.0

package/src/code/fingerprint.ts

@@ -0,0 +1,87 @@
+import { sha256 } from '../utils/hash.js';
+
+export function fingerprintCode(source: string, language: string): string {
+  let normalized = stripComments(source, language);
+  normalized = normalized.replace(/\s+/g, ' ').trim();
+  normalized = normalizeIdentifiers(normalized, language);
+  normalized = normalized.replace(/'[^']*'/g, "'<STR>'");
+  normalized = normalized.replace(/"[^"]*"/g, '"<STR>"');
+  normalized = normalized.replace(/`[^`]*`/g, '`<STR>`');
+  normalized = normalized.replace(/\b\d+\b/g, '<NUM>');
+  return sha256(normalized);
+}
+
+export function stripComments(source: string, language: string): string {
+  switch (language) {
+    case 'typescript':
+    case 'javascript':
+    case 'java':
+    case 'go':
+    case 'rust':
+    case 'c':
+    case 'cpp':
+      return source
+        .replace(/\/\/.*$/gm, '')
+        .replace(/\/\*[\s\S]*?\*\//g, '');
+    case 'python':
+      return source
+        .replace(/#.*$/gm, '')
+        .replace(/"""[\s\S]*?"""/g, '')
+        .replace(/'''[\s\S]*?'''/g, '');
+    default:
+      return source
+        .replace(/\/\/.*$/gm, '')
+        .replace(/#.*$/gm, '');
+  }
+}
+
+function normalizeIdentifiers(source: string, language: string): string {
+  const importNames = extractImportNames(source, language);
+  const keywords = getLanguageKeywords(language);
+  const preserve = new Set([...importNames, ...keywords]);
+
+  return source.replace(/\b[a-zA-Z_]\w*\b/g, (match) => {
+    if (preserve.has(match)) return match;
+    if (match[0] === match[0]!.toUpperCase() && match[0] !== match[0]!.toLowerCase()) return '<CLASS>';
+    return '<VAR>';
+  });
+}
+
+function extractImportNames(source: string, language: string): string[] {
+  const names: string[] = [];
+
+  if (language === 'typescript' || language === 'javascript') {
+    const re = /import\s+(?:\{([^}]+)\}|\*\s+as\s+(\w+)|(\w+))/g;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(source)) !== null) {
+      if (m[1]) names.push(...m[1].split(',').map(s => s.trim().split(/\s+as\s+/).pop()!));
+      if (m[2]) names.push(m[2]);
+      if (m[3]) names.push(m[3]);
+    }
+  } else if (language === 'python') {
+    const re = /(?:from\s+\S+\s+)?import\s+(.+)/g;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(source)) !== null) {
+      names.push(...m[1]!.split(',').map(s => {
+        const parts = s.trim().split(/\s+as\s+/);
+        return parts[parts.length - 1]!;
+      }));
+    }
+  }
+
+  return names.filter(Boolean);
+}
+
+function getLanguageKeywords(language: string): string[] {
+  const common = ['if', 'else', 'for', 'while', 'return', 'break', 'continue', 'switch', 'case', 'default', 'try', 'catch', 'throw', 'new', 'delete', 'true', 'false', 'null', 'undefined', 'void'];
+
+  const langKeywords: Record<string, string[]> = {
+    typescript: [...common, 'const', 'let', 'var', 'function', 'class', 'interface', 'type', 'enum', 'import', 'export', 'from', 'async', 'await', 'extends', 'implements', 'readonly', 'private', 'public', 'protected', 'static', 'abstract', 'as', 'is', 'in', 'of', 'typeof', 'keyof', 'infer', 'never', 'unknown', 'any', 'string', 'number', 'boolean', 'symbol', 'object'],
+    javascript: [...common, 'const', 'let', 'var', 'function', 'class', 'import', 'export', 'from', 'async', 'await', 'extends', 'typeof', 'instanceof', 'in', 'of', 'this', 'super', 'yield'],
+    python: ['def', 'class', 'import', 'from', 'if', 'elif', 'else', 'for', 'while', 'return', 'yield', 'break', 'continue', 'try', 'except', 'finally', 'raise', 'with', 'as', 'pass', 'lambda', 'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'global', 'nonlocal', 'assert', 'async', 'await', 'self'],
+    rust: [...common, 'fn', 'let', 'mut', 'pub', 'struct', 'enum', 'impl', 'trait', 'use', 'mod', 'crate', 'self', 'super', 'match', 'loop', 'move', 'ref', 'where', 'async', 'await', 'dyn', 'Box', 'Vec', 'String', 'Option', 'Result', 'Some', 'None', 'Ok', 'Err'],
+    go: [...common, 'func', 'package', 'import', 'type', 'struct', 'interface', 'map', 'chan', 'go', 'defer', 'select', 'range', 'var', 'const', 'nil', 'make', 'len', 'append', 'cap', 'copy', 'close'],
+  };
+
+  return langKeywords[language] ?? common;
+}

package/src/code/matcher.ts

@@ -0,0 +1,64 @@
+import type { CodeModuleRecord } from '../types/code.types.js';
+import { fingerprintCode } from './fingerprint.js';
+import { tokenize } from '../matching/tokenizer.js';
+import { cosineSimilarity, jaccardSimilarity } from '../matching/similarity.js';
+
+export interface CodeMatchResult {
+  moduleId: number;
+  score: number;
+  matchType: 'exact' | 'structural' | 'semantic';
+}
+
+export function findExactMatches(
+  fingerprint: string,
+  candidates: CodeModuleRecord[],
+): CodeMatchResult[] {
+  return candidates
+    .filter(c => c.fingerprint === fingerprint)
+    .map(c => ({ moduleId: c.id, score: 1.0, matchType: 'exact' as const }));
+}
+
+export function findStructuralMatches(
+  source: string,
+  language: string,
+  candidates: CodeModuleRecord[],
+  threshold: number = 0.75,
+): CodeMatchResult[] {
+  const fp = fingerprintCode(source, language);
+  const results: CodeMatchResult[] = [];
+
+  for (const candidate of candidates) {
+    if (candidate.fingerprint === fp) {
+      results.push({ moduleId: candidate.id, score: 1.0, matchType: 'structural' });
+      continue;
+    }
+
+    const tokensA = tokenize(source);
+    const tokensB = tokenize(candidate.name + ' ' + (candidate.description ?? ''));
+    const sim = cosineSimilarity(tokensA, tokensB);
+    if (sim >= threshold) {
+      results.push({ moduleId: candidate.id, score: sim, matchType: 'structural' });
+    }
+  }
+
+  return results.sort((a, b) => b.score - a.score);
+}
+
+export function findSemanticMatches(
+  description: string,
+  candidates: CodeModuleRecord[],
+  threshold: number = 0.5,
+): CodeMatchResult[] {
+  const queryTokens = tokenize(description);
+
+  return candidates
+    .map(c => {
+      const candidateTokens = tokenize(
+        [c.name, c.description ?? '', c.file_path].join(' ')
+      );
+      const score = cosineSimilarity(queryTokens, candidateTokens);
+      return { moduleId: c.id, score, matchType: 'semantic' as const };
+    })
+    .filter(r => r.score >= threshold)
+    .sort((a, b) => b.score - a.score);
+}

package/src/code/parsers/generic.ts

@@ -0,0 +1,29 @@
+import type { ExportInfo } from '../../types/code.types.js';
+
+const FUNC_RE = /(?:function|func|fn|def|sub)\s+(\w+)/g;
+const CLASS_RE = /(?:class|struct|type)\s+(\w+)/g;
+
+export function extractExports(source: string): ExportInfo[] {
+  const exports: ExportInfo[] = [];
+  let match: RegExpExecArray | null;
+
+  const funcRe = new RegExp(FUNC_RE.source, 'g');
+  while ((match = funcRe.exec(source)) !== null) {
+    exports.push({ name: match[1]!, type: 'function' });
+  }
+
+  const classRe = new RegExp(CLASS_RE.source, 'g');
+  while ((match = classRe.exec(source)) !== null) {
+    exports.push({ name: match[1]!, type: 'class' });
+  }
+
+  return exports;
+}
+
+export function extractImports(_source: string): { external: string[]; internal: string[] } {
+  return { external: [], internal: [] };
+}
+
+export function hasTypeAnnotations(_source: string): boolean {
+  return false;
+}

package/src/code/parsers/python.ts

@@ -0,0 +1,54 @@
+import type { ExportInfo } from '../../types/code.types.js';
+
+const FUNC_DEF_RE = /^def\s+(\w+)\s*\(/gm;
+const CLASS_DEF_RE = /^class\s+(\w+)/gm;
+const IMPORT_RE = /^(?:from\s+(\S+)\s+)?import\s+(.+)/gm;
+const TOP_LEVEL_ASSIGN_RE = /^([A-Z_][A-Z_\d]*)\s*=/gm;
+
+export function extractExports(source: string): ExportInfo[] {
+  const exports: ExportInfo[] = [];
+  let match: RegExpExecArray | null;
+
+  const funcRe = new RegExp(FUNC_DEF_RE.source, 'gm');
+  while ((match = funcRe.exec(source)) !== null) {
+    if (!match[1]!.startsWith('_')) {
+      exports.push({ name: match[1]!, type: 'function' });
+    }
+  }
+
+  const classRe = new RegExp(CLASS_DEF_RE.source, 'gm');
+  while ((match = classRe.exec(source)) !== null) {
+    if (!match[1]!.startsWith('_')) {
+      exports.push({ name: match[1]!, type: 'class' });
+    }
+  }
+
+  const constRe = new RegExp(TOP_LEVEL_ASSIGN_RE.source, 'gm');
+  while ((match = constRe.exec(source)) !== null) {
+    exports.push({ name: match[1]!, type: 'constant' });
+  }
+
+  return exports;
+}
+
+export function extractImports(source: string): { external: string[]; internal: string[] } {
+  const external: string[] = [];
+  const internal: string[] = [];
+  let match: RegExpExecArray | null;
+
+  const importRe = new RegExp(IMPORT_RE.source, 'gm');
+  while ((match = importRe.exec(source)) !== null) {
+    const module = match[1] ?? match[2]!.trim().split(/\s*,\s*/)[0]!;
+    if (module.startsWith('.')) {
+      internal.push(module);
+    } else {
+      external.push(module);
+    }
+  }
+
+  return { external, internal };
+}
+
+export function hasTypeAnnotations(source: string): boolean {
+  return /:\s*\w+/.test(source) && /->/.test(source);
+}

package/src/code/parsers/typescript.ts

@@ -0,0 +1,65 @@
+import type { ExportInfo } from '../../types/code.types.js';
+
+const NAMED_EXPORT_RE = /export\s+(?:async\s+)?(?:function|const|let|var|class|interface|type|enum)\s+(\w+)/g;
+const DEFAULT_EXPORT_RE = /export\s+default\s+(?:(?:async\s+)?(?:function|class)\s+)?(\w+)?/g;
+const IMPORT_RE = /import\s+(?:(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+|\w+))*\s+from\s+)?['"]([^'"]+)['"]/g;
+
+export function extractExports(source: string): ExportInfo[] {
+  const exports: ExportInfo[] = [];
+  let match: RegExpExecArray | null;
+
+  const namedRe = new RegExp(NAMED_EXPORT_RE.source, 'g');
+  while ((match = namedRe.exec(source)) !== null) {
+    const line = source.substring(
+      source.lastIndexOf('\n', match.index) + 1,
+      source.indexOf('\n', match.index),
+    );
+    exports.push({
+      name: match[1]!,
+      type: detectExportType(line),
+    });
+  }
+
+  const defaultRe = new RegExp(DEFAULT_EXPORT_RE.source, 'g');
+  while ((match = defaultRe.exec(source)) !== null) {
+    exports.push({
+      name: match[1] ?? 'default',
+      type: 'function',
+    });
+  }
+
+  return exports;
+}
+
+export function extractImports(source: string): { external: string[]; internal: string[] } {
+  const external: string[] = [];
+  const internal: string[] = [];
+  let match: RegExpExecArray | null;
+
+  const importRe = new RegExp(IMPORT_RE.source, 'g');
+  while ((match = importRe.exec(source)) !== null) {
+    const specifier = match[1]!;
+    if (specifier.startsWith('.') || specifier.startsWith('/')) {
+      internal.push(specifier);
+    } else {
+      external.push(specifier);
+    }
+  }
+
+  return { external, internal };
+}
+
+export function hasTypeAnnotations(source: string): boolean {
+  return /:\s*\w+[\[\]<>|&]*\s*[=;,)\n{]/.test(source) ||
+    /interface\s+\w+/.test(source) ||
+    /type\s+\w+\s*=/.test(source);
+}
+
+function detectExportType(line: string): ExportInfo['type'] {
+  if (/\bfunction\b/.test(line)) return 'function';
+  if (/\bclass\b/.test(line)) return 'class';
+  if (/\binterface\b/.test(line)) return 'interface';
+  if (/\btype\b/.test(line)) return 'type';
+  if (/\bconst\b/.test(line)) return 'constant';
+  return 'variable';
+}

package/src/code/registry.ts

@@ -0,0 +1,60 @@
+import type { ExportInfo } from '../types/code.types.js';
+import { analyzeCode, measureCohesion } from './analyzer.js';
+
+export type ModuleType = 'file' | 'class' | 'function';
+
+export function detectGranularity(
+  source: string,
+  language: string,
+): ModuleType {
+  const { exports } = analyzeCode(source, language);
+
+  const hasDefault = exports.some(e => e.name === 'default');
+  if (hasDefault && exports.length <= 3) return 'file';
+
+  const classes = exports.filter(e => e.type === 'class');
+  if (classes.length === 1 && exports.length <= 3) return 'class';
+
+  if (exports.length > 3) {
+    const cohesion = measureCohesion(exports);
+    if (cohesion < 0.5) return 'function';
+  }
+
+  return 'file';
+}
+
+export interface ModuleRegistration {
+  name: string;
+  filePath: string;
+  language: string;
+  source: string;
+  description?: string;
+  projectId: number;
+}
+
+export interface RegisteredModule {
+  name: string;
+  moduleType: ModuleType;
+  exports: ExportInfo[];
+  externalDeps: string[];
+  internalDeps: string[];
+  isPure: boolean;
+  hasTypeAnnotations: boolean;
+  linesOfCode: number;
+}
+
+export function prepareModule(reg: ModuleRegistration): RegisteredModule {
+  const analysis = analyzeCode(reg.source, reg.language);
+  const moduleType = detectGranularity(reg.source, reg.language);
+
+  return {
+    name: reg.name,
+    moduleType,
+    exports: analysis.exports,
+    externalDeps: analysis.externalDeps,
+    internalDeps: analysis.internalDeps,
+    isPure: analysis.isPure,
+    hasTypeAnnotations: analysis.hasTypeAnnotations,
+    linesOfCode: analysis.linesOfCode,
+  };
+}

package/src/code/scorer.ts

@@ -0,0 +1,108 @@
+import type { ExportInfo } from '../types/code.types.js';
+
+export interface CodeUnitForScoring {
+  source: string;
+  filePath: string;
+  exports: ExportInfo[];
+  internalDeps: string[];
+  hasTypeAnnotations: boolean;
+}
+
+interface ReusabilitySignal {
+  name: string;
+  weight: number;
+  check: (code: CodeUnitForScoring) => number;
+}
+
+const REUSABILITY_SIGNALS: ReusabilitySignal[] = [
+  {
+    name: 'single_responsibility',
+    weight: 0.25,
+    check: (code) => {
+      const count = code.exports.length;
+      if (count === 0) return 0;
+      if (count <= 3) return 1.0;
+      if (count <= 6) return 0.6;
+      return 0.3;
+    },
+  },
+  {
+    name: 'pure_function',
+    weight: 0.20,
+    check: (code) => {
+      const sideEffects = [
+        'fs.', 'process.', 'console.', 'fetch(',
+        'XMLHttpRequest', 'document.', 'window.',
+        'global.', 'require(',
+      ];
+      const found = sideEffects.filter(se => code.source.includes(se));
+      return found.length === 0 ? 1.0 : Math.max(0, 1 - found.length * 0.3);
+    },
+  },
+  {
+    name: 'clear_interface',
+    weight: 0.20,
+    check: (code) => {
+      let score = 0.5;
+      if (code.hasTypeAnnotations) score += 0.3;
+      if (!code.source.includes(': any')) score += 0.2;
+      return Math.min(1.0, score);
+    },
+  },
+  {
+    name: 'cohesion',
+    weight: 0.15,
+    check: (code) => {
+      const internalImports = code.internalDeps.length;
+      const exportCount = code.exports.length;
+      if (exportCount === 0) return 0;
+      const ratio = internalImports / exportCount;
+      if (ratio === 0) return 1.0;
+      if (ratio < 0.5) return 0.8;
+      if (ratio < 1.0) return 0.5;
+      return 0.2;
+    },
+  },
+  {
+    name: 'generic_utility',
+    weight: 0.10,
+    check: (code) => {
+      const utilPaths = ['utils/', 'helpers/', 'lib/', 'shared/', 'common/'];
+      const isUtilPath = utilPaths.some(p => code.filePath.includes(p));
+      const hasGenerics = /<[A-Z]\w*>/.test(code.source);
+      let score = 0;
+      if (isUtilPath) score += 0.6;
+      if (hasGenerics) score += 0.4;
+      return Math.min(1.0, score || 0.2);
+    },
+  },
+  {
+    name: 'documentation',
+    weight: 0.10,
+    check: (code) => {
+      const hasJsdoc = /\/\*\*[\s\S]*?\*\//.test(code.source);
+      const hasDocstring = /"""[\s\S]*?"""/.test(code.source) || /'''[\s\S]*?'''/.test(code.source);
+      const hasInlineComments = (code.source.match(/\/\/ /g) ?? []).length >= 2;
+      if (hasJsdoc || hasDocstring) return 1.0;
+      if (hasInlineComments) return 0.5;
+      return 0.1;
+    },
+  },
+];
+
+export const MODULE_THRESHOLD = 0.60;
+
+export function computeReusabilityScore(code: CodeUnitForScoring): number {
+  let totalScore = 0;
+  for (const signal of REUSABILITY_SIGNALS) {
+    totalScore += signal.check(code) * signal.weight;
+  }
+  return Math.min(1.0, totalScore);
+}
+
+export function getSignalBreakdown(code: CodeUnitForScoring): Array<{ name: string; score: number; weighted: number }> {
+  return REUSABILITY_SIGNALS.map(signal => {
+    const score = signal.check(code);
+    return { name: signal.name, score, weighted: score * signal.weight };
+  });
+}

package/src/config.ts

@@ -0,0 +1,111 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import type { BrainConfig } from './types/config.types.js';
+import { getDataDir, getPipeName } from './utils/paths.js';
+
+const defaults: BrainConfig = {
+  dataDir: getDataDir(),
+  dbPath: path.join(getDataDir(), 'brain.db'),
+  ipc: {
+    pipeName: getPipeName(),
+    timeout: 5000,
+  },
+  learning: {
+    intervalMs: 900_000,
+    minOccurrences: 3,
+    minSuccessRate: 0.70,
+    minConfidence: 0.60,
+    pruneThreshold: 0.20,
+    maxRejectionRate: 0.50,
+    decayHalfLifeDays: 30,
+  },
+  terminal: {
+    staleTimeout: 300000, // 5 min
+    maxConnected: 50,
+  },
+  matching: {
+    fingerprintFields: ['type', 'message', 'file_path'],
+    similarityThreshold: 0.8,
+    maxResults: 10,
+  },
+  code: {
+    supportedLanguages: ['typescript', 'javascript', 'python', 'rust', 'go'],
+    maxModuleSize: 50000,
+    similarityThreshold: 0.75,
+  },
+  synapses: {
+    initialWeight: 0.1,
+    learningRate: 0.15,
+    decayHalfLifeDays: 45,
+    pruneThreshold: 0.05,
+    decayAfterDays: 14,
+    maxDepth: 3,
+    minActivationWeight: 0.2,
+  },
+  research: {
+    intervalMs: 3_600_000,
+    initialDelayMs: 300_000,
+    minDataPoints: 10,
+    trendWindowDays: 7,
+    gapMinOccurrences: 5,
+    synergyMinWeight: 0.5,
+    templateMinAdaptations: 3,
+    insightExpiryDays: 30,
+  },
+  log: {
+    level: 'info',
+    file: path.join(getDataDir(), 'brain.log'),
+    maxSize: 10 * 1024 * 1024,
+    maxFiles: 3,
+  },
+  retention: {
+    errorDays: 90,
+    solutionDays: 365,
+    insightDays: 30,
+  },
+};
+
+function applyEnvOverrides(config: BrainConfig): void {
+  if (process.env['BRAIN_DATA_DIR']) {
+    config.dataDir = process.env['BRAIN_DATA_DIR'];
+    config.dbPath = path.join(config.dataDir, 'brain.db');
+    config.log.file = path.join(config.dataDir, 'brain.log');
+  }
+  if (process.env['BRAIN_DB_PATH']) config.dbPath = process.env['BRAIN_DB_PATH'];
+  if (process.env['BRAIN_LOG_LEVEL']) config.log.level = process.env['BRAIN_LOG_LEVEL'];
+  if (process.env['BRAIN_PIPE_NAME']) config.ipc.pipeName = process.env['BRAIN_PIPE_NAME'];
+}
+
+function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): void {
+  for (const key of Object.keys(source)) {
+    const val = source[key];
+    if (val && typeof val === 'object' && !Array.isArray(val) && target[key] && typeof target[key] === 'object') {
+      deepMerge(target[key] as Record<string, unknown>, val as Record<string, unknown>);
+    } else if (val !== undefined) {
+      target[key] = val;
+    }
+  }
+}
+
+export function loadConfig(configPath?: string): BrainConfig {
+  const config = structuredClone(defaults);
+
+  if (configPath) {
+    const filePath = path.resolve(configPath);
+    if (fs.existsSync(filePath)) {
+      const raw = fs.readFileSync(filePath, 'utf-8');
+      const fileConfig = JSON.parse(raw) as Partial<BrainConfig>;
+      deepMerge(config as unknown as Record<string, unknown>, fileConfig as unknown as Record<string, unknown>);
+    }
+  } else {
+    const defaultConfigPath = path.join(getDataDir(), 'config.json');
+    if (fs.existsSync(defaultConfigPath)) {
+      const raw = fs.readFileSync(defaultConfigPath, 'utf-8');
+      const fileConfig = JSON.parse(raw) as Partial<BrainConfig>;
+      deepMerge(config as unknown as Record<string, unknown>, fileConfig as unknown as Record<string, unknown>);
+    }
+  }
+
+  applyEnvOverrides(config);
+  return config;
+}

package/src/db/connection.ts

@@ -0,0 +1,22 @@
+import Database from 'better-sqlite3';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getLogger } from '../utils/logger.js';
+
+export function createConnection(dbPath: string): Database.Database {
+  const logger = getLogger();
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  logger.info(`Opening database at ${dbPath}`);
+  const db = new Database(dbPath);
+
+  db.pragma('journal_mode = WAL');
+  db.pragma('synchronous = NORMAL');
+  db.pragma('cache_size = 10000');
+  db.pragma('foreign_keys = ON');
+
+  return db;
+}