@kodus/kodus-graph 0.2.8 → 0.2.10

package/src/resolver/languages/typescript.ts

@@ -1,168 +0,0 @@
-/**
- * TypeScript/JavaScript import resolver.
- *
- * Handles:
- * - Relative imports with extension probing (.ts, .tsx, .js, .jsx)
- * - ESM .js → .ts remapping
- * - Directory index files
- * - tsconfig path aliases
- */
-
-import { existsSync, readFileSync } from 'fs';
-import { dirname, join, resolve as resolvePath } from 'path';
-import { log } from '../../shared/logger';
-
-const TS_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
-
-/**
- * Resolve a TypeScript/JavaScript relative import to an absolute file path.
- * Returns null for non-relative (external package) imports.
- */
-export function resolve(fromAbsFile: string, modulePath: string, _repoRoot: string): string | null {
-  if (!modulePath.startsWith('.')) return null;
-
-  let base = join(dirname(fromAbsFile), modulePath);
-
-  // ESM convention: .js in import -> .ts on disk
-  if (modulePath.endsWith('.js')) base = base.slice(0, -3);
-
-  // Try direct with extension
-  for (const ext of TS_EXTENSIONS) {
-    const candidate = base + ext;
-    if (existsSync(candidate)) return resolvePath(candidate);
-  }
-
-  // Try index file in directory
-  for (const ext of TS_EXTENSIONS) {
-    const candidate = join(base, `index${ext}`);
-    if (existsSync(candidate)) return resolvePath(candidate);
-  }
-
-  return null;
-}
-
-/**
- * Strip comments and trailing commas from JSON (tsconfig-compatible).
- * Handles strings correctly -- won't strip // inside "url://..." etc.
- */
-function stripJsonComments(str: string): string {
-  let result = '';
-  let i = 0;
-  const len = str.length;
-
-  while (i < len) {
-    // String literal -- copy as-is
-    if (str[i] === '"') {
-      let j = i + 1;
-      while (j < len && str[j] !== '"') {
-        if (str[j] === '\\') j++; // skip escaped char
-        j++;
-      }
-      result += str.substring(i, j + 1);
-      i = j + 1;
-      continue;
-    }
-
-    // Single-line comment
-    if (str[i] === '/' && str[i + 1] === '/') {
-      while (i < len && str[i] !== '\n') i++;
-      continue;
-    }
-
-    // Block comment
-    if (str[i] === '/' && str[i + 1] === '*') {
-      i += 2;
-      while (i < len && !(str[i] === '*' && str[i + 1] === '/')) i++;
-      i += 2;
-      continue;
-    }
-
-    // Trailing comma: comma followed by optional whitespace + closing bracket
-    if (str[i] === ',') {
-      let j = i + 1;
-      while (j < len && (str[j] === ' ' || str[j] === '\t' || str[j] === '\n' || str[j] === '\r')) j++;
-      if (str[j] === '}' || str[j] === ']') {
-        i++;
-        continue;
-      }
-    }
-
-    result += str[i];
-    i++;
-  }
-
-  return result;
-}
-
-/**
- * Load and parse tsconfig.json path aliases.
- *
- * Tries tsconfig.json first, then tsconfig.base.json.
- * Converts alias patterns like "@libs/*" into prefix → resolved dirs.
- */
-export function loadTsconfigAliases(repoRoot: string): Map<string, string[]> {
-  const aliases = new Map<string, string[]>();
-
-  for (const filename of ['tsconfig.json', 'tsconfig.base.json']) {
-    const tsconfigPath = join(repoRoot, filename);
-    if (!existsSync(tsconfigPath)) continue;
-
-    try {
-      const content = readFileSync(tsconfigPath, 'utf-8');
-      const cleaned = stripJsonComments(content);
-      const config = JSON.parse(cleaned);
-      const paths = config?.compilerOptions?.paths;
-      const baseUrl = config?.compilerOptions?.baseUrl || '.';
-      const baseDir = join(repoRoot, baseUrl);
-
-      if (paths) {
-        for (const [alias, targets] of Object.entries(paths)) {
-          // Convert alias pattern: "@libs/*" -> prefix "@libs/"
-          const prefix = alias.replace('/*', '/').replace('*', '');
-          const resolvedTargets = (targets as string[]).map((t) => {
-            const targetPath = t.replace('/*', '').replace('*', '');
-            return join(baseDir, targetPath);
-          });
-          aliases.set(prefix, resolvedTargets);
-        }
-      }
-    } catch (err) {
-      log.warn('Failed to parse tsconfig', { file: tsconfigPath, error: String(err) });
-    }
-  }
-
-  return aliases;
-}
-
-/**
- * Resolve an import path using tsconfig aliases.
- *
- * Tries each alias prefix, and for matches, probes extensions and index files.
- */
-export function resolveWithAliases(
-  modulePath: string,
-  aliases: Map<string, string[]>,
-  _repoRoot: string,
-): string | null {
-  for (const [prefix, targets] of aliases) {
-    if (modulePath.startsWith(prefix)) {
-      const rest = modulePath.slice(prefix.length);
-
-      for (const targetBase of targets) {
-        const base = join(targetBase, rest);
-
-        for (const ext of TS_EXTENSIONS) {
-          if (existsSync(base + ext)) return resolvePath(base + ext);
-        }
-        for (const ext of TS_EXTENSIONS) {
-          const idx = join(base, `index${ext}`);
-          if (existsSync(idx)) return resolvePath(idx);
-        }
-        // Try exact match (for directories with index)
-        if (existsSync(base)) return resolvePath(base);
-      }
-    }
-  }
-
-  return null;
-}

