@timmeck/brain 1.0.0

package/src/cli/commands/import.ts

@@ -0,0 +1,190 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { resolve, basename, relative, extname } from 'path';
+
+const DEFAULT_EXTENSIONS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.py', '.rs', '.go',
+  '.java', '.c', '.cpp', '.h', '.hpp', '.rb', '.sh',
+]);
+
+const EXCLUDE_DIRS = new Set([
+  'node_modules', 'dist', 'build', '.git', '.next',
+  '__pycache__', 'vendor', 'coverage', '.cache', '.turbo',
+  '.nuxt', '.output', 'target', 'out', 'venv', '.venv',
+  'env', '.env', 'site-packages',
+]);
+
+const EXCLUDE_PATTERNS = [/\.min\./, /\.bundle\./, /\.d\.ts$/];
+
+const LANG_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', bash: 'shell',
+};
+
+function detectLanguage(filePath: string): string {
+  const ext = extname(filePath).slice(1).toLowerCase();
+  return LANG_MAP[ext] ?? ext;
+}
+
+function findSourceFiles(dir: string, extensions: Set<string>, maxSizeBytes: number): string[] {
+  const files: string[] = [];
+
+  function walk(current: string): void {
+    let entries;
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      return; // skip unreadable directories
+    }
+
+    for (const entry of entries) {
+      const fullPath = resolve(current, entry.name);
+
+      if (entry.isDirectory()) {
+        if (!EXCLUDE_DIRS.has(entry.name)) {
+          walk(fullPath);
+        }
+        continue;
+      }
+
+      if (!entry.isFile()) continue;
+
+      const ext = extname(entry.name).toLowerCase();
+      if (!extensions.has(ext)) continue;
+      if (EXCLUDE_PATTERNS.some(p => p.test(entry.name))) continue;
+
+      try {
+        const stat = statSync(fullPath);
+        if (stat.size > maxSizeBytes) continue;
+        files.push(fullPath);
+      } catch {
+        // skip unreadable files
+      }
+    }
+  }
+
+  walk(dir);
+  return files.sort();
+}
+
+export function importCommand(): Command {
+  return new Command('import')
+    .description('Import source files from a project directory into Brain')
+    .argument('<directory>', 'Project directory to scan')
+    .option('-p, --project <name>', 'Project name (default: directory basename)')
+    .option('-e, --extensions <list>', 'Comma-separated extensions (default: ts,tsx,js,jsx,py,rs,go,java,c,cpp,h,hpp,rb,sh)')
+    .option('--dry-run', 'List files that would be imported without importing')
+    .option('--max-size <kb>', 'Skip files larger than N KB', '100')
+    .action(async (directory: string, opts) => {
+      const dir = resolve(directory);
+      const projectName = opts.project ?? basename(dir);
+      const maxSizeKb = parseInt(opts.maxSize, 10) || 100;
+      const maxSizeBytes = maxSizeKb * 1024;
+
+      // Parse extensions
+      let extensions = DEFAULT_EXTENSIONS;
+      if (opts.extensions) {
+        extensions = new Set(
+          opts.extensions.split(',').map((e: string) => {
+            const trimmed = e.trim();
+            return trimmed.startsWith('.') ? trimmed : `.${trimmed}`;
+          })
+        );
+      }
+
+      // Verify directory exists
+      try {
+        const stat = statSync(dir);
+        if (!stat.isDirectory()) {
+          console.error(`Not a directory: ${dir}`);
+          process.exit(1);
+        }
+      } catch {
+        console.error(`Directory not found: ${dir}`);
+        process.exit(1);
+      }
+
+      console.log(`Scanning ${dir} ...`);
+      const files = findSourceFiles(dir, extensions, maxSizeBytes);
+
+      if (files.length === 0) {
+        console.log('No source files found.');
+        return;
+      }
+
+      console.log(`Found ${files.length} source files.\n`);
+
+      if (opts.dryRun) {
+        for (const f of files) {
+          const rel = relative(dir, f);
+          const lang = detectLanguage(f);
+          console.log(`  [${lang}] ${rel}`);
+        }
+        console.log(`\n${files.length} files would be imported as project "${projectName}".`);
+        return;
+      }
+
+      // Import via IPC
+      await withIpc(async (client) => {
+        let imported = 0;
+        let newCount = 0;
+        let existingCount = 0;
+        let failedCount = 0;
+        let totalScore = 0;
+
+        for (let i = 0; i < files.length; i++) {
+          const filePath = files[i];
+          const rel = relative(dir, filePath);
+          const fileName = basename(filePath);
+          const language = detectLanguage(filePath);
+
+          let source: string;
+          try {
+            source = readFileSync(filePath, 'utf-8');
+          } catch {
+            failedCount++;
+            process.stdout.write(`  [${i + 1}/${files.length}] ${rel} — read error\n`);
+            continue;
+          }
+
+          // Skip empty files
+          if (!source.trim()) continue;
+
+          try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result: any = await client.request('code.analyze', {
+              project: projectName,
+              name: fileName,
+              filePath: rel,
+              language,
+              source,
+            });
+
+            const score = result.reusabilityScore ?? 0;
+            const status = result.isNew ? 'new' : 'existing';
+            totalScore += score;
+            imported++;
+
+            if (result.isNew) newCount++;
+            else existingCount++;
+
+            process.stdout.write(`  [${i + 1}/${files.length}] ${rel} → score: ${score.toFixed(2)} (${status})\n`);
+          } catch (err) {
+            failedCount++;
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stdout.write(`  [${i + 1}/${files.length}] ${rel} — failed: ${msg.slice(0, 80)}\n`);
+          }
+        }
+
+        const avgScore = imported > 0 ? (totalScore / imported).toFixed(2) : '0';
+        console.log(`\n--- Import Summary ---`);
+        console.log(`  Project:  ${projectName}`);
+        console.log(`  Imported: ${imported} (${newCount} new, ${existingCount} existing)`);
+        if (failedCount > 0) console.log(`  Failed:   ${failedCount}`);
+        console.log(`  Avg reusability score: ${avgScore}`);
+      });
+    });
+}

