@timmeck/brain 1.0.0 → 1.1.1

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;
+}

package/src/code/matcher.ts

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

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