@kodus/kodus-graph 0.2.9 → 0.2.10

package/dist/resolver/fs-cache.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared filesystem cache for resolvers.
+ * Caches existsSync and readdirSync results to avoid repeated disk I/O.
+ * Call clearFsCache() between analysis runs.
+ */
+export declare function cachedExists(path: string): boolean;
+export declare function cachedReaddir(path: string): string[];
+export declare function clearFsCache(): void;

package/dist/resolver/fs-cache.js

@@ -0,0 +1,36 @@
+/**
+ * Shared filesystem cache for resolvers.
+ * Caches existsSync and readdirSync results to avoid repeated disk I/O.
+ * Call clearFsCache() between analysis runs.
+ */
+import { existsSync, readdirSync } from 'fs';
+const existsCache = new Map();
+const readdirCache = new Map();
+export function cachedExists(path) {
+    const cached = existsCache.get(path);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = existsSync(path);
+    existsCache.set(path, result);
+    return result;
+}
+export function cachedReaddir(path) {
+    const cached = readdirCache.get(path);
+    if (cached !== undefined) {
+        return cached;
+    }
+    try {
+        const result = readdirSync(path).sort();
+        readdirCache.set(path, result);
+        return result;
+    }
+    catch {
+        readdirCache.set(path, []);
+        return [];
+    }
+}
+export function clearFsCache() {
+    existsCache.clear();
+    readdirCache.clear();
+}

package/dist/resolver/import-resolver.js

@@ -4,10 +4,12 @@
  * Routes import resolution to language-specific resolvers and
  * falls back to tsconfig aliases for TypeScript/JavaScript.
  */
-import { existsSync, readdirSync, readFileSync } from 'fs';
+import { readdirSync, readFileSync } from 'fs';
 import { join, resolve as resolvePath } from 'path';
 import { log } from '../shared/logger';
 import { ensureWithinRoot } from '../shared/safe-path';
+import { detectExternal } from './external-detector';
+import { cachedExists } from './fs-cache';
 import { resolve as resolveCsImport } from './languages/csharp';
 import { resolve as resolveGoImport } from './languages/go';
 import { resolve as resolveJavaImport } from './languages/java';
