@kodus/kodus-graph 0.2.8 → 0.2.10

package/src/parser/languages.ts

@@ -1,122 +0,0 @@
-import csharp from '@ast-grep/lang-csharp';
-import go from '@ast-grep/lang-go';
-import java from '@ast-grep/lang-java';
-import php from '@ast-grep/lang-php';
-import python from '@ast-grep/lang-python';
-import ruby from '@ast-grep/lang-ruby';
-import rust from '@ast-grep/lang-rust';
-import { Lang, registerDynamicLanguage } from '@ast-grep/napi';
-
-// Register dynamic languages at import time (side effect).
-// This must happen before parseAsync can parse these languages.
-registerDynamicLanguage({ python, ruby, go, java, rust, php, csharp });
-
-// Extension -> language identifier
-// Built-in langs use Lang enum, dynamic langs use lowercase string
-const EXT_TO_LANG: Record<string, Lang | string> = {
-  '.ts': Lang.TypeScript,
-  '.tsx': Lang.Tsx,
-  '.js': Lang.JavaScript,
-  '.jsx': Lang.JavaScript,
-  '.mjs': Lang.JavaScript,
-  '.cjs': Lang.JavaScript,
-  '.py': 'python',
-  '.rb': 'ruby',
-  '.go': 'go',
-  '.java': 'java',
-  '.rs': 'rust',
-  '.cs': 'csharp',
-  '.php': 'php',
-};
-
-export function getLanguage(ext: string): Lang | string | null {
-  return EXT_TO_LANG[ext] ?? null;
-}
-
-export function getSupportedExtensions(): string[] {
-  return Object.keys(EXT_TO_LANG);
-}
-
-export function getLanguageName(lang: Lang | string): string {
-  if (typeof lang === 'string') return lang;
-  if (lang === Lang.TypeScript || lang === Lang.Tsx) return 'typescript';
-  if (lang === Lang.JavaScript) return 'javascript';
-  return 'unknown';
-}
-
-export function isTypeScriptLike(lang: Lang | string): boolean {
-  return lang === Lang.TypeScript || lang === Lang.Tsx || lang === Lang.JavaScript;
-}
-
-// AST node kinds per language for structural extraction
-export const LANG_KINDS: Record<string, Record<string, string>> = {
-  typescript: {
-    class: 'class_declaration',
-    abstractClass: 'abstract_class_declaration',
-    method: 'method_definition',
-    function: 'function_declaration',
-    arrowContainer: 'variable_declarator',
-    arrowFunction: 'arrow_function',
-    interface: 'interface_declaration',
-    enum: 'enum_declaration',
-    import: 'import_statement',
-    export: 'export_statement',
-    methodSignature: 'method_signature',
-  },
-  python: {
-    class: 'class_definition',
-    method: 'function_definition',
-    function: 'function_definition',
-    import: 'import_from_statement',
-    importRegular: 'import_statement',
-    decorator: 'decorator',
-  },
-  ruby: {
-    class: 'class',
-    method: 'method',
-    singletonMethod: 'singleton_method',
-    module: 'module',
-    call: 'call',
-  },
-  go: {
-    function: 'function_declaration',
-    method: 'method_declaration',
-    struct: 'type_declaration',
-    interface: 'type_declaration',
-    import: 'import_declaration',
-  },
-  java: {
-    class: 'class_declaration',
-    interface: 'interface_declaration',
-    method: 'method_declaration',
-    constructor: 'constructor_declaration',
-    import: 'import_declaration',
-    enum: 'enum_declaration',
-  },
-  rust: {
-    function: 'function_item',
-    struct: 'struct_item',
-    impl: 'impl_item',
-    trait: 'trait_item',
-    enum: 'enum_item',
-    use: 'use_declaration',
-  },
-  csharp: {
-    class: 'class_declaration',
-    interface: 'interface_declaration',
-    method: 'method_declaration',
-    constructor: 'constructor_declaration',
-    using: 'using_directive',
-    enum: 'enum_declaration',
-    namespace: 'namespace_declaration',
-  },
-  php: {
-    class: 'class_declaration',
-    method: 'method_declaration',
-    function: 'function_definition',
-    namespace: 'namespace_definition',
-    use: 'namespace_use_declaration',
-  },
-};
-
-export { Lang };

