@kodus/kodus-graph 0.2.9 → 0.2.10

package/dist/resolver/languages/php.js

@@ -1,10 +1,15 @@
-import { existsSync, readFileSync } from 'fs';
-import { join, resolve as resolvePath } from 'path';
+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) {
@@ -12,7 +17,7 @@ function loadPsr4(repoRoot) {
     }
     const map = new Map();
     const composerPath = join(repoRoot, 'composer.json');
-    if (existsSync(composerPath)) {
+    if (cachedExists(composerPath)) {
         try {
             const content = readFileSync(composerPath, 'utf-8');
             const config = JSON.parse(content);
@@ -32,13 +37,29 @@ function loadPsr4(repoRoot) {
     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 (existsSync(candidate)) {
+            if (cachedExists(candidate)) {
                 return resolvePath(candidate);
             }
         }
@@ -46,7 +67,7 @@ export function resolve(_fromAbsFile, modulePath, repoRoot) {
     const relPath = `${modulePath.replace(/\\/g, '/')}.php`;
     for (const base of ['', 'src', 'lib', 'app']) {
         const candidate = join(repoRoot, base, relPath);
-        if (existsSync(candidate)) {
+        if (cachedExists(candidate)) {
             return resolvePath(candidate);
         }
     }

package/dist/resolver/languages/python.js

@@ -4,8 +4,9 @@
  * Handles dotted module paths (e.g., "from x.y import z").
  * Walks up directories to find packages.
  */
-import { existsSync } from 'fs';
+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.
@@ -26,7 +27,7 @@ export function resolve(fromAbsFile, modulePath, _repoRoot) {
         const candidates = rest ? [`${rest}.py`, `${rest}/__init__.py`] : [`__init__.py`];
         for (const candidate of candidates) {
             const full = join(base, candidate);
-            if (existsSync(full)) {
+            if (cachedExists(full)) {
                 return resolvePath(full);
             }
         }
@@ -37,7 +38,7 @@ export function resolve(fromAbsFile, modulePath, _repoRoot) {
     for (let i = 0; i < 10; i++) {
         for (const candidate of [`${parts}.py`, `${parts}/__init__.py`]) {
             const full = join(current, candidate);
-            if (existsSync(full)) {
+            if (cachedExists(full)) {
                 return resolvePath(full);
             }
         }
@@ -47,5 +48,80 @@ export function resolve(fromAbsFile, modulePath, _repoRoot) {
         }
         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

@@ -1,9 +1,24 @@
 /**
  * Ruby import resolver.
  *
- * Handles require_relative paths and Gemfile path: gems.
+ * 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;

package/dist/resolver/languages/ruby.js

@@ -1,10 +1,11 @@
 /**
  * Ruby import resolver.
  *
- * Handles require_relative paths and Gemfile path: gems.
+ * Handles require_relative paths, Gemfile path: gems, and Zeitwerk autoload.
  */
-import { existsSync, readFileSync } from 'fs';
+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();
 /**
@@ -16,7 +17,7 @@ function getGemPathLibDirs(repoRoot) {
     }
     const gemfilePath = join(repoRoot, 'Gemfile');
     const libDirs = [];
-    if (existsSync(gemfilePath)) {
+    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;
@@ -39,19 +40,69 @@ export function resolve(fromAbsFile, modulePath, repoRoot) {
     }
     // 1. Try relative resolution (require_relative style)
     const base = join(dirname(fromAbsFile), modulePath);
-    if (existsSync(`${base}.rb`)) {
+    if (cachedExists(`${base}.rb`)) {
         return resolvePath(`${base}.rb`);
     }
-    if (existsSync(base)) {
+    if (cachedExists(base)) {
         return resolvePath(base);
     }
     // 2. Try Gemfile path: gems
     for (const libDir of getGemPathLibDirs(repoRoot)) {
         const candidate = join(libDir, modulePath);
-        if (existsSync(`${candidate}.rb`)) {
+        if (cachedExists(`${candidate}.rb`)) {
             return resolvePath(`${candidate}.rb`);
         }
-        if (existsSync(candidate)) {
+        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);
         }
     }

package/dist/resolver/languages/rust.js

@@ -1,16 +1,17 @@
-import { existsSync, readFileSync } from 'fs';
+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 (existsSync(asFile)) {
+    if (cachedExists(asFile)) {
         return resolvePath(asFile);
     }
     const asMod = join(baseDir, relPath, 'mod.rs');
-    if (existsSync(asMod)) {
+    if (cachedExists(asMod)) {
         return resolvePath(asMod);
     }
     const asLib = join(baseDir, relPath, 'lib.rs');
-    if (existsSync(asLib)) {
+    if (cachedExists(asLib)) {
         return resolvePath(asLib);
     }
     return null;
@@ -96,7 +97,7 @@ function findCrateDir(fromAbsFile) {
     let dir = dirname(fromAbsFile);
     const root = resolvePath('/');
     while (dir !== root) {
-        if (existsSync(join(dir, 'Cargo.toml'))) {
+        if (cachedExists(join(dir, 'Cargo.toml'))) {
             return dir;
         }
         const parent = dirname(dir);
@@ -123,7 +124,7 @@ function findLocalPackageName(fromAbsFile) {
         return cached;
     }
     const cargoPath = join(crateDir, 'Cargo.toml');
-    if (!existsSync(cargoPath)) {
+    if (!cachedExists(cargoPath)) {
         pkgNameCache.set(crateDir, null);
         return null;
     }
@@ -146,7 +147,7 @@ function findLocalPackageName(fromAbsFile) {
 function parsePathDeps(crateDir) {
     const result = new Map();
     const cargoPath = join(crateDir, 'Cargo.toml');
-    if (!existsSync(cargoPath)) {
+    if (!cachedExists(cargoPath)) {
         return result;
     }
     const content = readFileSync(cargoPath, 'utf-8');

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

@@ -7,6 +7,14 @@
  * - 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.

package/dist/resolver/languages/typescript.js

@@ -7,9 +7,10 @@
  * - Directory index files
  * - tsconfig path aliases
  */
-import { existsSync, readFileSync } from 'fs';
+import { readFileSync } from 'fs';
 import { dirname, join, resolve as resolvePath } from 'path';
 import { log } from '../../shared/logger';
+import { cachedExists } from '../fs-cache';
 const TS_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
 /**
  * Probe a base path for TS/JS files: try extensions, then index files.
@@ -18,13 +19,13 @@ const TS_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
 function probeExtensions(base) {
     for (const ext of TS_EXTENSIONS) {
         const candidate = base + ext;
-        if (existsSync(candidate)) {
+        if (cachedExists(candidate)) {
             return resolvePath(candidate);
         }
     }
     for (const ext of TS_EXTENSIONS) {
         const candidate = join(base, `index${ext}`);
-        if (existsSync(candidate)) {
+        if (cachedExists(candidate)) {
             return resolvePath(candidate);
         }
     }
@@ -32,6 +33,154 @@ function probeExtensions(base) {
 }
 /** Cache for parsed tsconfig.json (keyed by repoRoot). */
 const tsconfigCache = new Map();
+/** Cache for parsed bundler aliases (keyed by repoRoot). */
+const bundlerAliasCache = new Map();
+/**
+ * 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 function loadBundlerAliases(repoRoot) {
+    const cached = bundlerAliasCache.get(repoRoot);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const aliases = new Map();
+    const configFiles = ['webpack.config.js', 'webpack.config.ts', 'vite.config.js', 'vite.config.ts'];
+    for (const configFile of configFiles) {
+        const configPath = join(repoRoot, configFile);
+        if (!cachedExists(configPath)) {
+            continue;
+        }
+        try {
+            const content = readFileSync(configPath, 'utf-8');
+            parseBundlerAliases(content, repoRoot, aliases);
+        }
+        catch {
+            // config file read failed, continue
+        }
+    }
+    bundlerAliasCache.set(repoRoot, aliases);
+    return aliases;
+}
+/**
+ * Parse alias definitions from a webpack or vite config file content.
+ * Handles:
+ * - path.join(__dirname, 'a', 'b') and path.resolve(__dirname, 'a', 'b')
+ * - Simple string literal values: 'key': '/path/to/dir'
+ * - Variable references like path.join(varName, 'sub') where varName is defined
+ *   earlier as const varName = path.join(__dirname, ...)
+ */
+function parseBundlerAliases(content, repoRoot, aliases) {
+    // First, extract top-level variable definitions like:
+    //   const staticPrefix = path.join(__dirname, 'static')
+    const varDefs = new Map();
+    const varDefRegex = /(?:const|let|var)\s+(\w+)\s*=\s*path\.(?:join|resolve)\s*\(\s*__dirname\s*,\s*([^)]+)\)/g;
+    let varMatch = varDefRegex.exec(content);
+    while (varMatch !== null) {
+        const varName = varMatch[1];
+        const argsStr = varMatch[2];
+        const segments = extractStringArgs(argsStr);
+        if (segments.length > 0) {
+            varDefs.set(varName, join(repoRoot, ...segments));
+        }
+        varMatch = varDefRegex.exec(content);
+    }
+    // Find the alias block — look for alias: { ... } or alias: [ ... ]
+    // We search for "alias:" or "alias :" possibly inside resolve: { ... }
+    const aliasBlockRegex = /alias\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/gs;
+    let aliasMatch = aliasBlockRegex.exec(content);
+    while (aliasMatch !== null) {
+        const aliasBlock = aliasMatch[1];
+        parseAliasEntries(aliasBlock, repoRoot, varDefs, aliases);
+        aliasMatch = aliasBlockRegex.exec(content);
+    }
+}
+/**
+ * Parse individual alias entries from inside an alias block.
+ */
+function parseAliasEntries(block, repoRoot, varDefs, aliases) {
+    // Match entries like:
+    //   key: path.join(__dirname, 'a', 'b'),
+    //   'key': path.join(__dirname, 'a', 'b'),
+    //   "key": path.resolve(__dirname, 'a'),
+    //   key: path.join(varName, 'sub'),
+    //   key: 'literal/path',
+    //   'key': 'literal/path',
+    // Pattern for key (unquoted identifier or quoted string)
+    const keyPattern = /(?:'([^']+)'|"([^"]+)"|(\w+))\s*:\s*/g;
+    let keyMatch = keyPattern.exec(block);
+    while (keyMatch !== null) {
+        const key = keyMatch[1] ?? keyMatch[2] ?? keyMatch[3];
+        const valueStart = keyMatch.index + keyMatch[0].length;
+        const restOfBlock = block.slice(valueStart);
+        const resolvedDir = resolveAliasValue(restOfBlock, repoRoot, varDefs);
+        if (resolvedDir !== null && !aliases.has(`${key}/`) && !aliases.has(key)) {
+            // Use key + '/' as prefix for path-based aliases (like tsconfig aliases)
+            // but if the key already ends with special chars like ~, use as-is
+            const prefix = key.endsWith('/') ? key : `${key}/`;
+            aliases.set(prefix, [resolvedDir]);
+            // Also set exact match (for bare imports like 'sentry' → 'sentry/')
+            if (!aliases.has(key) && key !== prefix) {
+                aliases.set(key, [resolvedDir]);
+            }
+        }
+        keyMatch = keyPattern.exec(block);
+    }
+}
+/**
+ * Try to resolve an alias value expression to an absolute directory.
+ */
+function resolveAliasValue(expr, repoRoot, varDefs) {
+    // path.join(__dirname, 'a', 'b') or path.resolve(__dirname, 'a', 'b')
+    const pathDirnameRegex = /^path\.(?:join|resolve)\s*\(\s*__dirname\s*,\s*([^)]+)\)/;
+    const dirnameMatch = pathDirnameRegex.exec(expr);
+    if (dirnameMatch) {
+        const segments = extractStringArgs(dirnameMatch[1]);
+        if (segments.length > 0) {
+            return join(repoRoot, ...segments);
+        }
+    }
+    // path.join(varName, 'a', 'b') or path.resolve(varName, 'a')
+    const pathVarRegex = /^path\.(?:join|resolve)\s*\(\s*(\w+)\s*(?:,\s*([^)]+))?\)/;
+    const varMatch = pathVarRegex.exec(expr);
+    if (varMatch) {
+        const varName = varMatch[1];
+        if (varName !== '__dirname' && varDefs.has(varName)) {
+            const baseDir = varDefs.get(varName);
+            if (varMatch[2]) {
+                const segments = extractStringArgs(varMatch[2]);
+                if (segments.length > 0) {
+                    return join(baseDir, ...segments);
+                }
+            }
+            return baseDir;
+        }
+    }
+    // Simple string literal: 'path/to/dir' or "path/to/dir"
+    const stringLiteralRegex = /^['"]([^'"]+)['"]/;
+    const strMatch = stringLiteralRegex.exec(expr);
+    if (strMatch) {
+        return join(repoRoot, strMatch[1]);
+    }
+    return null;
+}
+/**
+ * Extract string literal arguments from a comma-separated argument list.
+ * e.g. "'static', 'app'" → ['static', 'app']
+ */
+function extractStringArgs(argsStr) {
+    const segments = [];
+    const argRegex = /['"]([^'"]+)['"]/g;
+    let m = argRegex.exec(argsStr);
+    while (m !== null) {
+        segments.push(m[1]);
+        m = argRegex.exec(argsStr);
+    }
+    return segments;
+}
 function loadTsconfigCompilerOptions(repoRoot) {
     const cached = tsconfigCache.get(repoRoot);
     if (cached !== undefined) {
@@ -39,7 +188,7 @@ function loadTsconfigCompilerOptions(repoRoot) {
     }
     const tsconfigPath = join(repoRoot, 'tsconfig.json');
     let result = {};
-    if (existsSync(tsconfigPath)) {
+    if (cachedExists(tsconfigPath)) {
         try {
             const content = readFileSync(tsconfigPath, 'utf-8');
             const cleaned = stripJsonComments(content);
@@ -72,7 +221,7 @@ export function resolve(fromAbsFile, modulePath, repoRoot) {
     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)) {
+        if (cachedExists(base)) {
             return resolvePath(base);
         }
     }
@@ -177,9 +326,23 @@ function stripJsonComments(str) {
  */
 export function loadTsconfigAliases(repoRoot) {
     const aliases = new Map();
+    loadTsconfigPathsInto(repoRoot, aliases);
+    return aliases;
+}
+/**
+ * Parse a tsconfig.json (and tsconfig.base.json) in the given directory
+ * and add its path aliases to the provided map.
+ */
+function loadTsconfigPathsInto(dir, aliases, visited) {
+    const seen = visited ?? new Set();
+    const absDir = resolvePath(dir);
+    if (seen.has(absDir)) {
+        return;
+    }
+    seen.add(absDir);
     for (const filename of ['tsconfig.json', 'tsconfig.base.json']) {
-        const tsconfigPath = join(repoRoot, filename);
-        if (!existsSync(tsconfigPath)) {
+        const tsconfigPath = join(dir, filename);
+        if (!cachedExists(tsconfigPath)) {
             continue;
         }
         try {
@@ -188,16 +351,30 @@ export function loadTsconfigAliases(repoRoot) {
             const config = JSON.parse(cleaned);
             const paths = config?.compilerOptions?.paths;
             const baseUrl = config?.compilerOptions?.baseUrl || '.';
-            const baseDir = join(repoRoot, baseUrl);
+            const baseDir = join(dir, 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);
+                    if (!aliases.has(prefix)) {
+                        const resolvedTargets = targets.map((t) => {
+                            const targetPath = t.replace('/*', '').replace('*', '');
+                            return join(baseDir, targetPath);
+                        });
+                        aliases.set(prefix, resolvedTargets);
+                    }
+                }
+            }
+            // Follow project references to discover aliases from referenced projects
+            const references = config?.references;
+            if (Array.isArray(references)) {
+                for (const ref of references) {
+                    if (ref && typeof ref.path === 'string') {
+                        const refDir = resolvePath(dir, ref.path);
+                        if (cachedExists(refDir)) {
+                            loadTsconfigPathsInto(refDir, aliases, seen);
+                        }
+                    }
                 }
             }
         }
@@ -205,7 +382,6 @@ export function loadTsconfigAliases(repoRoot) {
             log.warn('Failed to parse tsconfig', { file: tsconfigPath, error: String(err) });
         }
     }
-    return aliases;
 }
 /**
  * Resolve an import path using tsconfig aliases.
@@ -219,18 +395,18 @@ export function resolveWithAliases(modulePath, aliases, _repoRoot) {
             for (const targetBase of targets) {
                 const base = join(targetBase, rest);
                 for (const ext of TS_EXTENSIONS) {
-                    if (existsSync(base + ext)) {
+                    if (cachedExists(base + ext)) {
                         return resolvePath(base + ext);
                     }
                 }
                 for (const ext of TS_EXTENSIONS) {
                     const idx = join(base, `index${ext}`);
-                    if (existsSync(idx)) {
+                    if (cachedExists(idx)) {
                         return resolvePath(idx);
                     }
                 }
                 // Try exact match (for directories with index)
-                if (existsSync(base)) {
+                if (cachedExists(base)) {
                     return resolvePath(base);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodus/kodus-graph",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "Code graph builder for Kodus code review — parses source code into structural graphs with nodes, edges, and analysis",
   "type": "module",
   "main": "./dist/cli.js",