package/src/resolver/re-export-resolver.ts

@@ -1,66 +0,0 @@
-/**
- * Re-export (barrel) resolver.
- *
- * Follows `export { X } from './module'` chains so that the import map
- * points to the file where the symbol is actually defined, not the
- * barrel index file.
- *
- * Without this, an import like `import { Foo } from '@lib'` resolves
- * to `@lib/index.ts`, but `Foo` is defined in `@lib/foo.ts`.
- * The call resolver can't find `Foo` in the barrel's symbol table and
- * falls to lower-confidence tiers.
- */
-
-import { relative, resolve } from 'path';
-import { resolveImport } from './import-resolver';
-
-interface RawReExport {
-  module: string;
-  file: string;
-  line: number;
-}
-
-/**
- * Build a map: barrel file (relative) → list of resolved re-export target files (relative).
- *
- * Follows one level of re-exports (covers >95% of real-world barrel patterns).
- */
-export function buildReExportMap(
-  reExports: RawReExport[],
-  repoDir: string,
-  tsconfigAliases?: Map<string, string[]>,
-): Map<string, string[]> {
-  const barrelMap = new Map<string, string[]>();
-
-  for (const re of reExports) {
-    const absFrom = resolve(repoDir, re.file);
-    const resolved = resolveImport(absFrom, re.module, 'typescript', repoDir, tsconfigAliases);
-    if (!resolved) continue;
-
-    const resolvedRel = relative(repoDir, resolved);
-    const list = barrelMap.get(re.file);
-    if (list) {
-      if (!list.includes(resolvedRel)) list.push(resolvedRel);
-    } else {
-      barrelMap.set(re.file, [resolvedRel]);
-    }
-  }
-
-  // Follow one extra level: if a re-export target is itself a barrel, flatten
-  for (const [barrel, targets] of barrelMap) {
-    const extra: string[] = [];
-    for (const target of targets) {
-      const nested = barrelMap.get(target);
-      if (nested) {
-        for (const n of nested) {
-          if (n !== barrel && !targets.includes(n) && !extra.includes(n)) {
-            extra.push(n);
-          }
-        }
-      }
-    }
-    if (extra.length > 0) targets.push(...extra);
-  }
-
-  return barrelMap;
-}

package/src/resolver/symbol-table.ts