package/src/resolver/call-resolver.ts

@@ -1,244 +0,0 @@
-/**
- * Call resolution with 5-tier confidence cascade.
- *
- * Cascade: DI (0.90-0.95) → same-file (0.85) → import-resolved (0.70-0.90)
- *        → unique-name (0.50) → ambiguous (0.30)
- *
- * Pure resolution logic — no file I/O, no parsing.
- * Raw call sites are provided by the batch parser.
- */
-
-import type { RawCallEdge, RawCallSite } from '../graph/types';
-import { NOISE } from '../shared/filters';
-import type { ImportMap } from './import-map';
-import type { SymbolTable } from './symbol-table';
-
-// ── Types ──
-
-interface ResolveResult {
-  target: string;
-  confidence: number;
-  strategy: 'di' | 'same' | 'import' | 'unique' | 'ambiguous';
-}
-
-interface CallResolverStats {
-  di: number;
-  same: number;
-  import: number;
-  unique: number;
-  ambiguous: number;
-  noise: number;
-}
-
-interface ResolveAllResult {
-  callEdges: RawCallEdge[];
-  stats: CallResolverStats;
-}
-
-// ── Batch resolution (pure, no I/O) ──
-
-/**
- * Resolve all raw call sites via the 5-tier cascade.
- *
- * Accepts pre-extracted RawCallSite[] from the batch parser.
- * No file reads, no parseAsync — pure iteration + lookup.
- */
-export function resolveAllCalls(
-  rawCalls: RawCallSite[],
-  diMaps: Map<string, Map<string, string>>,
-  symbolTable: SymbolTable,
-  importMap: ImportMap,
-): ResolveAllResult {
-  const callEdges: RawCallEdge[] = [];
-  const stats: CallResolverStats = { di: 0, same: 0, import: 0, unique: 0, ambiguous: 0, noise: 0 };
-
-  for (const call of rawCalls) {
-    if (NOISE.has(call.callName)) {
-      stats.noise++;
-      continue;
-    }
-
-    const fp = call.source;
-    const diMap = diMaps.get(fp);
-
-    // Try DI resolution first if diField is present
-    if (call.diField) {
-      const resolved = resolveDICall(call.diField, call.callName, fp, diMap, symbolTable);
-      if (resolved) {
-        callEdges.push({
-          source: fp,
-          target: resolved.target,
-          callName: call.callName,
-          line: call.line,
-          confidence: resolved.confidence,
-        });
-        stats.di++;
-        continue;
-      }
-    }
-
-    // Class-aware resolution for self.X() and super().X()
-    if (call.resolveInClass) {
-      const classResolved = resolveInClass(call.callName, fp, call.resolveInClass, symbolTable);
-      if (classResolved) {
-        callEdges.push({
-          source: fp,
-          target: classResolved.target,
-          callName: call.callName,
-          line: call.line,
-          confidence: classResolved.confidence,
-        });
-        stats[classResolved.strategy]++;
-        continue;
-      }
-    }
-
-    // Name-based cascade fallback
-    const resolved = resolveByName(call.callName, fp, symbolTable, importMap);
-    if (resolved) {
-      callEdges.push({
-        source: fp,
-        target: resolved.target,
-        callName: call.callName,
-        line: call.line,
-        confidence: resolved.confidence,
-      });
-      stats[resolved.strategy]++;
-    }
-  }
-
-  return { callEdges, stats };
-}
-
-// ── Class-aware resolution (self./super.) ──
-
-function resolveInClass(
-  callName: string,
-  currentFile: string,
-  className: string,
-  symbolTable: SymbolTable,
-): ResolveResult | null {
-  // Try same-file class method first (self.method() or super().method())
-  const inFile = symbolTable.lookupInFile(currentFile, callName, className);
-  if (inFile) return { target: inFile, confidence: 0.9, strategy: 'same' };
-
-  // Class might be in another file (imported parent class for super())
-  const candidates = symbolTable.lookupGlobal(callName);
-  const match = candidates.find((q) => q.includes(`::${className}.${callName}`));
-  if (match) return { target: match, confidence: 0.85, strategy: 'import' };
-
-  return null;
-}
-
-// ── DI resolution ──
-
-function resolveDICall(
-  fieldName: string,
-  methodName: string,
-  _currentFile: string,
-  diMap: Map<string, string> | undefined,
-  symbolTable: SymbolTable,
-): ResolveResult | null {
-  if (!diMap?.has(fieldName)) return null;
-
-  const typeName = diMap.get(fieldName)!;
-
-  // Direct class match
-  const candidates = symbolTable.lookupGlobal(typeName);
-  if (candidates.length >= 1) {
-    const typeFile = candidates[0].split('::')[0];
-    return { target: `${typeFile}::${typeName}.${methodName}`, confidence: 0.95, strategy: 'di' };
-  }
-
-  // ISomething → Something heuristic for interface → implementation
-  if (typeName.startsWith('I') && typeName[1] === typeName[1]?.toUpperCase()) {
-    const implName = typeName.substring(1);
-    const implCandidates = symbolTable.lookupGlobal(implName);
-    if (implCandidates.length >= 1) {
-      const implFile = implCandidates[0].split('::')[0];
-      return { target: `${implFile}::${implName}.${methodName}`, confidence: 0.9, strategy: 'di' };
-    }
-  }
-
-  return null;
-}
-
-// ── Name-based resolution (4-tier cascade) ──
-
-function resolveByName(
-  callName: string,
-  currentFile: string,
-  symbolTable: SymbolTable,
-  importMap: ImportMap,
-): ResolveResult | null {
-  // Strategy 1: Same file (0.85)
-  const sameFile = symbolTable.lookupExact(currentFile, callName);
-  if (sameFile) return { target: sameFile, confidence: 0.85, strategy: 'same' };
-
-  // Strategy 2: Import-resolved (0.70-0.90)
-  const importedFrom = importMap.lookup(currentFile, callName);
-  if (importedFrom) {
-    const targetSym = symbolTable.lookupExact(importedFrom, callName);
-    if (targetSym) return { target: targetSym, confidence: 0.9, strategy: 'import' };
-    return { target: `${importedFrom}::${callName}`, confidence: 0.7, strategy: 'import' };
-  }
-
-  // Strategy 3: Unique global name (0.50)
-  if (symbolTable.isUnique(callName)) {
-    const candidates = symbolTable.lookupGlobal(callName);
-    return { target: candidates[0], confidence: 0.5, strategy: 'unique' };
-  }
-
-  // Strategy 4: Ambiguous (0.30) — pick closest candidate by directory proximity
-  const candidates = symbolTable.lookupGlobal(callName);
-  if (candidates.length > 1) {
-    const best = pickClosestCandidate(candidates, currentFile);
-    return { target: best, confidence: 0.3, strategy: 'ambiguous' };
-  }
-
-  return null;
-}
-
-// ── Proximity-based candidate selection ──
-
-/**
- * Pick the candidate whose file path is closest to the caller's file.
- * Counts shared leading path segments — more shared = closer.
- */
-function pickClosestCandidate(candidates: string[], callerFile: string): string {
-  const callerParts = callerFile.split('/');
-  let best = candidates[0];
-  let bestScore = -1;
-
-  for (const candidate of candidates) {
-    const candidateFile = candidate.includes('::') ? candidate.split('::')[0] : candidate;
-    const parts = candidateFile.split('/');
-    let shared = 0;
-    for (let i = 0; i < Math.min(callerParts.length, parts.length); i++) {
-      if (callerParts[i] === parts[i]) shared++;
-      else break;
-    }
-    if (shared > bestScore) {
-      bestScore = shared;
-      best = candidate;
-    }
-  }
-
-  return best;
-}
-
-// ── Public wrapper for unit testing ──
-
-export function resolveCall(
-  callName: string,
-  currentFile: string,
-  symbolTable: SymbolTable,
-  importMap: ImportMap,
-): { target: string; confidence: number } | null {
-  if (NOISE.has(callName)) return null;
-
-  const result = resolveByName(callName, currentFile, symbolTable, importMap);
-  if (!result) return null;
-
-  return { target: result.target, confidence: result.confidence };
-}

