@kodus/kodus-graph 0.2.8 → 0.2.9

package/dist/resolver/import-resolver.js

@@ -0,0 +1,212 @@
+/**
+ * Import resolver dispatcher.
+ *
+ * Routes import resolution to language-specific resolvers and
+ * falls back to tsconfig aliases for TypeScript/JavaScript.
+ */
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, resolve as resolvePath } from 'path';
+import { log } from '../shared/logger';
+import { ensureWithinRoot } from '../shared/safe-path';
+import { resolve as resolveCsImport } from './languages/csharp';
+import { resolve as resolveGoImport } from './languages/go';
+import { resolve as resolveJavaImport } from './languages/java';
+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';
+const RESOLVERS = {
+    ts: resolveTsImport,
+    javascript: resolveTsImport,
+    typescript: resolveTsImport,
+    python: resolvePyImport,
+    ruby: resolveRbImport,
+    go: resolveGoImport,
+    java: resolveJavaImport,
+    rust: resolveRustImport,
+    csharp: resolveCsImport,
+    php: resolvePhpImport,
+};
+/**
+ * Resolve package.json #imports (Node.js subpath imports).
+ * Handles both exact matches and wildcard patterns.
+ */
+function resolveHashImport(modulePath, repoRoot) {
+    const pkgPath = join(repoRoot, 'package.json');
+    if (!existsSync(pkgPath)) {
+        return null;
+    }
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        const imports = pkg?.imports;
+        if (!imports) {
+            return null;
+        }
+        for (const [pattern, target] of Object.entries(imports)) {
+            if (typeof target !== 'string') {
+                continue;
+            }
+            if (pattern === modulePath) {
+                // Exact match: "#utils" -> "./src/shared/utils.ts"
+                const resolved = resolvePath(repoRoot, target);
+                if (existsSync(resolved)) {
+                    return resolved;
+                }
+            }
+            // Wildcard match: "#db/*" -> "./src/db/*.ts"
+            if (pattern.includes('*')) {
+                const prefix = pattern.split('*')[0]; // "#db/"
+                if (modulePath.startsWith(prefix)) {
+                    const rest = modulePath.slice(prefix.length); // "connection"
+                    const resolved = resolvePath(repoRoot, target.replace('*', rest));
+                    if (existsSync(resolved)) {
+                        return resolved;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    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)) {
+        return null;
+    }
+    try {
+        const rootPkg = JSON.parse(readFileSync(rootPkgPath, 'utf-8'));
+        const workspaces = rootPkg?.workspaces;
+        if (!Array.isArray(workspaces)) {
+            return null;
+        }
+        // Collect all workspace package directories
+        const pkgDirs = [];
+        for (const ws of workspaces) {
+            if (ws.endsWith('/*')) {
+                // Glob pattern like "packages/*"
+                const parentDir = join(repoRoot, ws.slice(0, -2));
+                if (existsSync(parentDir)) {
+                    const entries = readdirSync(parentDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory()) {
+                            pkgDirs.push(join(parentDir, entry.name));
+                        }
+                    }
+                }
+            }
+            else {
+                pkgDirs.push(join(repoRoot, ws));
+            }
+        }
+        // Search each workspace package for a matching name + exports
+        for (const pkgDir of pkgDirs) {
+            const pkgJsonPath = join(pkgDir, 'package.json');
+            if (!existsSync(pkgJsonPath)) {
+                continue;
+            }
+            const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+            const pkgName = pkg?.name;
+            if (!pkgName) {
+                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;
+                    }
+                }
+            }
+            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;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return null;
+}
+/**
+ * Resolve an import from one file to another.
+ *
+ * @param fromAbsFile - Absolute path of the importing file
+ * @param modulePath - The import specifier (e.g., './auth', 'express', '@/lib/db')
+ * @param lang - Language key (ts, javascript, typescript, python, ruby, etc.)
+ * @param repoRoot - Absolute path to the repository root
+ * @param tsconfigAliases - Optional pre-loaded tsconfig aliases for TS/JS
+ * @returns Absolute path to the resolved file, or null if unresolvable
+ */
+export function resolveImport(fromAbsFile, modulePath, lang, repoRoot, tsconfigAliases) {
+    const resolver = RESOLVERS[lang];
+    if (!resolver) {
+        return null;
+    }
+    const isTs = lang === 'ts' || lang === 'javascript' || lang === 'typescript';
+    // Handle package.json #imports (TS/JS only)
+    if (isTs && modulePath.startsWith('#')) {
+        const result = resolveHashImport(modulePath, repoRoot);
+        if (result) {
+            try {
+                ensureWithinRoot(result, repoRoot);
+                return result;
+            }
+            catch {
+                log.warn('Import resolves outside repository root', {
+                    from: fromAbsFile,
+                    module: modulePath,
+                    resolved: result,
+                });
+                return null;
+            }
+        }
+    }
+    let result = resolver(fromAbsFile, modulePath, repoRoot);
+    // Fallback: tsconfig aliases for TS/JS
+    if (!result && isTs && tsconfigAliases?.size) {
+        result = resolveWithAliases(modulePath, tsconfigAliases, repoRoot);
+    }
+    // Fallback: monorepo workspace exports for TS/JS bare specifiers
+    if (!result && isTs && !modulePath.startsWith('.')) {
+        result = resolveWorkspaceExport(modulePath, repoRoot);
+    }
+    // Validate resolved path is within repo root
+    if (result) {
+        try {
+            ensureWithinRoot(result, repoRoot);
+        }
+        catch {
+            log.warn('Import resolves outside repository root', {
+                from: fromAbsFile,
+                module: modulePath,
+                resolved: result,
+            });
+            return null;
+        }
+    }
+    return result;
+}
+export { loadTsconfigAliases };

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

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

package/dist/resolver/languages/csharp.js

@@ -0,0 +1,31 @@
+import { existsSync, statSync } from 'fs';
+import { join, resolve as resolvePath } from 'path';
+const STDLIB_PREFIXES = ['System.', 'System', 'Microsoft.', 'Newtonsoft.'];
+export function resolve(_fromAbsFile, modulePath, repoRoot) {
+    if (STDLIB_PREFIXES.some((p) => modulePath.startsWith(p))) {
+        return null;
+    }
+    const segments = modulePath.split('.');
+    // 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']) {
+            const full = join(repoRoot, base, candidate);
+            if (existsSync(full)) {
+                return resolvePath(full);
+            }
+        }
+    }
+    // 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']) {
+            const full = join(repoRoot, base, pathPart);
+            if (existsSync(full) && statSync(full).isDirectory()) {
+                return resolvePath(full);
+            }
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,3 @@
+/** Clear cached go.mod 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/go.js

@@ -0,0 +1,196 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, resolve as resolvePath } from 'path';
+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 (!existsSync(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 (!existsSync(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 (!existsSync(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 (existsSync(absDir)) {
+        try {
+            const files = readdirSync(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 (existsSync(`${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,108 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, resolve as resolvePath } from 'path';
+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 (!existsSync(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 Maven subprojects from pom.xml
+    const pomPath = join(repoRoot, 'pom.xml');
+    if (existsSync(pomPath)) {
+        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);
+            }
+        }
+        catch {
+            // pom.xml read failed, continue
+        }
+    }
+    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 (existsSync(candidate)) {
+                return resolvePath(candidate);
+            }
+        }
+    }
+    return null;
+}
+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 (existsSync(dirPath)) {
+                try {
+                    const files = readdirSync(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,54 @@
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve as resolvePath } from 'path';
+const psr4Cache = new Map();
+/** Clear cached composer.json PSR-4 data. Call between analysis runs or when switching repos. */
+export function clearCache() {
+    psr4Cache.clear();
+}
+function loadPsr4(repoRoot) {
+    const cached = psr4Cache.get(repoRoot);
+    if (cached) {
+        return cached;
+    }
+    const map = new Map();
+    const composerPath = join(repoRoot, 'composer.json');
+    if (existsSync(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) {
+    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)) {
+                return resolvePath(candidate);
+            }
+        }
+    }
+    const relPath = `${modulePath.replace(/\\/g, '/')}.php`;
+    for (const base of ['', 'src', 'lib', 'app']) {
+        const candidate = join(repoRoot, base, relPath);
+        if (existsSync(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,51 @@
+/**
+ * Python import resolver.
+ *
+ * Handles dotted module paths (e.g., "from x.y import z").
+ * Walks up directories to find packages.
+ */
+import { existsSync } from 'fs';
+import { dirname, join, resolve as resolvePath } from 'path';
+/**
+ * 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 (existsSync(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 (existsSync(full)) {
+                return resolvePath(full);
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return null;
+}