@@ -1,67 +0,0 @@
-/**
- * Symbol table with dual-index lookup (GitNexus pattern).
- *
- * Provides both exact (file + name) and global (name-only) lookups.
- * The exact lookup is high-confidence; global lookup is lower-confidence
- * but useful when import resolution fails.
- */
-
-export interface SymbolTable {
-  add(file: string, name: string, qualified: string): void;
-  lookupExact(file: string, name: string): string | null;
-  lookupInFile(file: string, name: string, className: string): string | null;
-  isUnique(name: string): boolean;
-  lookupGlobal(name: string): string[];
-  readonly size: number;
-  readonly fileCount: number;
-}
-
-export function createSymbolTable(): SymbolTable {
-  const byFile = new Map<string, Map<string, string[]>>();
-  const byName = new Map<string, string[]>();
-
-  return {
-    add(file, name, qualified) {
-      if (!byFile.has(file)) byFile.set(file, new Map());
-      const fileMap = byFile.get(file)!;
-      if (!fileMap.has(name)) fileMap.set(name, []);
-      fileMap.get(name)!.push(qualified);
-
-      if (!byName.has(name)) byName.set(name, []);
-      byName.get(name)!.push(qualified);
-    },
-
-    lookupExact(file, name) {
-      const candidates = byFile.get(file)?.get(name);
-      if (!candidates || candidates.length === 0) return null;
-      // Only return if unambiguous within this file
-      return candidates.length === 1 ? candidates[0] : null;
-    },
-
-    lookupInFile(file, name, className) {
-      const candidates = byFile.get(file)?.get(name);
-      if (!candidates || candidates.length === 0) return null;
-      return candidates.find((q) => q.includes(`::${className}.${name}`)) ?? null;
-    },
-
-    isUnique(name) {
-      return (byName.get(name)?.length ?? 0) === 1;
-    },
-
-    lookupGlobal(name) {
-      return byName.get(name) ?? [];
-    },
-
-    get size() {
-      let count = 0;
-      for (const m of byFile.values()) {
-        for (const arr of m.values()) count += arr.length;
-      }
-      return count;
-    },
-
-    get fileCount() {
-      return byFile.size;
-    },
-  };
-}

package/src/shared/extract-calls.ts

@@ -1,75 +0,0 @@
-import type { SgNode } from '@ast-grep/napi';
-import type { RawCallSite } from '../graph/types';
-import { NOISE } from './filters';
-
-/**
- * Language-specific configuration for call extraction.
- * Each language provides its self/super patterns and how to find class context in the AST.
- */
-export interface CallExtractionConfig {
-  /** Prefixes indicating a self-reference (e.g., 'self.', 'this.') */
-  selfPrefixes: string[];
-  /** Prefixes indicating a super-reference (e.g., 'super().', 'super.', 'base.') */
-  superPrefixes: string[];
-  /** Find the enclosing class/module/impl node from a call site */
-  findEnclosingClass: (node: SgNode) => SgNode | null;
-  /** Extract the parent class name from a class node (for super resolution) */
-  getParentClass?: (classNode: SgNode) => string | undefined;
-  /** Skip this callee entirely (e.g., TS skips this.field.method — handled by DI) */
-  skipCallee?: (callee: string) => boolean;
-}
-
-/**
- * Shared call extraction for all languages.
- *
- * Parses `$CALLEE($$$ARGS)` pattern, detects self/super references
- * based on language config, and populates resolveInClass for
- * class-aware resolution downstream.
- */
-export function extractCalls(
-  rootNode: SgNode,
-  fp: string,
-  config: CallExtractionConfig,
-  calls: RawCallSite[],
-): void {
-  for (const m of rootNode.findAll('$CALLEE($$$ARGS)')) {
-    const callee = m.getMatch('CALLEE')?.text();
-    if (!callee) continue;
-    if (config.skipCallee?.(callee)) continue;
-
-    const callName = callee.includes('.') ? callee.split('.').pop()! : callee;
-    if (NOISE.has(callName)) continue;
-
-    let resolveInClass: string | undefined;
-
-    // Check self-reference: callee must be exactly `prefix + methodName` (no further chaining)
-    for (const prefix of config.selfPrefixes) {
-      if (!callee.startsWith(prefix)) continue;
-      const rest = callee.substring(prefix.length);
-      if (rest.includes('.')) break; // chained access (e.g., this.field.method) — not a self call
-      const classNode = config.findEnclosingClass(m);
-      resolveInClass = classNode?.field('name')?.text();
-      break;
-    }
-
-    // Check super-reference if no self match
-    if (!resolveInClass) {
-      for (const prefix of config.superPrefixes) {
-        const matches = callee === prefix || (callee.startsWith(prefix) && !callee.substring(prefix.length).includes('.'));
-        if (!matches) continue;
-        const classNode = config.findEnclosingClass(m);
-        if (classNode && config.getParentClass) {
-          resolveInClass = config.getParentClass(classNode);
-        }
-        break;
-      }
-    }
-
-    calls.push({
-      source: fp,
-      callName,
-      line: m.range().start.line,
-      ...(resolveInClass ? { resolveInClass } : {}),
-    });
-  }
-}

