@timmeck/brain 1.8.5 → 2.0.0

package/src/cli/commands/status.ts

@@ -1,75 +0,0 @@
-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';
-import { c, icons, header, keyValue, divider } from '../colors.js';
-import { checkForUpdate, getCurrentVersion } from '../update-check.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(`${icons.brain}  Brain Daemon: ${c.red.bold('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(`${icons.brain}  Brain Daemon: ${c.red.bold('NOT RUNNING')} ${c.dim('(stale PID file)')}`);
-        return;
-      }
-
-      console.log(header(`Brain Status v${getCurrentVersion()}`, 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) => {
-        // 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(keyValue('Database', `${dbPath} (${dbSize})`));
-        console.log();
-
-        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(`  ${icons.module}  ${c.blue.bold('Code Brain')}`);
-        console.log(`     ${c.label('Modules:')}    ${c.value(summary.modules?.total ?? 0)} registered`);
-        console.log();
-
-        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(`  ${icons.insight}  ${c.orange.bold('Research Brain')}`);
-        console.log(`     ${c.label('Insights:')}   ${c.value(summary.insights?.active ?? 0)} active`);
-
-        await checkForUpdate();
-        console.log(`\n${divider()}`);
-      });
-    });
-}

package/src/cli/commands/stop.ts

@@ -1,34 +0,0 @@
-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')
-    .description('Stop the Brain daemon')
-    .action(() => {
-      const pidPath = path.join(getDataDir(), 'brain.pid');
-
-      if (!fs.existsSync(pidPath)) {
-        console.log(`${icons.brain}  ${c.dim('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(`${icons.brain}  ${c.success('Brain daemon stopped')} ${c.dim(`(PID: ${pid})`)}`);
-      } catch (err) {
-        if ((err as NodeJS.ErrnoException).code === 'ESRCH') {
-          console.log(`${icons.brain}  ${c.dim('Brain daemon was not running (stale PID file removed).')}`);
-        } else {
-          console.error(`${icons.error}  ${c.error(`Failed to stop daemon: ${err}`)}`);
-        }
-      }
-
-      // Clean up PID file
-      try { fs.unlinkSync(pidPath); } catch { /* ignore */ }
-    });
-}

package/src/cli/ipc-helper.ts

@@ -1,22 +0,0 @@
-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);
-  try {
-    await client.connect();
-    return await fn(client);
-  } catch (err) {
-    if (err instanceof Error && err.message.includes('ENOENT')) {
-      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(`${icons.error}  ${c.error('Brain daemon is not responding.')} Try: ${c.cyan('brain stop && brain start')}`);
-    } else {
-      console.error(`${icons.error}  ${c.error(err instanceof Error ? err.message : String(err))}`);
-    }
-    process.exit(1);
-  } finally {
-    client.disconnect();
-  }
-}

package/src/cli/update-check.ts

@@ -1,63 +0,0 @@
-import https from 'node:https';
-import { c, icons } from './colors.js';
-
-// Read current version from package.json at build time
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
-const pkg = require('../../package.json');
-const CURRENT_VERSION: string = pkg.version;
-
-export function getCurrentVersion(): string {
-  return CURRENT_VERSION;
-}
-
-function fetchLatestVersion(): Promise<string | null> {
-  return new Promise((resolve) => {
-    const timeout = setTimeout(() => resolve(null), 3000);
-
-    const req = https.get(
-      'https://registry.npmjs.org/@timmeck/brain/latest',
-      { headers: { Accept: 'application/json' } },
-      (res) => {
-        let data = '';
-        res.on('data', (chunk) => { data += chunk; });
-        res.on('end', () => {
-          clearTimeout(timeout);
-          try {
-            const json = JSON.parse(data);
-            resolve(json.version ?? null);
-          } catch {
-            resolve(null);
-          }
-        });
-      },
-    );
-    req.on('error', () => {
-      clearTimeout(timeout);
-      resolve(null);
-    });
-  });
-}
-
-function isNewer(latest: string, current: string): boolean {
-  const l = latest.split('.').map(Number);
-  const c = current.split('.').map(Number);
-  for (let i = 0; i < 3; i++) {
-    if ((l[i] ?? 0) > (c[i] ?? 0)) return true;
-    if ((l[i] ?? 0) < (c[i] ?? 0)) return false;
-  }
-  return false;
-}
-
-export async function checkForUpdate(): Promise<void> {
-  try {
-    const latest = await fetchLatestVersion();
-    if (latest && isNewer(latest, CURRENT_VERSION)) {
-      console.log();
-      console.log(`  ${icons.star}  ${c.orange.bold(`Update available: v${CURRENT_VERSION} → v${latest}`)}`);
-      console.log(`     Run: ${c.cyan('npm update -g @timmeck/brain')}`);
-    }
-  } catch {
-    // silently ignore — update check is best-effort
-  }
-}

package/src/code/analyzer.ts

@@ -1,117 +0,0 @@
-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;
-  complexity: 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;
-  const complexity = computeCyclomaticComplexity(source, language);
-
-  return {
-    exports,
-    externalDeps: external,
-    internalDeps: internal,
-    isPure,
-    hasTypeAnnotations: typed,
-    linesOfCode,
-    complexity,
-  };
-}
-
-/**
- * Computes cyclomatic complexity: counts decision points in the code.
- * CC = 1 + number of decision points (if, else if, for, while, case, catch, &&, ||, ?:)
- */
-export function computeCyclomaticComplexity(source: string, language: string): number {
-  // Remove comments and strings to avoid false positives
-  const cleaned = source
-    .replace(/\/\/.*$/gm, '')           // single-line comments
-    .replace(/\/\*[\s\S]*?\*\//g, '')   // multi-line comments
-    .replace(/#.*$/gm, '')              // Python comments
-    .replace(/(["'`])(?:(?!\1|\\).|\\.)*\1/g, '""'); // strings
-
-  let complexity = 1; // Base complexity
-
-  // Language-agnostic decision point patterns
-  const patterns = [
-    /\bif\b/g,
-    /\belse\s+if\b/g,
-    /\belif\b/g,
-    /\bfor\b/g,
-    /\bwhile\b/g,
-    /\bcase\b/g,
-    /\bcatch\b/g,
-    /\bexcept\b/g,
-    /&&/g,
-    /\|\|/g,
-    /\?\s*[^:]/g, // ternary operator (not type annotations)
-  ];
-
-  for (const pattern of patterns) {
-    const matches = cleaned.match(pattern);
-    if (matches) complexity += matches.length;
-  }
-
-  return complexity;
-}
-
-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 +0,0 @@
-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