@@ -15,7 +17,20 @@ 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';
+import { loadBundlerAliases, loadTsconfigAliases, resolve as resolveTsImport, resolveWithAliases, } from './languages/typescript';
+/**
+ * Registered import resolvers by language key.
+ *
+ * IMPORTANT: When adding a new language, you MUST:
+ * 1. Create a resolver in src/resolver/languages/<lang>.ts
+ * 2. Add it to this map
+ * 3. Add tests in tests/resolver/<lang>.test.ts
+ * 4. Add external detection in src/resolver/external-detector.ts
+ *
+ * If a language key from the parser is not in this map, resolveImport()
+ * will log a warning and return null. This is intentional — silent
+ * failures that default to another language's resolver cause wrong results.
+ */
 const RESOLVERS = {
     ts: resolveTsImport,
     javascript: resolveTsImport,
@@ -34,7 +49,7 @@ const RESOLVERS = {
  */
 function resolveHashImport(modulePath, repoRoot) {
     const pkgPath = join(repoRoot, 'package.json');
-    if (!existsSync(pkgPath)) {
+    if (!cachedExists(pkgPath)) {
         return null;
     }
     try {
@@ -50,7 +65,7 @@ function resolveHashImport(modulePath, repoRoot) {
             if (pattern === modulePath) {
                 // Exact match: "#utils" -> "./src/shared/utils.ts"
                 const resolved = resolvePath(repoRoot, target);
-                if (existsSync(resolved)) {
+                if (cachedExists(resolved)) {
                     return resolved;
                 }
             }
@@ -60,7 +75,7 @@ function resolveHashImport(modulePath, repoRoot) {
                 if (modulePath.startsWith(prefix)) {
                     const rest = modulePath.slice(prefix.length); // "connection"
                     const resolved = resolvePath(repoRoot, target.replace('*', rest));
-                    if (existsSync(resolved)) {
+                    if (cachedExists(resolved)) {
                         return resolved;
                     }
                 }
@@ -72,28 +87,59 @@ function resolveHashImport(modulePath, repoRoot) {
     }
     return null;
 }
+/**
+ * Resolve a conditional export value to a single string path.
+ * When the value is a plain string, return it directly.
+ * When it's an object with condition keys, prefer: types > import > default > first value.
+ */
+function resolveExportValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const obj = value;
+        for (const key of ['types', 'import', 'default']) {
+            if (typeof obj[key] === 'string') {
+                return obj[key];
+            }
+        }
+        // Fallback: first value that is a string
+        for (const v of Object.values(obj)) {
+            if (typeof v === 'string') {
+                return v;
+            }
+        }
+    }
+    return null;
+}
 /**
  * Resolve monorepo workspace package exports.
  * Scans workspace directories to find packages matching the import specifier.
  */
 function resolveWorkspaceExport(modulePath, repoRoot) {
     const rootPkgPath = join(repoRoot, 'package.json');
-    if (!existsSync(rootPkgPath)) {
+    if (!cachedExists(rootPkgPath)) {
         return null;
     }
     try {
         const rootPkg = JSON.parse(readFileSync(rootPkgPath, 'utf-8'));
-        const workspaces = rootPkg?.workspaces;
-        if (!Array.isArray(workspaces)) {
+        let workspaceGlobs;
+        if (Array.isArray(rootPkg?.workspaces)) {
+            workspaceGlobs = rootPkg.workspaces;
+        }
+        else if (rootPkg?.workspaces?.packages && Array.isArray(rootPkg.workspaces.packages)) {
+            workspaceGlobs = rootPkg.workspaces.packages;
+        }
+        if (!workspaceGlobs) {
             return null;
         }
         // Collect all workspace package directories
         const pkgDirs = [];
-        for (const ws of workspaces) {
+        for (const ws of workspaceGlobs) {
             if (ws.endsWith('/*')) {
                 // Glob pattern like "packages/*"
                 const parentDir = join(repoRoot, ws.slice(0, -2));
-                if (existsSync(parentDir)) {
+                if (cachedExists(parentDir)) {
                     const entries = readdirSync(parentDir, { withFileTypes: true });
                     for (const entry of entries) {
                         if (entry.isDirectory()) {
@@ -106,10 +152,10 @@ function resolveWorkspaceExport(modulePath, repoRoot) {
                 pkgDirs.push(join(repoRoot, ws));
             }
         }
-        // Search each workspace package for a matching name + exports
+        // Search each workspace package for a matching name + exports/main/module
         for (const pkgDir of pkgDirs) {
             const pkgJsonPath = join(pkgDir, 'package.json');
-            if (!existsSync(pkgJsonPath)) {
+            if (!cachedExists(pkgJsonPath)) {
                 continue;
             }
             const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
@@ -118,28 +164,53 @@ function resolveWorkspaceExport(modulePath, repoRoot) {
                 continue;
             }
             const exports = pkg?.exports;
-            if (!exports || typeof exports !== 'object') {
-                continue;
-            }
             // Check if modulePath matches this package (exact or subpath)
             if (modulePath === pkgName) {
-                // Root export: "." entry
-                const target = exports['.'];
-                if (typeof target === 'string') {
-                    const resolved = resolvePath(pkgDir, target);
-                    if (existsSync(resolved)) {
-                        return resolved;
+                if (exports && typeof exports === 'object') {
+                    // Root export: "." entry
+                    const target = resolveExportValue(exports['.']);
+                    if (target) {
+                        const resolved = resolvePath(pkgDir, target);
+                        if (cachedExists(resolved)) {
+                            return resolved;
+                        }
+                    }
+                }
+                else if (!exports) {
+                    // Fallback to main or module fields
+                    const fallback = pkg.main ?? pkg.module;
+                    if (typeof fallback === 'string') {
+                        const resolved = resolvePath(pkgDir, fallback);
+                        if (cachedExists(resolved)) {
+                            return resolved;
+                        }
                     }
                 }
             }
             else if (modulePath.startsWith(`${pkgName}/`)) {
-                // Subpath export: "./button" entry
-                const subpath = `./${modulePath.slice(pkgName.length + 1)}`;
-                const target = exports[subpath];
-                if (typeof target === 'string') {
-                    const resolved = resolvePath(pkgDir, target);
-                    if (existsSync(resolved)) {
-                        return resolved;
+                const subpath = modulePath.slice(pkgName.length + 1);
+                // 1. Try exports field first
+                if (exports && typeof exports === 'object') {
+                    const exportKey = `./${subpath}`;
+                    const target = resolveExportValue(exports[exportKey]);
+                    if (target) {
+                        const resolved = resolvePath(pkgDir, target);
+                        if (cachedExists(resolved)) {
+                            return resolved;
+                        }
+                    }
+                }
+                // 2. No exports or no match? Resolve subpath directly in package directory
+                const directBase = join(pkgDir, subpath);
+                for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+                    if (cachedExists(directBase + ext)) {
+                        return resolvePath(directBase + ext);
+                    }
+                }
+                for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+                    const idx = join(directBase, `index${ext}`);
+                    if (cachedExists(idx)) {
+                        return resolvePath(idx);
                     }
                 }
             }
@@ -163,11 +234,21 @@ function resolveWorkspaceExport(modulePath, repoRoot) {
 export function resolveImport(fromAbsFile, modulePath, lang, repoRoot, tsconfigAliases) {
     const resolver = RESOLVERS[lang];
     if (!resolver) {
+        log.warn('No import resolver registered for language', { lang, module: modulePath, from: fromAbsFile });
         return null;
     }
-    const isTs = lang === 'ts' || lang === 'javascript' || lang === 'typescript';
+    // Strip webpack/rollup loader syntax: !!loader1!loader2!actual/path
+    // The actual import path is always the last segment after the final '!'
+    if (modulePath.includes('!')) {
+        modulePath = modulePath.split('!').pop() || modulePath;
+    }
+    // TS/JS-specific fallbacks: tsconfig aliases, bundler aliases, #imports, workspace exports.
+    // These are Node.js/npm ecosystem features that don't apply to other languages.
+    // Other languages handle their own workspace/monorepo patterns inside their resolvers
+    // (Go: go.work, Rust: Cargo workspace, Java: Maven/Gradle modules).
+    const isTsOrJs = lang === 'ts' || lang === 'javascript' || lang === 'typescript';
     // Handle package.json #imports (TS/JS only)
-    if (isTs && modulePath.startsWith('#')) {
+    if (isTsOrJs && modulePath.startsWith('#')) {
         const result = resolveHashImport(modulePath, repoRoot);
         if (result) {
             try {
@@ -186,11 +267,18 @@ export function resolveImport(fromAbsFile, modulePath, lang, repoRoot, tsconfigA
     }
     let result = resolver(fromAbsFile, modulePath, repoRoot);
     // Fallback: tsconfig aliases for TS/JS
-    if (!result && isTs && tsconfigAliases?.size) {
+    if (!result && isTsOrJs && tsconfigAliases?.size) {
         result = resolveWithAliases(modulePath, tsconfigAliases, repoRoot);
     }
+    // Fallback: bundler aliases (webpack/vite) for TS/JS bare specifiers
+    if (!result && isTsOrJs && !modulePath.startsWith('.')) {
+        const bundlerAliases = loadBundlerAliases(repoRoot);
+        if (bundlerAliases.size > 0) {
+            result = resolveWithAliases(modulePath, bundlerAliases, repoRoot);
+        }
+    }
     // Fallback: monorepo workspace exports for TS/JS bare specifiers
-    if (!result && isTs && !modulePath.startsWith('.')) {
+    if (!result && isTsOrJs && !modulePath.startsWith('.')) {
         result = resolveWorkspaceExport(modulePath, repoRoot);
     }
     // Validate resolved path is within repo root
@@ -207,6 +295,16 @@ export function resolveImport(fromAbsFile, modulePath, lang, repoRoot, tsconfigA
             return null;
         }
     }
+    // If still unresolved, check if it's an external package (for logging/debugging)
+    if (!result) {
+        const externalPkg = detectExternal(modulePath, lang, repoRoot);
+        if (externalPkg) {
+            // External package — expected null, don't log as warning
+            return null;
+        }
+        // Truly unresolved local import
+        log.debug('Unresolved local import', { from: fromAbsFile, module: modulePath });
+    }
     return result;
 }
 export { loadTsconfigAliases };

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

@@ -1 +1,3 @@
+/** Clear cached .sln 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/csharp.js

@@ -1,18 +1,74 @@
-import { existsSync, statSync } from 'fs';
-import { join, resolve as resolvePath } from 'path';
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { dirname, join, resolve as resolvePath } from 'path';
+import { cachedExists } from '../fs-cache';
 const STDLIB_PREFIXES = ['System.', 'System', 'Microsoft.', 'Newtonsoft.'];
+const slnProjectsCache = new Map();
+/** Clear cached .sln data. Call between analysis runs or when switching repos. */
+export function clearCache() {
+    slnProjectsCache.clear();
+}
+/**
+ * Parse .sln files at repoRoot to discover project directories.
+ * Lines like: Project("{FAE04EC0}") = "Name", "path/to/Project.csproj", "{GUID}"
+ */
+function getSlnProjectDirs(repoRoot) {
+    const cached = slnProjectsCache.get(repoRoot);
+    if (cached) {
+        return cached;
+    }
+    const dirs = [];
+    try {
+        const entries = readdirSync(repoRoot);
+        for (const entry of entries) {
+            if (entry.endsWith('.sln')) {
+                const slnPath = join(repoRoot, entry);
+                try {
+                    const content = readFileSync(slnPath, 'utf-8');
+                    const projectRe = /^Project\("[^"]*"\)\s*=\s*"[^"]*",\s*"([^"]+\.csproj)"/gm;
+                    let m = projectRe.exec(content);
+                    while (m !== null) {
+                        const csprojRelPath = m[1].replace(/\\/g, '/');
+                        const projectDir = dirname(join(repoRoot, csprojRelPath));
+                        if (cachedExists(projectDir)) {
+                            dirs.push(projectDir);
+                        }
+                        m = projectRe.exec(content);
+                    }
+                }
+                catch {
+                    /* ignore unreadable sln */
+                }
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    slnProjectsCache.set(repoRoot, dirs);
+    return dirs;
+}
 export function resolve(_fromAbsFile, modulePath, repoRoot) {
     if (STDLIB_PREFIXES.some((p) => modulePath.startsWith(p))) {
         return null;
     }
     const segments = modulePath.split('.');
+    // Collect search base directories: standard ones + .sln-discovered project dirs
+    const standardBases = ['', 'src', 'lib', 'Source'];
+    const slnDirs = getSlnProjectDirs(repoRoot);
     // Try resolving as a .cs file first
     for (let i = segments.length - 1; i >= 0; i--) {
         const pathPart = segments.slice(i).join('/');
         const candidate = `${pathPart}.cs`;
-        for (const base of ['', 'src', 'lib', 'Source']) {
+        for (const base of standardBases) {
             const full = join(repoRoot, base, candidate);
-            if (existsSync(full)) {
+            if (cachedExists(full)) {
+                return resolvePath(full);
+            }
+        }
+        // Also search in .sln-discovered project directories
+        for (const projDir of slnDirs) {
+            const full = join(projDir, candidate);
+            if (cachedExists(full)) {
                 return resolvePath(full);
             }
         }
@@ -20,9 +76,16 @@ export function resolve(_fromAbsFile, modulePath, repoRoot) {
     // Try resolving as a directory (namespace → folder mapping)
     for (let i = segments.length - 1; i >= 0; i--) {
         const pathPart = segments.slice(i).join('/');
-        for (const base of ['', 'src', 'lib', 'Source']) {
+        for (const base of standardBases) {
             const full = join(repoRoot, base, pathPart);
-            if (existsSync(full) && statSync(full).isDirectory()) {
+            if (cachedExists(full) && statSync(full).isDirectory()) {
+                return resolvePath(full);
+            }
+        }
+        // Also search in .sln-discovered project directories
+        for (const projDir of slnDirs) {
+            const full = join(projDir, pathPart);
+            if (cachedExists(full) && statSync(full).isDirectory()) {
                 return resolvePath(full);
             }
         }

package/dist/resolver/languages/go.js

@@ -1,5 +1,6 @@
-import { existsSync, readdirSync, readFileSync } from 'fs';
+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();
@@ -15,7 +16,7 @@ function getModuleName(repoRoot) {
         return cached || null;
     }
     const goModPath = join(repoRoot, 'go.mod');
-    if (!existsSync(goModPath)) {
+    if (!cachedExists(goModPath)) {
         moduleCache.set(repoRoot, '');
         return null;
     }
@@ -41,7 +42,7 @@ function getReplaceMap(repoRoot) {
     }
     const result = new Map();
     const goModPath = join(repoRoot, 'go.mod');
-    if (!existsSync(goModPath)) {
+    if (!cachedExists(goModPath)) {
         replaceCache.set(repoRoot, result);
         return result;
     }
@@ -73,7 +74,7 @@ function getWorkspaceModules(repoRoot) {
     }
     const result = new Map();
     const goWorkPath = join(repoRoot, 'go.work');
-    if (!existsSync(goWorkPath)) {
+    if (!cachedExists(goWorkPath)) {
         workspaceCache.set(repoRoot, result);
         return result;
     }
@@ -125,9 +126,9 @@ function isStdlib(modulePath) {
 }
 /** Find the first .go file (non-test) in a directory, or check for a .go file at the path. */
 function findGoFile(absDir) {
-    if (existsSync(absDir)) {
+    if (cachedExists(absDir)) {
         try {
-            const files = readdirSync(absDir).sort();
+            const files = cachedReaddir(absDir).sort();
             const goFile = files.find((f) => f.endsWith('.go') && !f.endsWith('_test.go'));
             if (goFile) {
                 return resolvePath(join(absDir, goFile));
@@ -137,7 +138,7 @@ function findGoFile(absDir) {
             /* not a directory */
         }
     }
-    if (existsSync(`${absDir}.go`)) {
+    if (cachedExists(`${absDir}.go`)) {
         return resolvePath(`${absDir}.go`);
     }
     return null;

package/dist/resolver/languages/java.js

@@ -1,5 +1,6 @@
-import { existsSync, readdirSync, readFileSync } from 'fs';
+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'];
@@ -11,7 +12,7 @@ function collectSourceRoots(repoRoot) {
     // Discover Gradle subprojects from settings.gradle / settings.gradle.kts
     for (const settingsFile of ['settings.gradle', 'settings.gradle.kts']) {
         const settingsPath = join(repoRoot, settingsFile);
-        if (!existsSync(settingsPath)) {
+        if (!cachedExists(settingsPath)) {
             continue;
         }
         const content = readFileSync(settingsPath, 'utf-8');
@@ -29,24 +30,69 @@ function collectSourceRoots(repoRoot) {
         }
         break; // only read first settings file found
     }
-    // Discover Maven subprojects from pom.xml
-    const pomPath = join(repoRoot, 'pom.xml');
-    if (existsSync(pomPath)) {
+    // 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(pomPath, 'utf-8');
-            const moduleRegex = /<module>([^<]+)<\/module>/g;
-            let mvnMatch = moduleRegex.exec(content);
-            while (mvnMatch !== null) {
-                const subDir = mvnMatch[1];
-                roots.push(join(subDir, 'src/main/java'));
-                roots.push(join(subDir, 'src/main/kotlin'));
-                mvnMatch = moduleRegex.exec(content);
+            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 {
-            // pom.xml read failed, continue
+            // build.gradle read failed, continue
         }
     }
+    // Discover Maven subprojects from pom.xml (recursive)
+    discoverMavenModules(repoRoot, '', roots, 0);
     return roots;
 }
 /**
@@ -57,13 +103,52 @@ function findFile(repoRoot, relPathNoExt, sourceRoots) {
     for (const srcRoot of sourceRoots) {
         for (const ext of EXTENSIONS) {
             const candidate = join(repoRoot, srcRoot, relPathNoExt + ext);
-            if (existsSync(candidate)) {
+            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;
@@ -74,9 +159,9 @@ export function resolve(_fromAbsFile, modulePath, repoRoot) {
         const packagePath = modulePath.slice(0, -2).replace(/\./g, '/');
         for (const srcRoot of sourceRoots) {
             const dirPath = join(repoRoot, srcRoot, packagePath);
-            if (existsSync(dirPath)) {
+            if (cachedExists(dirPath)) {
                 try {
-                    const files = readdirSync(dirPath).filter((f) => EXTENSIONS.some((ext) => f.endsWith(ext)));
+                    const files = cachedReaddir(dirPath).filter((f) => EXTENSIONS.some((ext) => f.endsWith(ext)));
                     if (files.length > 0) {
                         return resolvePath(join(dirPath, files[0]));
                     }