@kodus/kodus-graph 0.2.8 → 0.2.10

package/dist/resolver/languages/go.js

@@ -0,0 +1,197 @@
+import { readFileSync } from 'fs';
+import { join, resolve as resolvePath } from 'path';
+import { cachedExists, cachedReaddir } from '../fs-cache';
+const moduleCache = new Map();
+const replaceCache = new Map();
+const workspaceCache = new Map();
+/** Clear cached go.mod data. Call between analysis runs or when switching repos. */
+export function clearCache() {
+    moduleCache.clear();
+    replaceCache.clear();
+    workspaceCache.clear();
+}
+function getModuleName(repoRoot) {
+    const cached = moduleCache.get(repoRoot);
+    if (cached !== undefined) {
+        return cached || null;
+    }
+    const goModPath = join(repoRoot, 'go.mod');
+    if (!cachedExists(goModPath)) {
+        moduleCache.set(repoRoot, '');
+        return null;
+    }
+    try {
+        const content = readFileSync(goModPath, 'utf-8');
+        const match = content.match(/^module\s+(\S+)/m);
+        if (match) {
+            moduleCache.set(repoRoot, match[1]);
+            return match[1];
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    moduleCache.set(repoRoot, '');
+    return null;
+}
+/** Parse replace directives from go.mod. Returns map: module path → local directory (absolute). */
+function getReplaceMap(repoRoot) {
+    const cached = replaceCache.get(repoRoot);
+    if (cached) {
+        return cached;
+    }
+    const result = new Map();
+    const goModPath = join(repoRoot, 'go.mod');
+    if (!cachedExists(goModPath)) {
+        replaceCache.set(repoRoot, result);
+        return result;
+    }
+    try {
+        const content = readFileSync(goModPath, 'utf-8');
+        // Match single-line replace: replace mod => ./path  or  replace mod v1.2.3 => ./path
+        const replaceRe = /^replace\s+(\S+)(?:\s+\S+)?\s+=>\s+(\S+)/gm;
+        let m = replaceRe.exec(content);
+        while (m !== null) {
+            const modPath = m[1];
+            const replacement = m[2];
+            if (replacement.startsWith('./') || replacement.startsWith('../')) {
+                result.set(modPath, resolvePath(join(repoRoot, replacement)));
+            }
+            m = replaceRe.exec(content);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    replaceCache.set(repoRoot, result);
+    return result;
+}
+/** Parse go.work use directives. Returns map: module name → absolute directory of the module. */
+function getWorkspaceModules(repoRoot) {
+    const cached = workspaceCache.get(repoRoot);
+    if (cached) {
+        return cached;
+    }
+    const result = new Map();
+    const goWorkPath = join(repoRoot, 'go.work');
+    if (!cachedExists(goWorkPath)) {
+        workspaceCache.set(repoRoot, result);
+        return result;
+    }
+    try {
+        const content = readFileSync(goWorkPath, 'utf-8');
+        // Parse use directives — both single-line and block form
+        // Block: use ( ./a \n ./b )
+        const blockRe = /use\s*\(([\s\S]*?)\)/g;
+        let blockMatch = blockRe.exec(content);
+        const useDirs = [];
+        while (blockMatch !== null) {
+            const inner = blockMatch[1];
+            for (const line of inner.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('//')) {
+                    useDirs.push(trimmed);
+                }
+            }
+            blockMatch = blockRe.exec(content);
+        }
+        // Single-line: use ./foo
+        const singleRe = /^use\s+(\S+)\s*$/gm;
+        let singleMatch = singleRe.exec(content);
+        while (singleMatch !== null) {
+            const dir = singleMatch[1];
+            if (dir !== '(') {
+                useDirs.push(dir);
+            }
+            singleMatch = singleRe.exec(content);
+        }
+        // For each use directory, read its go.mod to get the module name
+        for (const dir of useDirs) {
+            const absDir = resolvePath(join(repoRoot, dir));
+            const modName = getModuleName(absDir);
+            if (modName) {
+                result.set(modName, absDir);
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    workspaceCache.set(repoRoot, result);
+    return result;
+}
+function isStdlib(modulePath) {
+    const first = modulePath.split('/')[0];
+    return !first.includes('.');
+}
+/** Find the first .go file (non-test) in a directory, or check for a .go file at the path. */
+function findGoFile(absDir) {
+    if (cachedExists(absDir)) {
+        try {
+            const files = cachedReaddir(absDir).sort();
+            const goFile = files.find((f) => f.endsWith('.go') && !f.endsWith('_test.go'));
+            if (goFile) {
+                return resolvePath(join(absDir, goFile));
+            }
+        }
+        catch {
+            /* not a directory */
+        }
+    }
+    if (cachedExists(`${absDir}.go`)) {
+        return resolvePath(`${absDir}.go`);
+    }
+    return null;
+}
+export function resolve(_fromAbsFile, modulePath, repoRoot) {
+    if (isStdlib(modulePath)) {
+        return null;
+    }
+    // 1. Try resolving against the root module name
+    const moduleName = getModuleName(repoRoot);
+    if (moduleName && modulePath.startsWith(moduleName)) {
+        const relPath = modulePath.slice(moduleName.length + 1);
+        if (relPath) {
+            const result = findGoFile(join(repoRoot, relPath));
+            if (result) {
+                return result;
+            }
+        }
+    }
+    // 2. Try replace directives from go.mod
+    const replaces = getReplaceMap(repoRoot);
+    for (const [modPrefix, localDir] of replaces) {
+        if (modulePath.startsWith(modPrefix)) {
+            const suffix = modulePath.slice(modPrefix.length);
+            // suffix is either empty or starts with '/'
+            const relPath = suffix.startsWith('/') ? suffix.slice(1) : suffix;
+            if (relPath) {
+                const result = findGoFile(join(localDir, relPath));
+                if (result) {
+                    return result;
+                }
+            }
+        }
+    }
+    // 3. Try go.work workspace modules
+    const workspaceModules = getWorkspaceModules(repoRoot);
+    for (const [wsModName, wsModDir] of workspaceModules) {
+        if (modulePath.startsWith(wsModName)) {
+            const suffix = modulePath.slice(wsModName.length);
+            const relPath = suffix.startsWith('/') ? suffix.slice(1) : suffix;
+            if (relPath) {
+                const result = findGoFile(join(wsModDir, relPath));
+                if (result) {
+                    return result;
+                }
+            }
+        }
+    }
+    // 4. Try vendor directory
+    const vendorDir = join(repoRoot, 'vendor', modulePath);
+    const vendorResult = findGoFile(vendorDir);
+    if (vendorResult) {
+        return vendorResult;
+    }
+    return null;
+}

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

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

package/dist/resolver/languages/java.js

@@ -0,0 +1,193 @@
+import { readFileSync } from 'fs';
+import { join, resolve as resolvePath } from 'path';
+import { cachedExists, cachedReaddir } from '../fs-cache';
+const STDLIB_PREFIXES = ['java.', 'javax.', 'sun.', 'com.sun.', 'jdk.'];
+const SOURCE_ROOTS = ['src/main/java', 'src/main/kotlin', 'src', ''];
+const EXTENSIONS = ['.java', '.kt'];
+/**
+ * Collect all source roots, including those inside Gradle subproject directories.
+ */
+function collectSourceRoots(repoRoot) {
+    const roots = [...SOURCE_ROOTS];
+    // Discover Gradle subprojects from settings.gradle / settings.gradle.kts
+    for (const settingsFile of ['settings.gradle', 'settings.gradle.kts']) {
+        const settingsPath = join(repoRoot, settingsFile);
+        if (!cachedExists(settingsPath)) {
+            continue;
+        }
+        const content = readFileSync(settingsPath, 'utf-8');
+        // Match patterns like ':app', ':lib', ':core:domain'
+        const projectRegex = /['"]:([\w:/-]+)['"]/g;
+        let match = projectRegex.exec(content);
+        while (match !== null) {
+            const subDir = match[1].replace(/:/g, '/');
+            for (const srcRoot of SOURCE_ROOTS) {
+                if (srcRoot) {
+                    roots.push(join(subDir, srcRoot));
+                }
+            }
+            match = projectRegex.exec(content);
+        }
+        break; // only read first settings file found
+    }
+    // Discover custom sourceSets from build.gradle / build.gradle.kts in subprojects
+    const gradleFiles = [];
+    // Collect build.gradle files: root + discovered subproject dirs
+    for (const buildFile of ['build.gradle', 'build.gradle.kts']) {
+        if (cachedExists(join(repoRoot, buildFile))) {
+            gradleFiles.push({ dir: '', file: buildFile });
+        }
+    }
+    // Also check subproject directories already discovered above
+    const subDirs = new Set();
+    for (const r of roots) {
+        // Extract the subproject directory (everything before src/...)
+        const srcIdx = r.indexOf('/src');
+        if (srcIdx > 0) {
+            subDirs.add(r.slice(0, srcIdx));
+        }
+    }
+    for (const sub of subDirs) {
+        for (const buildFile of ['build.gradle', 'build.gradle.kts']) {
+            const buildPath = join(repoRoot, sub, buildFile);
+            if (cachedExists(buildPath)) {
+                gradleFiles.push({ dir: sub, file: join(sub, buildFile) });
+            }
+        }
+    }
+    for (const { dir, file } of gradleFiles) {
+        try {
+            const content = readFileSync(join(repoRoot, file), 'utf-8');
+            // Match: srcDirs = ['path1', 'path2']
+            const srcDirsArrayRegex = /srcDirs\s*=\s*\[([^\]]+)\]/g;
+            let sdMatch = srcDirsArrayRegex.exec(content);
+            while (sdMatch !== null) {
+                const entries = sdMatch[1];
+                const pathRegex = /['"]([^'"]+)['"]/g;
+                let pathMatch = pathRegex.exec(entries);
+                while (pathMatch !== null) {
+                    const srcDir = pathMatch[1];
+                    const root = dir ? join(dir, srcDir) : srcDir;
+                    if (!roots.includes(root)) {
+                        roots.push(root);
+                    }
+                    pathMatch = pathRegex.exec(entries);
+                }
+                sdMatch = srcDirsArrayRegex.exec(content);
+            }
+            // Match: srcDir 'path' or srcDir "path"
+            const srcDirSingleRegex = /srcDir\s+['"]([^'"]+)['"]/g;
+            let singleMatch = srcDirSingleRegex.exec(content);
+            while (singleMatch !== null) {
+                const srcDir = singleMatch[1];
+                const root = dir ? join(dir, srcDir) : srcDir;
+                if (!roots.includes(root)) {
+                    roots.push(root);
+                }
+                singleMatch = srcDirSingleRegex.exec(content);
+            }
+        }
+        catch {
+            // build.gradle read failed, continue
+        }
+    }
+    // Discover Maven subprojects from pom.xml (recursive)
+    discoverMavenModules(repoRoot, '', roots, 0);
+    return roots;
+}
+/**
+ * Try to find a file at the given relative path (without extension) across all
+ * source roots, probing each supported extension.
+ */
+function findFile(repoRoot, relPathNoExt, sourceRoots) {
+    for (const srcRoot of sourceRoots) {
+        for (const ext of EXTENSIONS) {
+            const candidate = join(repoRoot, srcRoot, relPathNoExt + ext);
+            if (cachedExists(candidate)) {
+                return resolvePath(candidate);
+            }
+        }
+    }
+    return null;
+}
+const MAX_MAVEN_DEPTH = 5;
+/**
+ * Recursively discover Maven modules from pom.xml files.
+ * Each module's pom.xml may declare its own <module> elements,
+ * forming a tree (e.g. Keycloak: root → services → sub-service).
+ */
+function discoverMavenModules(repoRoot, relDir, roots, depth) {
+    if (depth > MAX_MAVEN_DEPTH) {
+        return;
+    }
+    const pomPath = join(repoRoot, relDir, 'pom.xml');
+    if (!cachedExists(pomPath)) {
+        return;
+    }
+    try {
+        const content = readFileSync(pomPath, 'utf-8');
+        const moduleRegex = /<module>([^<]+)<\/module>/g;
+        let mvnMatch = moduleRegex.exec(content);
+        while (mvnMatch !== null) {
+            const moduleName = mvnMatch[1];
+            const moduleDir = relDir ? join(relDir, moduleName) : moduleName;
+            // Add source roots for this module
+            const javaRoot = join(moduleDir, 'src/main/java');
+            if (!roots.includes(javaRoot)) {
+                roots.push(javaRoot);
+            }
+            const kotlinRoot = join(moduleDir, 'src/main/kotlin');
+            if (!roots.includes(kotlinRoot)) {
+                roots.push(kotlinRoot);
+            }
+            // Recurse into the module's own pom.xml
+            discoverMavenModules(repoRoot, moduleDir, roots, depth + 1);
+            mvnMatch = moduleRegex.exec(content);
+        }
+    }
+    catch {
+        // pom.xml read failed, continue
+    }
+}
+export function resolve(_fromAbsFile, modulePath, repoRoot) {
+    if (STDLIB_PREFIXES.some((p) => modulePath.startsWith(p))) {
+        return null;
+    }
+    const sourceRoots = collectSourceRoots(repoRoot);
+    // --- Wildcard imports: com.example.models.* ---
+    if (modulePath.endsWith('.*')) {
+        const packagePath = modulePath.slice(0, -2).replace(/\./g, '/');
+        for (const srcRoot of sourceRoots) {
+            const dirPath = join(repoRoot, srcRoot, packagePath);
+            if (cachedExists(dirPath)) {
+                try {
+                    const files = cachedReaddir(dirPath).filter((f) => EXTENSIONS.some((ext) => f.endsWith(ext)));
+                    if (files.length > 0) {
+                        return resolvePath(join(dirPath, files[0]));
+                    }
+                }
+                catch {
+                    // directory read failed, try next root
+                }
+            }
+        }
+        return null;
+    }
+    // --- Standard resolution: try full path with all extensions ---
+    const relPathNoExt = modulePath.replace(/\./g, '/');
+    const direct = findFile(repoRoot, relPathNoExt, sourceRoots);
+    if (direct) {
+        return direct;
+    }
+    // --- Inner class fallback: progressively shorten the path ---
+    // com.example.Config.DatabaseSettings → try com/example/Config
+    const segments = modulePath.split('.');
+    for (let i = segments.length - 1; i >= 2; i--) {
+        const shorter = segments.slice(0, i).join('/');
+        const found = findFile(repoRoot, shorter, sourceRoots);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,3 @@
+/** Clear cached composer.json PSR-4 data. Call between analysis runs or when switching repos. */
+export declare function clearCache(): void;
+export declare function resolve(_fromAbsFile: string, modulePath: string, repoRoot: string): string | null;

package/dist/resolver/languages/php.js

@@ -0,0 +1,75 @@
+import { readFileSync } from 'fs';
+import { dirname, join, resolve as resolvePath } from 'path';
+import { cachedExists } from '../fs-cache';
+const psr4Cache = new Map();
+/** Clear cached composer.json PSR-4 data. Call between analysis runs or when switching repos. */
+export function clearCache() {
+    psr4Cache.clear();
+}
+/** Check if the modulePath looks like a file path (require/include style) rather than a namespace. */
+function looksLikeFilePath(modulePath) {
+    return modulePath.includes('/') || modulePath.endsWith('.php');
+}
+function loadPsr4(repoRoot) {
+    const cached = psr4Cache.get(repoRoot);
+    if (cached) {
+        return cached;
+    }
+    const map = new Map();
+    const composerPath = join(repoRoot, 'composer.json');
+    if (cachedExists(composerPath)) {
+        try {
+            const content = readFileSync(composerPath, 'utf-8');
+            const config = JSON.parse(content);
+            const psr4 = config?.autoload?.['psr-4'];
+            if (psr4) {
+                for (const [prefix, dir] of Object.entries(psr4)) {
+                    const dirStr = Array.isArray(dir) ? dir[0] : dir;
+                    map.set(prefix, dirStr);
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    psr4Cache.set(repoRoot, map);
+    return map;
+}
+export function resolve(_fromAbsFile, modulePath, repoRoot) {
+    // Handle require/include style file paths before PSR-4 resolution
+    if (looksLikeFilePath(modulePath)) {
+        // Try resolving relative to the importing file's directory
+        if (_fromAbsFile) {
+            const fromDir = dirname(_fromAbsFile);
+            const candidate = resolvePath(join(fromDir, modulePath));
+            if (cachedExists(candidate)) {
+                return candidate;
+            }
+        }
+        // Try resolving relative to repo root
+        const rootCandidate = resolvePath(join(repoRoot, modulePath));
+        if (cachedExists(rootCandidate)) {
+            return rootCandidate;
+        }
+    }
+    const psr4 = loadPsr4(repoRoot);
+    for (const [prefix, dir] of psr4) {
+        if (modulePath.startsWith(prefix)) {
+            const rest = modulePath.slice(prefix.length);
+            const relPath = `${rest.replace(/\\/g, '/')}.php`;
+            const candidate = join(repoRoot, dir, relPath);
+            if (cachedExists(candidate)) {
+                return resolvePath(candidate);
+            }
+        }
+    }
+    const relPath = `${modulePath.replace(/\\/g, '/')}.php`;
+    for (const base of ['', 'src', 'lib', 'app']) {
+        const candidate = join(repoRoot, base, relPath);
+        if (cachedExists(candidate)) {
+            return resolvePath(candidate);
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Python import resolver.
+ *
+ * Handles dotted module paths (e.g., "from x.y import z").
+ * Walks up directories to find packages.
+ */
+/**
+ * Resolve a Python dotted import to a file path.
+ * Walks up from the importing file's directory to find the module.
+ */
+export declare function resolve(fromAbsFile: string, modulePath: string, _repoRoot: string): string | null;

package/dist/resolver/languages/python.js

@@ -0,0 +1,127 @@
+/**
+ * Python import resolver.
+ *
+ * Handles dotted module paths (e.g., "from x.y import z").
+ * Walks up directories to find packages.
+ */
+import { readFileSync } from 'fs';
+import { dirname, join, resolve as resolvePath } from 'path';
+import { cachedExists } from '../fs-cache';
+/**
+ * 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, modulePath, _repoRoot) {
+    if (!modulePath) {
+        return null;
+    }
+    if (modulePath.startsWith('.')) {
+        // Relative import: count leading dots, walk up directories
+        const dotMatch = modulePath.match(/^(\.+)/);
+        const dots = dotMatch[1].length;
+        const rest = modulePath.slice(dots).replace(/\./g, '/');
+        let base = dirname(fromAbsFile);
+        for (let d = 1; d < dots; d++) {
+            base = dirname(base);
+        }
+        const candidates = rest ? [`${rest}.py`, `${rest}/__init__.py`] : [`__init__.py`];
+        for (const candidate of candidates) {
+            const full = join(base, candidate);
+            if (cachedExists(full)) {
+                return resolvePath(full);
+            }
+        }
+        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 (cachedExists(full)) {
+                return resolvePath(full);
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    // Fallback: check setup.cfg for package_dir directive (e.g., package_dir = = src)
+    const setupCfgResult = resolveViaSetupCfg(parts, _repoRoot);
+    if (setupCfgResult) {
+        return setupCfgResult;
+    }
+    // Fallback: check pyproject.toml for package-dir (e.g., [tool.setuptools.package-dir] "" = "src")
+    const pyprojectResult = resolveViaPyprojectPackageDir(parts, _repoRoot);
+    if (pyprojectResult) {
+        return pyprojectResult;
+    }
+    return null;
+}
+/**
+ * Try resolving via setup.cfg package_dir directive.
+ * Looks for patterns like:
+ *   [options]
+ *   package_dir =
+ *       = src
+ * which means the root package directory is "src/".
+ */
+function resolveViaSetupCfg(relPath, repoRoot) {
+    const setupCfgPath = join(repoRoot, 'setup.cfg');
+    if (!cachedExists(setupCfgPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(setupCfgPath, 'utf-8');
+        // Look for package_dir under [options]
+        // Common patterns:
+        //   package_dir =
+        //       = src
+        //   package_dir = = src
+        const packageDirRegex = /package_dir\s*=\s*(?:\n\s+)?=\s*(\S+)/;
+        const match = packageDirRegex.exec(content);
+        if (match) {
+            const srcDir = match[1];
+            for (const candidate of [`${relPath}.py`, `${relPath}/__init__.py`]) {
+                const full = join(repoRoot, srcDir, candidate);
+                if (cachedExists(full)) {
+                    return resolvePath(full);
+                }
+            }
+        }
+    }
+    catch {
+        // setup.cfg read failed, continue
+    }
+    return null;
+}
+/**
+ * Try resolving via pyproject.toml [tool.setuptools.package-dir] directive.
+ */
+function resolveViaPyprojectPackageDir(relPath, repoRoot) {
+    const pyprojectPath = join(repoRoot, 'pyproject.toml');
+    if (!cachedExists(pyprojectPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(pyprojectPath, 'utf-8');
+        // Look for [tool.setuptools.package-dir] section with "" = "src" or similar
+        const packageDirRegex = /\[tool\.setuptools\.package-dir\]\s*\n\s*""\s*=\s*"(\S+)"/;
+        const match = packageDirRegex.exec(content);
+        if (match) {
+            const srcDir = match[1];
+            for (const candidate of [`${relPath}.py`, `${relPath}/__init__.py`]) {
+                const full = join(repoRoot, srcDir, candidate);
+                if (cachedExists(full)) {
+                    return resolvePath(full);
+                }
+            }
+        }
+    }
+    catch {
+        // pyproject.toml read failed, continue
+    }
+    return null;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Ruby import resolver.
+ *
+ * Handles require_relative paths, Gemfile path: gems, and Zeitwerk autoload.
+ */
+/**
+ * Resolve a Ruby require/require_relative to a file path.
+ */
+export declare function resolve(fromAbsFile: string, modulePath: string, repoRoot: string): string | null;
+/**
+ * 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 declare function resolveZeitwerk(className: string, repoRoot: string): string | null;