package/src/shared/file-hash.ts

@@ -1,12 +0,0 @@
-import { createHash } from 'crypto';
-import { readFileSync } from 'fs';
-
-export function computeFileHash(filePath: string): string {
-  const content = readFileSync(filePath);
-  return createHash('sha256').update(content).digest('hex');
-}
-
-/** Hash a node's source text (function body, class body, etc.) */
-export function computeContentHash(sourceText: string): string {
-  return createHash('sha256').update(sourceText).digest('hex');
-}

package/src/shared/filters.ts

@@ -1,243 +0,0 @@
-export const SKIP_DIRS = new Set([
-  'node_modules',
-  '.git',
-  'dist',
-  'build',
-  '.next',
-  'coverage',
-  'vendor',
-  '__pycache__',
-  '.venv',
-  'venv',
-  'target',
-  '.turbo',
-  '.cache',
-  '.output',
-  'out',
-  '.nuxt',
-  '.svelte-kit',
-  '.idea',
-  '.mypy_cache',
-  '.tox',
-  '.pytest_cache',
-  '.eggs',
-  'bower_components',
-]);
-
-/** File name patterns to skip during discovery (minified, bundled, vendored) */
-const SKIP_FILE_PATTERNS: RegExp[] = [
-  /\.min\.\w+$/, // *.min.js, *.min.css
-  /[.-]bundle\.\w+$/, // *.bundle.js, *-bundle.js
-  /\.chunk\.\w+$/, // *.chunk.js (webpack)
-  /\.packed\.\w+$/, // *.packed.js
-];
-
-export function isSkippableFile(fileName: string): boolean {
-  return SKIP_FILE_PATTERNS.some((p) => p.test(fileName));
-}
-
-export const NOISE = new Set([
-  // JS/TS builtins
-  'log',
-  'error',
-  'warn',
-  'info',
-  'debug',
-  'trace',
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'slice',
-  'map',
-  'filter',
-  'reduce',
-  'forEach',
-  'find',
-  'findIndex',
-  'some',
-  'every',
-  'flat',
-  'flatMap',
-  'sort',
-  'reverse',
-  'join',
-  'split',
-  'trim',
-  'replace',
-  'match',
-  'test',
-  'includes',
-  'indexOf',
-  'lastIndexOf',
-  'startsWith',
-  'endsWith',
-  'keys',
-  'values',
-  'entries',
-  'assign',
-  'freeze',
-  'create',
-  'stringify',
-  'parse',
-  'toString',
-  'toLowerCase',
-  'toUpperCase',
-  'concat',
-  'charAt',
-  'substring',
-  'parseInt',
-  'parseFloat',
-  'isNaN',
-  'isFinite',
-  'isArray',
-  'resolve',
-  'reject',
-  'all',
-  'allSettled',
-  'race',
-  'any',
-  'then',
-  'catch',
-  'finally',
-  'get',
-  'set',
-  'has',
-  'delete',
-  'clear',
-  'add',
-  'next',
-  'return',
-  'throw',
-  'setTimeout',
-  'clearTimeout',
-  'setInterval',
-  'clearInterval',
-  'require',
-  'length',
-  'call',
-  'apply',
-  'bind',
-  'createElement',
-  'useState',
-  'useEffect',
-  'useRef',
-  'useCallback',
-  'useMemo',
-  'useContext',
-  'useReducer',
-  'render',
-  // Test helpers
-  'expect',
-  'toBe',
-  'toEqual',
-  'toBeDefined',
-  'toBeNull',
-  'toBeUndefined',
-  'toBeTruthy',
-  'toBeFalsy',
-  'toContain',
-  'toHaveLength',
-  'toThrow',
-  'toHaveBeenCalled',
-  'toHaveBeenCalledWith',
-  'toMatchObject',
-  'toHaveBeenCalledTimes',
-  'toHaveProperty',
-  'describe',
-  'it',
-  'test',
-  'beforeEach',
-  'afterEach',
-  'beforeAll',
-  'afterAll',
-  'fn',
-  'spyOn',
-  'mock',
-  'mockResolvedValue',
-  'mockReturnValue',
-  'mockImplementation',
-  'mockReturnThis',
-  'now',
-  'toISOString',
-  'getTime',
-  // Globals
-  'console',
-  'Math',
-  'Date',
-  'JSON',
-  'Object',
-  'Array',
-  'String',
-  'Number',
-  'Boolean',
-  'Promise',
-  'Error',
-  'Map',
-  'Set',
-  'RegExp',
-  'Buffer',
-  'process',
-  // Python builtins
-  'print',
-  'len',
-  'range',
-  'enumerate',
-  'zip',
-  'isinstance',
-  'type',
-  'super',
-  'self',
-  'cls',
-  'None',
-  'True',
-  'False',
-  'append',
-  'extend',
-  'insert',
-  'remove',
-  'update',
-  'items',
-  'format',
-  'strip',
-  'upper',
-  'lower',
-  // Ruby builtins
-  'puts',
-  'raise',
-  'yield',
-  'each',
-  'do',
-  'end',
-  'attr_accessor',
-  'attr_reader',
-  'attr_writer',
-  'respond_to',
-  'render',
-  'redirect_to',
-  'before_action',
-  'after_action',
-  'validates',
-  'has_many',
-  'belongs_to',
-  'has_one',
-  'new',
-  'initialize',
-  // Go builtins
-  'fmt',
-  'Println',
-  'Printf',
-  'Sprintf',
-  'Errorf',
-  'make',
-  'panic',
-  'recover',
-  'defer',
-  // Java builtins
-  'System',
-  'println',
-  'equals',
-  'hashCode',
-  'getClass',
-]);

