@kodus/kodus-graph 0.2.7 → 0.2.9

package/dist/resolver/languages/ruby.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Ruby import resolver.
+ *
+ * Handles require_relative paths and Gemfile path: gems.
+ */
+/**
+ * Resolve a Ruby require/require_relative to a file path.
+ */
+export declare function resolve(fromAbsFile: string, modulePath: string, repoRoot: string): string | null;

package/dist/resolver/languages/ruby.js

@@ -0,0 +1,59 @@
+/**
+ * Ruby import resolver.
+ *
+ * Handles require_relative paths and Gemfile path: gems.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join, resolve as resolvePath } from 'path';
+/** Cache parsed Gemfile path gems per repo root. */
+const gemfileCache = new Map();
+/**
+ * Parse Gemfile for path: gems and return their lib directories (absolute).
+ */
+function getGemPathLibDirs(repoRoot) {
+    if (gemfileCache.has(repoRoot)) {
+        return gemfileCache.get(repoRoot);
+    }
+    const gemfilePath = join(repoRoot, 'Gemfile');
+    const libDirs = [];
+    if (existsSync(gemfilePath)) {
+        const content = readFileSync(gemfilePath, 'utf-8');
+        // Match lines like: gem 'mylib', path: './libs/mylib'
+        const regex = /^\s*gem\s+['"][^'"]+['"]\s*,\s*path:\s*['"]([^'"]+)['"]/gm;
+        let match = regex.exec(content);
+        while (match !== null) {
+            const gemPath = match[1];
+            libDirs.push(resolvePath(join(repoRoot, gemPath, 'lib')));
+            match = regex.exec(content);
+        }
+    }
+    gemfileCache.set(repoRoot, libDirs);
+    return libDirs;
+}
+/**
+ * Resolve a Ruby require/require_relative to a file path.
+ */
+export function resolve(fromAbsFile, modulePath, repoRoot) {
+    if (!modulePath) {
+        return null;
+    }
+    // 1. Try relative resolution (require_relative style)
+    const base = join(dirname(fromAbsFile), modulePath);
+    if (existsSync(`${base}.rb`)) {
+        return resolvePath(`${base}.rb`);
+    }
+    if (existsSync(base)) {
+        return resolvePath(base);
+    }
+    // 2. Try Gemfile path: gems
+    for (const libDir of getGemPathLibDirs(repoRoot)) {
+        const candidate = join(libDir, modulePath);
+        if (existsSync(`${candidate}.rb`)) {
+            return resolvePath(`${candidate}.rb`);
+        }
+        if (existsSync(candidate)) {
+            return resolvePath(candidate);
+        }
+    }
+    return null;
+}

package/dist/resolver/languages/rust.d.ts

@@ -0,0 +1 @@
+export declare function resolve(fromAbsFile: string, modulePath: string, repoRoot: string): string | null;

package/dist/resolver/languages/rust.js

