@timmeck/brain 1.0.0 → 1.1.0

package/src/cli/commands/query.ts

@@ -1,42 +1,119 @@
 import { Command } from 'commander';
 import { withIpc } from '../ipc-helper.js';
+import { c, icons, header, statusBadge, divider } from '../colors.js';
 
 export function queryCommand(): Command {
   return new Command('query')
-    .description('Search for errors and solutions')
-    .argument('<search>', 'Error message or description to search for')
-    .option('-l, --limit <n>', 'Maximum results', '10')
+    .description('Search errors, code modules, and insights')
+    .argument('<search>', 'Search term')
+    .option('-l, --limit <n>', 'Maximum results per category', '10')
+    .option('--errors-only', 'Only search errors')
+    .option('--modules-only', 'Only search code modules')
+    .option('--insights-only', 'Only search insights')
+    .option('--page <n>', 'Page number (starting from 1)', '1')
     .action(async (search: string, opts) => {
       await withIpc(async (client) => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const results: any = await client.request('error.query', {
-          search,
-          limit: parseInt(opts.limit, 10),
-        });
-
-        if (!results?.length) {
-          console.log('No matching errors found.');
-          return;
+        const limit = parseInt(opts.limit, 10);
+        const page = parseInt(opts.page, 10) || 1;
+        const offset = (page - 1) * limit;
+        const searchAll = !opts.errorsOnly && !opts.modulesOnly && !opts.insightsOnly;
+        let totalResults = 0;
+
+        // --- Errors ---
+        if (searchAll || opts.errorsOnly) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const results: any = await client.request('error.query', {
+            search,
+            limit: limit + offset,
+          });
+
+          const errors = Array.isArray(results) ? results.slice(offset, offset + limit) : [];
+          if (errors.length > 0) {
+            totalResults += errors.length;
+            console.log(header(`Errors matching "${search}"`, icons.error));
+
+            for (const err of errors) {
+              const badge = statusBadge(err.resolved ? 'resolved' : 'open');
+              const typeTag = c.purple(err.errorType ?? 'unknown');
+              console.log(`  ${c.dim(`#${err.id}`)} ${badge} ${typeTag}`);
+              console.log(`     ${c.dim((err.message ?? '').slice(0, 120))}`);
+
+              // Get solutions for this error
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              const solutions: any = await client.request('solution.query', { error_id: err.id });
+              if (solutions?.length > 0) {
+                console.log(`     ${c.green(`${icons.check} ${solutions.length} solution(s)`)}`);
+                for (const sol of solutions.slice(0, 3)) {
+                  console.log(`       ${c.dim(icons.corner)} ${c.dim((sol.description ?? '').slice(0, 100))}`);
+                }
+              }
+              console.log();
+            }
+          }
         }
 
-        console.log(`Found ${results.length} errors:\n`);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        for (const err of results as any[]) {
-          const status = err.resolved ? 'RESOLVED' : 'OPEN';
-          console.log(`  #${err.id} [${status}] ${err.errorType ?? 'unknown'}`);
-          console.log(`    ${(err.message ?? '').slice(0, 120)}`);
+        // --- Code Modules ---
+        if (searchAll || opts.modulesOnly) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const modules: any = await client.request('code.find', {
+            query: search,
+            limit: limit + offset,
+          });
+
+          const mods = Array.isArray(modules) ? modules.slice(offset, offset + limit) : [];
+          if (mods.length > 0) {
+            totalResults += mods.length;
+            console.log(header(`Modules matching "${search}"`, icons.module));
 
-          // Get solutions for this error
+            for (const mod of mods) {
+              const score = mod.reusability_score ?? mod.reusabilityScore ?? 0;
+              const scoreColor = score >= 0.7 ? c.green : score >= 0.4 ? c.orange : c.red;
+              console.log(`  ${c.dim(`#${mod.id}`)} ${c.cyan(`[${mod.language}]`)} ${c.value(mod.name)}`);
+              console.log(`     ${c.label('File:')} ${c.dim(mod.file_path ?? mod.filePath)}  ${c.label('Score:')} ${scoreColor(typeof score === 'number' ? score.toFixed(2) : score)}`);
+              if (mod.description) {
+                console.log(`     ${c.dim(mod.description.slice(0, 120))}`);
+              }
+              console.log();
+            }
+          }
+        }
+
+        // --- Insights ---
+        if (searchAll || opts.insightsOnly) {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          const solutions: any = await client.request('solution.query', { error_id: err.id });
-          if (solutions?.length > 0) {
-            console.log(`    Solutions: ${solutions.length}`);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            for (const sol of solutions.slice(0, 3) as any[]) {
-              console.log(`      - #${sol.id}: ${(sol.description ?? '').slice(0, 100)}`);
+          const insights: any = await client.request('research.insights', {
+            activeOnly: true,
+            limit: 100,
+          });
+
+          // Client-side search since insights API may not support text search
+          const allInsights = Array.isArray(insights) ? insights : [];
+          const searchLower = search.toLowerCase();
+          const matched = allInsights.filter((i: { title?: string; description?: string }) =>
+            (i.title ?? '').toLowerCase().includes(searchLower) ||
+            (i.description ?? '').toLowerCase().includes(searchLower)
+          ).slice(offset, offset + limit);
+
+          if (matched.length > 0) {
+            totalResults += matched.length;
+            console.log(header(`Insights matching "${search}"`, icons.insight));
+
+            for (const ins of matched) {
+              const typeTag = c.cyan(`[${ins.type}]`);
+              console.log(`  ${typeTag} ${c.value(ins.title)}`);
+              if (ins.description) {
+                console.log(`     ${c.dim(ins.description.slice(0, 150))}`);
+              }
+              console.log();
             }
           }
-          console.log();
+        }
+
+        if (totalResults === 0) {
+          console.log(`\n${icons.search}  ${c.dim(`No results found for "${search}".`)}`);
+        } else {
+          console.log(`  ${c.dim(`Page ${page} — showing ${totalResults} result(s). Use --page ${page + 1} for more.`)}`);
+          console.log(divider());
         }
       });
     });

package/src/cli/commands/start.ts

@@ -3,6 +3,7 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { getDataDir } from '../../utils/paths.js';
+import { c, icons } from '../colors.js';
 
 export function startCommand(): Command {
   return new Command('start')
@@ -17,7 +18,7 @@ export function startCommand(): Command {
         const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
         try {
           process.kill(pid, 0); // Check if process exists
-          console.log(`Brain daemon is already running (PID: ${pid})`);
+          console.log(`${icons.brain}  Brain daemon is ${c.green('already running')} ${c.dim(`(PID: ${pid})`)}`);
           return;
         } catch {
           // PID file stale, remove it
@@ -45,14 +46,14 @@ export function startCommand(): Command {
       });
       child.unref();
 
-      console.log(`Brain daemon starting (PID: ${child.pid})`);
+      console.log(`${icons.brain}  ${c.info('Brain daemon starting')} ${c.dim(`(PID: ${child.pid})`)}`);
 
       // Wait briefly for PID file to appear
       setTimeout(() => {
         if (fs.existsSync(pidPath)) {
-          console.log('Brain daemon started successfully.');
+          console.log(`${icons.ok}  ${c.success('Brain daemon started successfully.')}`);
         } else {
-          console.log('Brain daemon may still be starting. Check: brain status');
+          console.log(`${icons.clock}  ${c.warn('Brain daemon may still be starting.')} Check: ${c.cyan('brain status')}`);
         }
       }, 1000);
     });

package/src/cli/commands/status.ts

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { getDataDir } from '../../utils/paths.js';
 import { withIpc } from '../ipc-helper.js';
+import { c, icons, header, keyValue, divider } from '../colors.js';
 
 export function statusCommand(): Command {
   return new Command('status')
@@ -11,7 +12,7 @@ export function statusCommand(): Command {
       const pidPath = path.join(getDataDir(), 'brain.pid');
 
       if (!fs.existsSync(pidPath)) {
-        console.log('Brain Daemon: NOT RUNNING');
+        console.log(`${icons.brain}  Brain Daemon: ${c.red.bold('NOT RUNNING')}`);
         return;
       }
 
@@ -23,11 +24,12 @@ export function statusCommand(): Command {
       } catch { /* not running */ }
 
       if (!running) {
-        console.log('Brain Daemon: NOT RUNNING (stale PID file)');
+        console.log(`${icons.brain}  Brain Daemon: ${c.red.bold('NOT RUNNING')} ${c.dim('(stale PID file)')}`);
         return;
       }
 
-      console.log(`Brain Daemon: RUNNING (PID ${pid})`);
+      console.log(header('Brain Status', icons.brain));
+      console.log(`  ${c.green(`${icons.dot} RUNNING`)} ${c.dim(`(PID ${pid})`)}`);
 
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       await withIpc(async (client) => {
@@ -43,27 +45,28 @@ export function statusCommand(): Command {
           dbSize = `${(stat.size / 1024 / 1024).toFixed(1)} MB`;
         } catch { /* ignore */ }
 
-        console.log(`Database: ${dbPath} (${dbSize})`);
+        console.log(keyValue('Database', `${dbPath} (${dbSize})`));
         console.log();
 
-        console.log('Error Brain:');
-        console.log(`  Errors: ${summary.errors?.total ?? 0} total, ${summary.errors?.unresolved ?? 0} unresolved, ${summary.errors?.last7d ?? 0} last 7d`);
-        console.log(`  Solutions: ${summary.solutions?.total ?? 0}`);
-        console.log(`  Rules: ${summary.rules?.active ?? 0} active`);
-        console.log(`  Anti-Patterns: ${summary.antipatterns?.total ?? 0}`);
+        console.log(`  ${icons.error}  ${c.purple.bold('Error Brain')}`);
+        console.log(`     ${c.label('Errors:')}     ${c.value(summary.errors?.total ?? 0)} total, ${c.red(summary.errors?.unresolved ?? 0)} unresolved, ${c.dim(`${summary.errors?.last7d ?? 0} last 7d`)}`);
+        console.log(`     ${c.label('Solutions:')}  ${c.value(summary.solutions?.total ?? 0)}`);
+        console.log(`     ${c.label('Rules:')}      ${c.green(summary.rules?.active ?? 0)} active`);
+        console.log(`     ${c.label('Anti-Pat.:')} ${c.value(summary.antipatterns?.total ?? 0)}`);
         console.log();
 
-        console.log('Code Brain:');
-        console.log(`  Modules: ${summary.modules?.total ?? 0} registered`);
+        console.log(`  ${icons.module}  ${c.blue.bold('Code Brain')}`);
+        console.log(`     ${c.label('Modules:')}    ${c.value(summary.modules?.total ?? 0)} registered`);
         console.log();
 
-        console.log('Synapse Network:');
-        console.log(`  Synapses: ${network.totalSynapses ?? 0}`);
-        console.log(`  Avg weight: ${(network.avgWeight ?? 0).toFixed(2)}`);
+        console.log(`  ${icons.synapse}  ${c.cyan.bold('Synapse Network')}`);
+        console.log(`     ${c.label('Synapses:')}   ${c.value(network.totalSynapses ?? 0)}`);
+        console.log(`     ${c.label('Avg weight:')} ${c.value((network.avgWeight ?? 0).toFixed(2))}`);
         console.log();
 
-        console.log('Research Brain:');
-        console.log(`  Insights: ${summary.insights?.active ?? 0} active`);
+        console.log(`  ${icons.insight}  ${c.orange.bold('Research Brain')}`);
+        console.log(`     ${c.label('Insights:')}   ${c.value(summary.insights?.active ?? 0)} active`);
+        console.log(`\n${divider()}`);
       });
     });
 }

package/src/cli/commands/stop.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 import fs from 'node:fs';
 import path from 'node:path';
 import { getDataDir } from '../../utils/paths.js';
+import { c, icons } from '../colors.js';
 
 export function stopCommand(): Command {
   return new Command('stop')
@@ -10,7 +11,7 @@ export function stopCommand(): Command {
       const pidPath = path.join(getDataDir(), 'brain.pid');
 
       if (!fs.existsSync(pidPath)) {
-        console.log('Brain daemon is not running (no PID file found).');
+        console.log(`${icons.brain}  ${c.dim('Brain daemon is not running (no PID file found).')}`);
         return;
       }
 
@@ -18,12 +19,12 @@ export function stopCommand(): Command {
 
       try {
         process.kill(pid, 'SIGTERM');
-        console.log(`Brain daemon stopped (PID: ${pid})`);
+        console.log(`${icons.brain}  ${c.success('Brain daemon stopped')} ${c.dim(`(PID: ${pid})`)}`);
       } catch (err) {
         if ((err as NodeJS.ErrnoException).code === 'ESRCH') {
-          console.log('Brain daemon was not running (stale PID file removed).');
+          console.log(`${icons.brain}  ${c.dim('Brain daemon was not running (stale PID file removed).')}`);
         } else {
-          console.error(`Failed to stop daemon: ${err}`);
+          console.error(`${icons.error}  ${c.error(`Failed to stop daemon: ${err}`)}`);
         }
       }
 

package/src/cli/ipc-helper.ts

@@ -1,5 +1,6 @@
 import { IpcClient } from '../ipc/client.js';
 import { getPipeName } from '../utils/paths.js';
+import { c, icons } from './colors.js';
 
 export async function withIpc<T>(fn: (client: IpcClient) => Promise<T>): Promise<T> {
   const client = new IpcClient(getPipeName(), 5000);
@@ -8,11 +9,11 @@ export async function withIpc<T>(fn: (client: IpcClient) => Promise<T>): Promise
     return await fn(client);
   } catch (err) {
     if (err instanceof Error && err.message.includes('ENOENT')) {
-      console.error('Brain daemon is not running. Start it with: brain start');
+      console.error(`${icons.error}  ${c.error('Brain daemon is not running.')} Start it with: ${c.cyan('brain start')}`);
     } else if (err instanceof Error && err.message.includes('ECONNREFUSED')) {
-      console.error('Brain daemon is not responding. Try: brain stop && brain start');
+      console.error(`${icons.error}  ${c.error('Brain daemon is not responding.')} Try: ${c.cyan('brain stop && brain start')}`);
     } else {
-      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      console.error(`${icons.error}  ${c.error(err instanceof Error ? err.message : String(err))}`);
     }
     process.exit(1);
   } finally {

package/src/code/analyzer.ts

@@ -1,77 +1,77 @@
-import type { ExportInfo } from '../types/code.types.js';
-import * as tsParser from './parsers/typescript.js';
-import * as pyParser from './parsers/python.js';
-import * as genericParser from './parsers/generic.js';
-
-export interface AnalysisResult {
-  exports: ExportInfo[];
-  externalDeps: string[];
-  internalDeps: string[];
-  isPure: boolean;
-  hasTypeAnnotations: boolean;
-  linesOfCode: number;
-}
-
-const SIDE_EFFECT_PATTERNS = [
-  'fs.', 'process.exit', 'process.env', 'console.', 'fetch(',
-  'XMLHttpRequest', 'document.', 'window.',
-  'global.', 'require(',
-];
-
-function getParser(language: string) {
-  switch (language) {
-    case 'typescript':
-    case 'javascript':
-      return tsParser;
-    case 'python':
-      return pyParser;
-    default:
-      return genericParser;
-  }
-}
-
-export function analyzeCode(source: string, language: string): AnalysisResult {
-  const parser = getParser(language);
-  const exports = parser.extractExports(source);
-  const { external, internal } = parser.extractImports(source);
-  const isPure = checkPurity(source);
-  const typed = parser.hasTypeAnnotations(source);
-  const linesOfCode = source.split('\n').filter(l => l.trim().length > 0).length;
-
-  return {
-    exports,
-    externalDeps: external,
-    internalDeps: internal,
-    isPure,
-    hasTypeAnnotations: typed,
-    linesOfCode,
-  };
-}
-
-export function checkPurity(source: string): boolean {
-  return !SIDE_EFFECT_PATTERNS.some(p => source.includes(p));
-}
-
-export function measureCohesion(exports: ExportInfo[]): number {
-  if (exports.length <= 1) return 1.0;
-
-  const names = exports.map(e =>
-    e.name
-      .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
-      .replace(/([a-z\d])([A-Z])/g, '$1 $2')
-      .toLowerCase()
-      .split(/\s+/)
-  );
-
-  const vocab = new Set<string>();
-  names.forEach(tokens => tokens.forEach(t => vocab.add(t)));
-
-  let sharedTokens = 0;
-  for (const token of vocab) {
-    const count = names.filter(n => n.includes(token)).length;
-    if (count > 1) sharedTokens += count;
-  }
-
-  const maxPossible = names.length * vocab.size;
-  return maxPossible === 0 ? 0 : sharedTokens / maxPossible;
-}
+import type { ExportInfo } from '../types/code.types.js';
+import * as tsParser from './parsers/typescript.js';
+import * as pyParser from './parsers/python.js';
+import * as genericParser from './parsers/generic.js';
+
+export interface AnalysisResult {
+  exports: ExportInfo[];
+  externalDeps: string[];
+  internalDeps: string[];
+  isPure: boolean;
+  hasTypeAnnotations: boolean;
+  linesOfCode: number;
+}
+
+const SIDE_EFFECT_PATTERNS = [
+  'fs.', 'process.exit', 'process.env', 'console.', 'fetch(',
+  'XMLHttpRequest', 'document.', 'window.',
+  'global.', 'require(',
+];
+
+function getParser(language: string) {
+  switch (language) {
+    case 'typescript':
+    case 'javascript':
+      return tsParser;
+    case 'python':
+      return pyParser;
+    default:
+      return genericParser;
+  }
+}
+
+export function analyzeCode(source: string, language: string): AnalysisResult {
+  const parser = getParser(language);
+  const exports = parser.extractExports(source);
+  const { external, internal } = parser.extractImports(source);
+  const isPure = checkPurity(source);
+  const typed = parser.hasTypeAnnotations(source);
+  const linesOfCode = source.split('\n').filter(l => l.trim().length > 0).length;
+
+  return {
+    exports,
+    externalDeps: external,
+    internalDeps: internal,
+    isPure,
+    hasTypeAnnotations: typed,
+    linesOfCode,
+  };
+}
+
+export function checkPurity(source: string): boolean {
+  return !SIDE_EFFECT_PATTERNS.some(p => source.includes(p));
+}
+
+export function measureCohesion(exports: ExportInfo[]): number {
+  if (exports.length <= 1) return 1.0;
+
+  const names = exports.map(e =>
+    e.name
+      .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+      .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+      .toLowerCase()
+      .split(/\s+/)
+  );
+
+  const vocab = new Set<string>();
+  names.forEach(tokens => tokens.forEach(t => vocab.add(t)));
+
+  let sharedTokens = 0;
+  for (const token of vocab) {
+    const count = names.filter(n => n.includes(token)).length;
+    if (count > 1) sharedTokens += count;
+  }
+
+  const maxPossible = names.length * vocab.size;
+  return maxPossible === 0 ? 0 : sharedTokens / maxPossible;
+}

package/src/code/fingerprint.ts

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