package/src/cli/commands/insights.ts

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+
+export function insightsCommand(): Command {
+  return new Command('insights')
+    .description('Show research insights')
+    .option('--type <type>', 'Filter by type: trend, pattern, gap, synergy, optimization, template_candidate, project_suggestion, warning')
+    .option('-l, --limit <n>', 'Maximum results', '20')
+    .action(async (opts) => {
+      await withIpc(async (client) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const insights: any = await client.request('research.insights', {
+          type: opts.type,
+          activeOnly: true,
+          limit: parseInt(opts.limit, 10),
+        });
+
+        if (!insights?.length) {
+          console.log('No active insights.');
+          return;
+        }
+
+        console.log(`${insights.length} insights:\n`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        for (const ins of insights as any[]) {
+          const priority = ins.priority >= 8 ? 'HIGH' : ins.priority >= 5 ? 'MEDIUM' : 'LOW';
+          console.log(`  [${ins.type}] [${priority}] ${ins.title}`);
+          if (ins.description) console.log(`    ${ins.description.slice(0, 150)}`);
+          console.log();
+        }
+      });
+    });
+}

package/src/cli/commands/modules.ts

@@ -0,0 +1,30 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+
+export function modulesCommand(): Command {
+  return new Command('modules')
+    .description('List registered code modules')
+    .option('--language <lang>', 'Filter by language')
+    .action(async (opts) => {
+      await withIpc(async (client) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const modules: any = await client.request('code.modules', {
+          language: opts.language,
+        });
+
+        if (!modules?.length) {
+          console.log('No code modules registered.');
+          return;
+        }
+
+        console.log(`${modules.length} code modules:\n`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        for (const mod of modules as any[]) {
+          console.log(`  #${mod.id} [${mod.language}] ${mod.name}`);
+          if (mod.description) console.log(`    ${mod.description.slice(0, 120)}`);
+          console.log(`    File: ${mod.filePath}  Reusability: ${mod.reusabilityScore ?? '?'}`);
+          console.log();
+        }
+      });
+    });
+}

package/src/cli/commands/network.ts

@@ -0,0 +1,61 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.js';
+
+export function networkCommand(): Command {
+  return new Command('network')
+    .description('Explore the synapse network')
+    .option('--node <type:id>', 'Node to explore (e.g., error:42)')
+    .option('-l, --limit <n>', 'Max synapses to show', '20')
+    .action(async (opts) => {
+      await withIpc(async (client) => {
+        if (opts.node) {
+          const [nodeType, nodeIdStr] = opts.node.split(':');
+          const nodeId = parseInt(nodeIdStr, 10);
+
+          if (!nodeType || isNaN(nodeId)) {
+            console.error('Invalid node format. Use: --node error:42');
+            return;
+          }
+
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const related: any = await client.request('synapse.related', {
+            nodeType,
+            nodeId,
+            maxDepth: 2,
+          });
+
+          if (!related?.length) {
+            console.log(`No connections found for ${nodeType}:${nodeId}`);
+            return;
+          }
+
+          console.log(`Connections from ${nodeType}:${nodeId}:\n`);
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          for (const r of related as any[]) {
+            console.log(`  → ${r.nodeType}:${r.nodeId} (weight: ${(r.activation ?? r.weight ?? 0).toFixed(3)})`);
+          }
+        } else {
+          // Show general network stats
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const stats: any = await client.request('synapse.stats', {});
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const overview: any = await client.request('analytics.network', {
+            limit: parseInt(opts.limit, 10),
+          });
+
+          console.log('Synapse Network Overview:\n');
+          console.log(`  Total synapses: ${stats.totalSynapses ?? 0}`);
+          console.log(`  Average weight: ${(stats.avgWeight ?? 0).toFixed(3)}`);
+          console.log();
+
+          if (overview?.strongestSynapses?.length) {
+            console.log('Strongest connections:');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            for (const s of overview.strongestSynapses as any[]) {
+              console.log(`  ${s.source} → ${s.target} [${s.type}] weight: ${(s.weight ?? 0).toFixed(3)}`);
+            }
+          }
+        }
+      });
+    });
+}

