@kodus/kodus-graph 0.2.8 → 0.2.10

package/dist/resolver/languages/ruby.js

@@ -0,0 +1,110 @@
+/**
+ * Ruby import resolver.
+ *
+ * Handles require_relative paths, Gemfile path: gems, and Zeitwerk autoload.
+ */
+import { readFileSync } from 'fs';
+import { dirname, join, resolve as resolvePath } from 'path';
+import { cachedExists } from '../fs-cache';
+/** 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 (cachedExists(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 (cachedExists(`${base}.rb`)) {
+        return resolvePath(`${base}.rb`);
+    }
+    if (cachedExists(base)) {
+        return resolvePath(base);
+    }
+    // 2. Try Gemfile path: gems
+    for (const libDir of getGemPathLibDirs(repoRoot)) {
+        const candidate = join(libDir, modulePath);
+        if (cachedExists(`${candidate}.rb`)) {
+            return resolvePath(`${candidate}.rb`);
+        }
+        if (cachedExists(candidate)) {
+            return resolvePath(candidate);
+        }
+    }
+    return null;
+}
+/** Common Rails autoload paths that Zeitwerk watches. */
+const ZEITWERK_AUTOLOAD_PATHS = [
+    'app/models',
+    'app/controllers',
+    'app/services',
+    'app/jobs',
+    'app/mailers',
+    'app/helpers',
+    'lib',
+];
+/**
+ * Convert a CamelCase segment to snake_case.
+ * E.g., "AuthService" → "auth_service", "UsersController" → "users_controller"
+ */
+function camelToSnake(name) {
+    return name
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+        .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+        .toLowerCase();
+}
+/**
+ * Resolve a Ruby class/module constant name to a file path using Zeitwerk conventions.
+ *
+ * Zeitwerk maps constant names to file paths:
+ *   - `User` → `user.rb`
+ *   - `AuthService` → `auth_service.rb`
+ *   - `Admin::UsersController` → `admin/users_controller.rb`
+ *
+ * This searches common Rails autoload paths for a matching file.
+ *
+ * @param className - The fully-qualified constant name (e.g., "Admin::UsersController")
+ * @param repoRoot  - The root of the repository / Rails project
+ * @returns Absolute path to the resolved file, or null if not found
+ */
+export function resolveZeitwerk(className, repoRoot) {
+    if (!className) {
+        return null;
+    }
+    // Split on :: and convert each segment from CamelCase to snake_case
+    const segments = className.split('::');
+    const relativePath = segments.map(camelToSnake).join('/');
+    // Search each autoload path
+    for (const autoloadPath of ZEITWERK_AUTOLOAD_PATHS) {
+        const candidate = join(repoRoot, autoloadPath, `${relativePath}.rb`);
+        if (cachedExists(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,197 @@
+import { readFileSync } from 'fs';
+import { basename, dirname, join, resolve as resolvePath } from 'path';
+import { cachedExists } from '../fs-cache';
+function probeRustPath(baseDir, relPath) {
+    const asFile = join(baseDir, `${relPath}.rs`);
+    if (cachedExists(asFile)) {
+        return resolvePath(asFile);
+    }
+    const asMod = join(baseDir, relPath, 'mod.rs');
+    if (cachedExists(asMod)) {
+        return resolvePath(asMod);
+    }
+    const asLib = join(baseDir, relPath, 'lib.rs');
+    if (cachedExists(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 (cachedExists(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 (!cachedExists(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 (!cachedExists(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,35 @@
+/**
+ * TypeScript/JavaScript import resolver.
+ *
+ * Handles:
+ * - Relative imports with extension probing (.ts, .tsx, .js, .jsx)
+ * - ESM .js → .ts remapping
+ * - Directory index files
+ * - tsconfig path aliases
+ */
+/**
+ * Load aliases from webpack.config.ts/js and vite.config.ts/js.
+ * These are NOT in tsconfig — many large projects use bundler aliases instead.
+ *
+ * Parses simple alias patterns from resolve.alias blocks.
+ * Returns Map<prefix, absoluteDir> — same format as tsconfig aliases.
+ */
+export declare function loadBundlerAliases(repoRoot: string): Map<string, string[]>;
+/**
+ * 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;