package/src/resolver/import-map.ts

@@ -1,27 +0,0 @@
-/**
- * Import map: tracks which symbols are imported from where per file.
- *
- * For each importing file, maps symbol names to the resolved file path
- * they were imported from. Used by the call resolver to connect
- * function calls to their definitions across files.
- */
-
-export interface ImportMap {
-  add(file: string, name: string, targetFile: string): void;
-  lookup(file: string, name: string): string | null;
-}
-
-export function createImportMap(): ImportMap {
-  const map = new Map<string, Map<string, string>>();
-
-  return {
-    add(file, name, targetFile) {
-      if (!map.has(file)) map.set(file, new Map());
-      map.get(file)!.set(name, targetFile);
-    },
-
-    lookup(file, name) {
-      return map.get(file)?.get(name) ?? null;
-    },
-  };
-}

package/src/resolver/import-resolver.ts

@@ -1,72 +0,0 @@
-/**
- * Import resolver dispatcher.
- *
- * Routes import resolution to language-specific resolvers and
- * falls back to tsconfig aliases for TypeScript/JavaScript.
- */
-
-import { log } from '../shared/logger';
-import { ensureWithinRoot } from '../shared/safe-path';
-import { resolve as resolveCsImport } from './languages/csharp';
-import { resolve as resolveGoImport } from './languages/go';
-import { resolve as resolveJavaImport } from './languages/java';
-import { resolve as resolvePhpImport } from './languages/php';
-import { resolve as resolvePyImport } from './languages/python';
-import { resolve as resolveRbImport } from './languages/ruby';
-import { resolve as resolveRustImport } from './languages/rust';
-import { loadTsconfigAliases, resolve as resolveTsImport, resolveWithAliases } from './languages/typescript';
-
-const RESOLVERS: Record<string, (from: string, mod: string, root: string) => string | null> = {
-  ts: resolveTsImport,
-  javascript: resolveTsImport,
-  typescript: resolveTsImport,
-  python: resolvePyImport,
-  ruby: resolveRbImport,
-  go: resolveGoImport,
-  java: resolveJavaImport,
-  rust: resolveRustImport,
-  csharp: resolveCsImport,
-  php: resolvePhpImport,
-};
-
-/**
- * Resolve an import from one file to another.
- *
- * @param fromAbsFile - Absolute path of the importing file
- * @param modulePath - The import specifier (e.g., './auth', 'express', '@/lib/db')
- * @param lang - Language key (ts, javascript, typescript, python, ruby, etc.)
- * @param repoRoot - Absolute path to the repository root
- * @param tsconfigAliases - Optional pre-loaded tsconfig aliases for TS/JS
- * @returns Absolute path to the resolved file, or null if unresolvable
- */
-export function resolveImport(
-  fromAbsFile: string,
-  modulePath: string,
-  lang: string,
-  repoRoot: string,
-  tsconfigAliases?: Map<string, string[]>,
-): string | null {
-  const resolver = RESOLVERS[lang];
-  if (!resolver) return null;
-
-  let result = resolver(fromAbsFile, modulePath, repoRoot);
-
-  // Fallback: tsconfig aliases for TS/JS
-  if (!result && (lang === 'ts' || lang === 'javascript' || lang === 'typescript') && tsconfigAliases?.size) {
-    result = resolveWithAliases(modulePath, tsconfigAliases, repoRoot);
-  }
-
-  // Validate resolved path is within repo root
-  if (result) {
-    try {
-      ensureWithinRoot(result, repoRoot);
-    } catch {
-      log.warn('Import resolves outside repository root', { from: fromAbsFile, module: modulePath, resolved: result });
-      return null;
-    }
-  }
-
-  return result;
-}
-
-export { loadTsconfigAliases };