package/src/cli/commands/query.ts

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { withIpc } from '../ipc-helper.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')
+    .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;
+        }
+
+        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)}`);
+
+          // 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(`    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)}`);
+            }
+          }
+          console.log();
+        }
+      });
+    });
+}

package/src/cli/commands/start.ts

@@ -0,0 +1,59 @@
+import { Command } from 'commander';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDataDir } from '../../utils/paths.js';
+
+export function startCommand(): Command {
+  return new Command('start')
+    .description('Start the Brain daemon')
+    .option('-f, --foreground', 'Run in foreground (no detach)')
+    .option('-c, --config <path>', 'Config file path')
+    .action((opts) => {
+      const pidPath = path.join(getDataDir(), 'brain.pid');
+
+      // Check if already running
+      if (fs.existsSync(pidPath)) {
+        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})`);
+          return;
+        } catch {
+          // PID file stale, remove it
+          fs.unlinkSync(pidPath);
+        }
+      }
+
+      if (opts.foreground) {
+        // Run in foreground — import dynamically to avoid loading everything at CLI parse time
+        import('../../brain.js').then(({ BrainCore }) => {
+          const core = new BrainCore();
+          core.start(opts.config);
+        });
+        return;
+      }
+
+      // Spawn detached daemon
+      const args = ['daemon'];
+      if (opts.config) args.push('-c', opts.config);
+
+      const entryPoint = path.resolve(import.meta.dirname, '../../index.js');
+      const child = spawn(process.execPath, [entryPoint, ...args], {
+        detached: true,
+        stdio: 'ignore',
+      });
+      child.unref();
+
+      console.log(`Brain daemon starting (PID: ${child.pid})`);
+
+      // Wait briefly for PID file to appear
+      setTimeout(() => {
+        if (fs.existsSync(pidPath)) {
+          console.log('Brain daemon started successfully.');
+        } else {
+          console.log('Brain daemon may still be starting. Check: brain status');
+        }
+      }, 1000);
+    });
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,69 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDataDir } from '../../utils/paths.js';
+import { withIpc } from '../ipc-helper.js';
+
+export function statusCommand(): Command {
+  return new Command('status')
+    .description('Show Brain daemon status')
+    .action(async () => {
+      const pidPath = path.join(getDataDir(), 'brain.pid');
+
+      if (!fs.existsSync(pidPath)) {
+        console.log('Brain Daemon: NOT RUNNING');
+        return;
+      }
+
+      const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+      let running = false;
+      try {
+        process.kill(pid, 0);
+        running = true;
+      } catch { /* not running */ }
+
+      if (!running) {
+        console.log('Brain Daemon: NOT RUNNING (stale PID file)');
+        return;
+      }
+
+      console.log(`Brain Daemon: RUNNING (PID ${pid})`);
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await withIpc(async (client) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const summary: any = await client.request('analytics.summary', {});
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const network: any = await client.request('synapse.stats', {});
+
+        const dbPath = path.join(getDataDir(), 'brain.db');
+        let dbSize = '?';
+        try {
+          const stat = fs.statSync(dbPath);
+          dbSize = `${(stat.size / 1024 / 1024).toFixed(1)} MB`;
+        } catch { /* ignore */ }
+
+        console.log(`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();
+
+        console.log('Code Brain:');
+        console.log(`  Modules: ${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();
+
+        console.log('Research Brain:');
+        console.log(`  Insights: ${summary.insights?.active ?? 0} active`);
+      });
+    });
+}

package/src/cli/commands/stop.ts

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDataDir } from '../../utils/paths.js';
+
+export function stopCommand(): Command {
+  return new Command('stop')
+    .description('Stop the Brain daemon')
+    .action(() => {
+      const pidPath = path.join(getDataDir(), 'brain.pid');
+
+      if (!fs.existsSync(pidPath)) {
+        console.log('Brain daemon is not running (no PID file found).');
+        return;
+      }
+
+      const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+
+      try {
+        process.kill(pid, 'SIGTERM');
+        console.log(`Brain daemon stopped (PID: ${pid})`);
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code === 'ESRCH') {
+          console.log('Brain daemon was not running (stale PID file removed).');
+        } else {
+          console.error(`Failed to stop daemon: ${err}`);
+        }
+      }
+
+      // Clean up PID file
+      try { fs.unlinkSync(pidPath); } catch { /* ignore */ }
+    });
+}

package/src/cli/ipc-helper.ts

@@ -0,0 +1,21 @@
+import { IpcClient } from '../ipc/client.js';
+import { getPipeName } from '../utils/paths.js';
+
+export async function withIpc<T>(fn: (client: IpcClient) => Promise<T>): Promise<T> {
+  const client = new IpcClient(getPipeName(), 5000);
+  try {
+    await client.connect();
+    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');
+    } else if (err instanceof Error && err.message.includes('ECONNREFUSED')) {
+      console.error('Brain daemon is not responding. Try: brain stop && brain start');
+    } else {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+    }
+    process.exit(1);
+  } finally {
+    client.disconnect();
+  }
+}

package/src/code/analyzer.ts

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