@@ -0,0 +1,196 @@
+import { existsSync, readFileSync } from 'fs';
+import { basename, dirname, join, resolve as resolvePath } from 'path';
+function probeRustPath(baseDir, relPath) {
+    const asFile = join(baseDir, `${relPath}.rs`);
+    if (existsSync(asFile)) {
+        return resolvePath(asFile);
+    }
+    const asMod = join(baseDir, relPath, 'mod.rs');
+    if (existsSync(asMod)) {
+        return resolvePath(asMod);
+    }
+    const asLib = join(baseDir, relPath, 'lib.rs');
+    if (existsSync(asLib)) {
+        return resolvePath(asLib);
+    }
+    return null;
+}
+export function resolve(fromAbsFile, modulePath, repoRoot) {
+    if (modulePath.startsWith('std::')) {
+        return null;
+    }
+    if (modulePath.startsWith('crate::')) {
+        const rest = modulePath.slice('crate::'.length).replace(/::/g, '/');
+        return probeRustPath(join(repoRoot, 'src'), rest);
+    }
+    if (modulePath.startsWith('super::')) {
+        const rest = modulePath.slice('super::'.length).replace(/::/g, '/');
+        const fileName = basename(fromAbsFile);
+        // mod.rs and lib.rs represent their parent directory, so super:: goes up two levels
+        const parentDir = fileName === 'mod.rs' || fileName === 'lib.rs' ? dirname(dirname(fromAbsFile)) : dirname(fromAbsFile);
+        return probeRustPath(parentDir, rest);
+    }
+    if (modulePath.startsWith('self::')) {
+        const rest = modulePath.slice('self::'.length).replace(/::/g, '/');
+        return probeRustPath(dirname(fromAbsFile), rest);
+    }
+    // Try workspace path dependency resolution
+    const firstSep = modulePath.indexOf('::');
+    if (firstSep !== -1) {
+        const crateName = modulePath.slice(0, firstSep);
+        const rest = modulePath.slice(firstSep + 2).replace(/::/g, '/');
+        const depPath = resolveWorkspacePathDep(fromAbsFile, crateName);
+        if (depPath) {
+            const srcDir = join(depPath, 'src');
+            // Try the full path first, then progressively strip trailing segments
+            // (they may be items like functions/structs inside a module file)
+            const segments = rest.split('/');
+            for (let i = segments.length; i >= 1; i--) {
+                const partial = segments.slice(0, i).join('/');
+                const result = probeRustPath(srcDir, partial);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        // bin+lib same crate: if the first segment matches the local [package] name,
+        // treat it like a crate:: import (resolve from src/)
+        const localPkgName = findLocalPackageName(fromAbsFile);
+        if (localPkgName && crateName === localPkgName) {
+            const srcDir = join(findCrateDir(fromAbsFile), 'src');
+            const segments = rest.split('/');
+            for (let i = segments.length; i >= 1; i--) {
+                const partial = segments.slice(0, i).join('/');
+                const result = probeRustPath(srcDir, partial);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+    }
+    return null;
+}
+/** Cache: crate dir → parsed {depName → resolved absolute path} */
+const pathDepCache = new Map();
+/**
+ * Walk up from `fromAbsFile` to find the nearest Cargo.toml,
+ * parse its [dependencies] for `path = "..."` entries,
+ * and return the absolute path of the dependency crate if it matches `depName`.
+ */
+function resolveWorkspacePathDep(fromAbsFile, depName) {
+    const crateDir = findCrateDir(fromAbsFile);
+    if (!crateDir) {
+        return null;
+    }
+    let deps = pathDepCache.get(crateDir);
+    if (!deps) {
+        deps = parsePathDeps(crateDir);
+        pathDepCache.set(crateDir, deps);
+    }
+    return deps.get(depName) ?? null;
+}
+/**
+ * Walk up from a file to find the nearest directory containing Cargo.toml.
+ */
+function findCrateDir(fromAbsFile) {
+    let dir = dirname(fromAbsFile);
+    const root = resolvePath('/');
+    while (dir !== root) {
+        if (existsSync(join(dir, 'Cargo.toml'))) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return null;
+}
+/** Cache: crate dir → parsed package name */
+const pkgNameCache = new Map();
+/**
+ * Find the [package] name from the nearest Cargo.toml for the given file.
+ * Used to detect bin+lib same-crate imports (e.g. `use myapp::foo` from main.rs).
+ */
+function findLocalPackageName(fromAbsFile) {
+    const crateDir = findCrateDir(fromAbsFile);
+    if (!crateDir) {
+        return null;
+    }
+    const cached = pkgNameCache.get(crateDir);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const cargoPath = join(crateDir, 'Cargo.toml');
+    if (!existsSync(cargoPath)) {
+        pkgNameCache.set(crateDir, null);
+        return null;
+    }
+    const content = readFileSync(cargoPath, 'utf-8');
+    const match = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
+    // Cargo crate names use hyphens but Rust imports use underscores
+    const name = match ? match[1].replace(/-/g, '_') : null;
+    pkgNameCache.set(crateDir, name);
+    return name;
+}
+/**
+ * Parse Cargo.toml in `crateDir` for path dependencies.
+ * Returns a map of dependency name → resolved absolute directory.
+ *
+ * Handles both inline table and multi-line table forms:
+ *   shared = { path = "../shared" }
+ *   [dependencies.shared]
+ *   path = "../shared"
+ */
+function parsePathDeps(crateDir) {
+    const result = new Map();
+    const cargoPath = join(crateDir, 'Cargo.toml');
+    if (!existsSync(cargoPath)) {
+        return result;
+    }
+    const content = readFileSync(cargoPath, 'utf-8');
+    const lines = content.split('\n');
+    let inDepsSection = false;
+    let depsTableDep = null; // for [dependencies.foo] style
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Detect section headers
+        if (trimmed.startsWith('[')) {
+            // Check for [dependencies.foo] form
+            const subMatch = trimmed.match(/^\[dependencies\.(\S+)\]$/);
+            if (subMatch) {
+                depsTableDep = subMatch[1];
+                inDepsSection = false;
+                continue;
+            }
+            depsTableDep = null;
+            if (trimmed === '[dependencies]') {
+                inDepsSection = true;
+                continue;
+            }
+            // Any other section header ends [dependencies]
+            inDepsSection = false;
+            continue;
+        }
+        // Inside [dependencies.foo], look for path = "..."
+        if (depsTableDep) {
+            const pathMatch = trimmed.match(/^path\s*=\s*"([^"]+)"/);
+            if (pathMatch) {
+                const resolved = resolvePath(crateDir, pathMatch[1]);
+                result.set(depsTableDep, resolved);
+            }
+            continue;
+        }
+        // Inside [dependencies], look for inline table with path
+        if (inDepsSection && trimmed.length > 0 && !trimmed.startsWith('#')) {
+            // name = { path = "..." ... }
+            const inlineMatch = trimmed.match(/^(\S+)\s*=\s*\{[^}]*path\s*=\s*"([^"]+)"[^}]*\}/);
+            if (inlineMatch) {
+                const resolved = resolvePath(crateDir, inlineMatch[2]);
+                result.set(inlineMatch[1], resolved);
+            }
+        }
+    }
+    return result;
+}

package/dist/resolver/languages/typescript.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TypeScript/JavaScript import resolver.
+ *
+ * Handles:
+ * - Relative imports with extension probing (.ts, .tsx, .js, .jsx)
+ * - ESM .js → .ts remapping
+ * - Directory index files
+ * - tsconfig path aliases
+ */
+/**
+ * Resolve a TypeScript/JavaScript relative import to an absolute file path.
+ * Returns null for non-relative (external package) imports.
+ */
+export declare function resolve(fromAbsFile: string, modulePath: string, repoRoot: string): string | null;
+/**
+ * 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 declare function loadTsconfigAliases(repoRoot: string): Map<string, string[]>;
+/**
+ * Resolve an import path using tsconfig aliases.
+ *
+ * Tries each alias prefix, and for matches, probes extensions and index files.
+ */
+export declare function resolveWithAliases(modulePath: string, aliases: Map<string, string[]>, _repoRoot: string): string | null;

package/dist/resolver/languages/typescript.js

@@ -0,0 +1,240 @@
+/**
+ * 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'];
+/**
+ * Probe a base path for TS/JS files: try extensions, then index files.
+ * Returns the resolved absolute path or null.
+ */
+function probeExtensions(base) {
+    for (const ext of TS_EXTENSIONS) {
+        const candidate = base + ext;
+        if (existsSync(candidate)) {
+            return resolvePath(candidate);
+        }
+    }
+    for (const ext of TS_EXTENSIONS) {
+        const candidate = join(base, `index${ext}`);
+        if (existsSync(candidate)) {
+            return resolvePath(candidate);
+        }
+    }
+    return null;
+}
+/** Cache for parsed tsconfig.json (keyed by repoRoot). */
+const tsconfigCache = new Map();
+function loadTsconfigCompilerOptions(repoRoot) {
+    const cached = tsconfigCache.get(repoRoot);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const tsconfigPath = join(repoRoot, 'tsconfig.json');
+    let result = {};
+    if (existsSync(tsconfigPath)) {
+        try {
+            const content = readFileSync(tsconfigPath, 'utf-8');
+            const cleaned = stripJsonComments(content);
+            const config = JSON.parse(cleaned);
+            const rootDirs = config?.compilerOptions?.rootDirs;
+            if (Array.isArray(rootDirs)) {
+                result = { rootDirs };
+            }
+        }
+        catch {
+            // ignore parse errors
+        }
+    }
+    tsconfigCache.set(repoRoot, result);
+    return result;
+}
+/**
+ * Resolve a TypeScript/JavaScript relative import to an absolute file path.
+ * Returns null for non-relative (external package) imports.
+ */
+export function resolve(fromAbsFile, modulePath, repoRoot) {
+    // Strip Vite-style query suffixes (?raw, ?url, ?worker, etc.)
+    const queryIdx = modulePath.indexOf('?');
+    if (queryIdx !== -1) {
+        modulePath = modulePath.slice(0, queryIdx);
+    }
+    if (!modulePath.startsWith('.')) {
+        return null;
+    }
+    let base = join(dirname(fromAbsFile), modulePath);
+    // If the path has a non-TS/JS extension (e.g. .txt, .svg), try exact match
+    if (/\.\w+$/.test(modulePath) && !TS_EXTENSIONS.some((ext) => modulePath.endsWith(ext))) {
+        if (existsSync(base)) {
+            return resolvePath(base);
+        }
+    }
+    // ESM convention: .js in import -> .ts on disk
+    if (modulePath.endsWith('.js')) {
+        base = base.slice(0, -3);
+    }
+    const direct = probeExtensions(base);
+    if (direct) {
+        return direct;
+    }
+    // rootDirs fallback: try the same relative import from other root directories
+    const { rootDirs } = loadTsconfigCompilerOptions(repoRoot);
+    if (rootDirs && rootDirs.length > 0) {
+        const fromDir = dirname(fromAbsFile);
+        for (const rd of rootDirs) {
+            const absRd = resolvePath(repoRoot, rd);
+            // Check if fromDir is inside this rootDir
+            if (fromDir.startsWith(`${absRd}/`) || fromDir === absRd) {
+                const relFromRoot = fromDir.slice(absRd.length); // e.g. "" or "/sub"
+                // Try the same relative path under each other rootDir
+                for (const otherRd of rootDirs) {
+                    if (otherRd === rd) {
+                        continue;
+                    }
+                    const absOtherRd = resolvePath(repoRoot, otherRd);
+                    const relModule = modulePath.startsWith('./') ? modulePath.slice(2) : modulePath;
+                    let otherBase = join(absOtherRd, relFromRoot, relModule);
+                    if (modulePath.endsWith('.js')) {
+                        otherBase = otherBase.slice(0, -3);
+                    }
+                    const result = probeExtensions(otherBase);
+                    if (result) {
+                        return result;
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Strip comments and trailing commas from JSON (tsconfig-compatible).
+ * Handles strings correctly -- won't strip // inside "url://..." etc.
+ */
+function stripJsonComments(str) {
+    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) {
+    const aliases = new Map();
+    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.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, aliases, _repoRoot) {
+    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/dist/resolver/re-export-resolver.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+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 declare function buildReExportMap(reExports: RawReExport[], repoDir: string, tsconfigAliases?: Map<string, string[]>): Map<string, string[]>;
+export {};

package/dist/resolver/re-export-resolver.js

@@ -0,0 +1,57 @@
+/**
+ * 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';
+/**
+ * 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, repoDir, tsconfigAliases) {
+    const barrelMap = new Map();
+    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 = [];
+        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/dist/resolver/symbol-table.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 declare function createSymbolTable(): SymbolTable;