@@ -1,129 +0,0 @@
-import type { CodeModuleRecord } from '../types/code.types.js';
-import { fingerprintCode } from './fingerprint.js';
-import { tokenize } from '../matching/tokenizer.js';
-import { cosineSimilarity } from '../matching/similarity.js';
-
-export interface CodeMatchResult {
-  moduleId: number;
-  score: number;
-  matchType: 'exact' | 'structural' | 'semantic' | 'vector';
-}
-
-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);
-}
-
-/**
- * Find matches using pre-computed vector embeddings.
- * Vector scores are computed externally (by the EmbeddingEngine) and passed in.
- */
-export function findVectorMatches(
-  vectorScores: Map<number, number>,
-  threshold: number = 0.5,
-): CodeMatchResult[] {
-  const results: CodeMatchResult[] = [];
-
-  for (const [moduleId, score] of vectorScores) {
-    if (score >= threshold) {
-      results.push({ moduleId, score, matchType: 'vector' });
-    }
-  }
-
-  return results.sort((a, b) => b.score - a.score);
-}
-
-/**
- * Hybrid search: combine structural + semantic + vector matches,
- * deduplicating and taking the highest score per module.
- */
-export function findHybridMatches(
-  source: string,
-  language: string,
-  description: string,
-  candidates: CodeModuleRecord[],
-  vectorScores?: Map<number, number>,
-): CodeMatchResult[] {
-  const scoreMap = new Map<number, CodeMatchResult>();
-
-  // Structural matches (highest priority)
-  for (const match of findStructuralMatches(source, language, candidates, 0.5)) {
-    const existing = scoreMap.get(match.moduleId);
-    if (!existing || match.score > existing.score) {
-      scoreMap.set(match.moduleId, match);
-    }
-  }
-
-  // Semantic matches
-  for (const match of findSemanticMatches(description, candidates, 0.3)) {
-    const existing = scoreMap.get(match.moduleId);
-    if (!existing || match.score > existing.score) {
-      scoreMap.set(match.moduleId, match);
-    }
-  }
-
-  // Vector matches (if available)
-  if (vectorScores && vectorScores.size > 0) {
-    for (const match of findVectorMatches(vectorScores, 0.4)) {
-      const existing = scoreMap.get(match.moduleId);
-      if (!existing) {
-        scoreMap.set(match.moduleId, match);
-      } else {
-        // Boost existing matches that also have high vector similarity
-        const vectorBoost = match.score * 0.15;
-        existing.score = Math.min(1.0, existing.score + vectorBoost);
-      }
-    }
-  }
-
-  return [...scoreMap.values()].sort((a, b) => b.score - a.score);
-}

package/src/code/parsers/generic.ts

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

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

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