package/src/shared/logger.ts

@@ -1,17 +0,0 @@
-// src/shared/logger.ts
-export const log = {
-  info(msg: string, ctx?: Record<string, unknown>): void {
-    process.stderr.write(`[INFO] ${msg}${ctx ? ` ${JSON.stringify(ctx)}` : ''}\n`);
-  },
-  debug(msg: string, ctx?: Record<string, unknown>): void {
-    if (process.env.KODUS_GRAPH_DEBUG) {
-      process.stderr.write(`[DEBUG] ${msg}${ctx ? ` ${JSON.stringify(ctx)}` : ''}\n`);
-    }
-  },
-  warn(msg: string, ctx?: Record<string, unknown>): void {
-    process.stderr.write(`[WARN] ${msg}${ctx ? ` ${JSON.stringify(ctx)}` : ''}\n`);
-  },
-  error(msg: string, ctx?: Record<string, unknown>): void {
-    process.stderr.write(`[ERROR] ${msg}${ctx ? ` ${JSON.stringify(ctx)}` : ''}\n`);
-  },
-};

package/src/shared/qualified-name.ts

@@ -1,5 +0,0 @@
-export function qualifiedName(filePath: string, name: string, className?: string, isTest?: boolean): string {
-  if (isTest) return `${filePath}::test:${name}`;
-  if (className) return `${filePath}::${className}.${name}`;
-  return `${filePath}::${name}`;
-}

package/src/shared/safe-path.ts

@@ -1,31 +0,0 @@
-import { realpathSync } from 'fs';
-import { relative, resolve } from 'path';
-
-/**
- * Validate that a resolved path is within the repository root.
- * Returns the validated absolute path.
- * Throws if the path escapes the root.
- */
-export function ensureWithinRoot(filePath: string, repoRoot: string): string {
-  let absRoot: string;
-  try {
-    absRoot = realpathSync(resolve(repoRoot));
-  } catch {
-    absRoot = resolve(repoRoot);
-  }
-
-  let absPath: string;
-  try {
-    absPath = realpathSync(resolve(absRoot, filePath));
-  } catch {
-    // File doesn't exist yet or is unreadable — use resolve without symlink follow
-    absPath = resolve(absRoot, filePath);
-  }
-
-  const rel = relative(absRoot, absPath);
-  if (rel.startsWith('..') || resolve(absRoot, rel) !== absPath) {
-    throw new Error(`Path escapes repository root: ${filePath}`);
-  }
-
-  return absPath;
-}