package/src/resolver/languages/csharp.ts

@@ -1,7 +0,0 @@
-/**
- * C# import resolver (stub).
- */
-
-export function resolve(_fromAbsFile: string, _modulePath: string, _repoRoot: string): string | null {
-  return null;
-}

package/src/resolver/languages/go.ts

@@ -1,7 +0,0 @@
-/**
- * Go import resolver (stub).
- */
-
-export function resolve(_fromAbsFile: string, _modulePath: string, _repoRoot: string): string | null {
-  return null;
-}

package/src/resolver/languages/java.ts

@@ -1,7 +0,0 @@
-/**
- * Java import resolver (stub).
- */
-
-export function resolve(_fromAbsFile: string, _modulePath: string, _repoRoot: string): string | null {
-  return null;
-}

package/src/resolver/languages/php.ts

@@ -1,7 +0,0 @@
-/**
- * PHP import resolver (stub).
- */
-
-export function resolve(_fromAbsFile: string, _modulePath: string, _repoRoot: string): string | null {
-  return null;
-}

package/src/resolver/languages/python.ts

@@ -1,35 +0,0 @@
-/**
- * Python import resolver.
- *
- * Handles dotted module paths (e.g., "from x.y import z").
- * Walks up directories to find packages.
- */
-
-import { existsSync } from 'fs';
-import { dirname, join, resolve as resolvePath } from 'path';
-
-/**
- * Resolve a Python dotted import to a file path.
- * Walks up from the importing file's directory to find the module.
- */
-export function resolve(fromAbsFile: string, modulePath: string, _repoRoot: string): string | null {
-  if (!modulePath || modulePath.startsWith('.')) {
-    // Relative import -- not handled yet
-    return null;
-  }
-
-  const parts = modulePath.replace(/\./g, '/');
-  let current = dirname(fromAbsFile);
-
-  for (let i = 0; i < 10; i++) {
-    for (const candidate of [`${parts}.py`, `${parts}/__init__.py`]) {
-      const full = join(current, candidate);
-      if (existsSync(full)) return resolvePath(full);
-    }
-    const parent = dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-
-  return null;
-}

package/src/resolver/languages/ruby.ts

@@ -1,21 +0,0 @@
-/**
- * Ruby import resolver.
- *
- * Handles require_relative paths.
- */
-
-import { existsSync } from 'fs';
-import { dirname, join, resolve as resolvePath } from 'path';
-
-/**
- * Resolve a Ruby require/require_relative to a file path.
- */
-export function resolve(fromAbsFile: string, modulePath: string, _repoRoot: string): string | null {
-  if (!modulePath) return null;
-
-  const base = join(dirname(fromAbsFile), modulePath);
-  if (existsSync(`${base}.rb`)) return resolvePath(`${base}.rb`);
-  if (existsSync(base)) return resolvePath(base);
-
-  return null;
-}

package/src/resolver/languages/rust.ts

@@ -1,7 +0,0 @@
-/**
- * Rust import resolver (stub).
- */
-
-export function resolve(_fromAbsFile: string, _modulePath: string, _repoRoot: string): string | null {
-  return null;
-}