@colbymchenry/codegraph-darwin-arm64 0.9.4 → 0.9.6

package/lib/dist/resolution/import-resolver.js

@@ -39,10 +39,13 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveImportPath = resolveImportPath;
+exports.clearCppIncludeDirCache = clearCppIncludeDirCache;
+exports.loadCppIncludeDirs = loadCppIncludeDirs;
 exports.extractImportMappings = extractImportMappings;
 exports.clearImportMappingCache = clearImportMappingCache;
 exports.extractReExports = extractReExports;
 exports.resolveViaImport = resolveViaImport;
+const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const path_aliases_1 = require("./path-aliases");
 /**
@@ -57,9 +60,12 @@ const EXTENSION_RESOLUTION = {
     go: ['.go'],
     rust: ['.rs', '/mod.rs'],
     java: ['.java'],
+    c: ['.h', '.c'],
+    cpp: ['.h', '.hpp', '.hxx', '.cpp', '.cc', '.cxx'],
     csharp: ['.cs'],
     php: ['.php'],
     ruby: ['.rb'],
+    objc: ['.h', '.m', '.mm'],
 };
 /**
  * Resolve an import path to an actual file
@@ -79,8 +85,53 @@ function resolveImportPath(importPath, fromFile, language, context) {
         return resolveRelativeImport(importPath, fromDir, language, context);
     }
     // Handle absolute/aliased imports (like @/ or src/)
-    return resolveAliasedImport(importPath, projectRoot, language, context);
+    const aliased = resolveAliasedImport(importPath, projectRoot, language, context);
+    if (aliased)
+        return aliased;
+    // C/C++ include directory search: when neither relative nor aliased
+    // resolution found a match, search -I directories from
+    // compile_commands.json or heuristic probing.
+    if (language === 'c' || language === 'cpp') {
+        return resolveCppIncludePath(importPath, language, context);
+    }
+    return null;
 }
+/**
+ * C and C++ standard library header names (without delimiters).
+ * Used by isExternalImport to filter system includes from resolution.
+ */
+const C_CPP_STDLIB_HEADERS = new Set([
+    // C standard library headers
+    'assert.h', 'complex.h', 'ctype.h', 'errno.h', 'fenv.h', 'float.h',
+    'inttypes.h', 'iso646.h', 'limits.h', 'locale.h', 'math.h', 'setjmp.h',
+    'signal.h', 'stdalign.h', 'stdarg.h', 'stdatomic.h', 'stdbool.h',
+    'stddef.h', 'stdint.h', 'stdio.h', 'stdlib.h', 'stdnoreturn.h',
+    'string.h', 'tgmath.h', 'threads.h', 'time.h', 'uchar.h', 'wchar.h',
+    'wctype.h',
+    // C++ C-library wrappers (cname form)
+    'cassert', 'ccomplex', 'cctype', 'cerrno', 'cfenv', 'cfloat',
+    'cinttypes', 'ciso646', 'climits', 'clocale', 'cmath', 'csetjmp',
+    'csignal', 'cstdalign', 'cstdarg', 'cstdbool', 'cstddef', 'cstdint',
+    'cstdio', 'cstdlib', 'cstring', 'ctgmath', 'ctime', 'cuchar',
+    'cwchar', 'cwctype',
+    // C++ STL headers
+    'algorithm', 'any', 'array', 'atomic', 'barrier', 'bit', 'bitset',
+    'charconv', 'chrono', 'codecvt', 'compare', 'complex', 'concepts',
+    'condition_variable', 'coroutine', 'deque', 'exception', 'execution',
+    'expected', 'filesystem', 'format', 'forward_list', 'fstream',
+    'functional', 'future', 'generator', 'initializer_list', 'iomanip',
+    'ios', 'iosfwd', 'iostream', 'istream', 'iterator', 'latch',
+    'limits', 'list', 'locale', 'map', 'mdspan', 'memory', 'memory_resource',
+    'mutex', 'new', 'numbers', 'numeric', 'optional', 'ostream', 'print',
+    'queue', 'random', 'ranges', 'ratio', 'regex', 'scoped_allocator',
+    'semaphore', 'set', 'shared_mutex', 'source_location', 'span',
+    'spanstream', 'sstream', 'stack', 'stacktrace', 'stdexcept',
+    'stdfloat', 'stop_token', 'streambuf', 'string', 'string_view',
+    'strstream', 'syncstream', 'system_error', 'thread', 'tuple',
+    'type_traits', 'typeindex', 'typeinfo', 'unordered_map',
+    'unordered_set', 'utility', 'valarray', 'variant', 'vector',
+    'version',
+]);
 /**
  * Check if an import is external (npm package, etc.)
  *
@@ -122,10 +173,35 @@ function isExternalImport(importPath, language, context) {
         }
     }
     if (language === 'go') {
-        // Standard library or external packages
-        if (!importPath.startsWith('.') && !importPath.includes('/internal/')) {
-            return true;
+        // Relative imports (rare in idiomatic Go but the grammar allows them).
+        if (importPath.startsWith('.')) {
+            return false;
         }
+        // In-module imports look like `<module-path>/sub/pkg` — local to
+        // this project. Without the module-path check we'd flag every
+        // cross-package call in a Go monorepo as external (issue #388).
+        const mod = context?.getGoModule?.();
+        if (mod && (importPath === mod.modulePath || importPath.startsWith(mod.modulePath + '/'))) {
+            return false;
+        }
+        // `internal/` packages stay local even when go.mod is missing —
+        // preserves the pre-#388 escape hatch for repos without a parsed module path.
+        if (importPath.includes('/internal/')) {
+            return false;
+        }
+        // Anything else is the Go standard library or a third-party module.
+        return true;
+    }
+    if (language === 'c' || language === 'cpp') {
+        // C/C++ standard library headers — both C-style (<stdio.h>) and
+        // C++-style (<cstdio>, <vector>) forms. Checked against the import
+        // path (which the extractor strips of <> or "" delimiters).
+        if (C_CPP_STDLIB_HEADERS.has(importPath))
+            return true;
+        // C++ headers without .h extension (e.g. "vector", "string")
+        const withoutExt = importPath.replace(/\.h$/, '');
+        if (C_CPP_STDLIB_HEADERS.has(withoutExt))
+            return true;
     }
     return false;
 }
@@ -204,6 +280,215 @@ function resolveAliasedImport(importPath, projectRoot, language, context) {
     // 3. Direct path.
     return tryWithExt(importPath);
 }
+/**
+ * C/C++ include directory cache (keyed by project root).
+ * Loaded once per resolver instance, shared across calls.
+ */
+const cppIncludeDirCache = new Map();
+/**
+ * Clear the C/C++ include directory cache (call between indexing runs)
+ */
+function clearCppIncludeDirCache() {
+    cppIncludeDirCache.clear();
+}
+/**
+ * Discover C/C++ include search directories for a project.
+ *
+ * Strategy:
+ * 1. Look for compile_commands.json (Clang compilation database) in the
+ *    project root and common build subdirectories. Parse -I and -isystem
+ *    flags from compiler commands.
+ * 2. If no compilation database is found, probe for common convention
+ *    directories (include/, src/, lib/, api/) and top-level directories
+ *    containing .h/.hpp files.
+ *
+ * Returns paths relative to projectRoot.
+ */
+function loadCppIncludeDirs(projectRoot) {
+    const cached = cppIncludeDirCache.get(projectRoot);
+    if (cached !== undefined)
+        return cached;
+    const dirs = loadCppIncludeDirsFromCompileDB(projectRoot)
+        || loadCppIncludeDirsHeuristic(projectRoot);
+    cppIncludeDirCache.set(projectRoot, dirs);
+    return dirs;
+}
+/**
+ * Try to load include directories from compile_commands.json.
+ * Returns null if no compilation database is found (so the heuristic
+ * fallback can run). Returns an array (possibly empty) otherwise.
+ */
+function loadCppIncludeDirsFromCompileDB(projectRoot) {
+    const candidates = [
+        path.join(projectRoot, 'compile_commands.json'),
+        path.join(projectRoot, 'build', 'compile_commands.json'),
+        path.join(projectRoot, 'cmake-build-debug', 'compile_commands.json'),
+        path.join(projectRoot, 'cmake-build-release', 'compile_commands.json'),
+        path.join(projectRoot, 'out', 'compile_commands.json'),
+    ];
+    let dbPath;
+    for (const c of candidates) {
+        try {
+            if (fs.existsSync(c)) {
+                dbPath = c;
+                break;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!dbPath)
+        return null;
+    try {
+        const content = fs.readFileSync(dbPath, 'utf-8');
+        const entries = JSON.parse(content);
+        if (!Array.isArray(entries))
+            return null;
+        const dirSet = new Set();
+        for (const entry of entries) {
+            const dir = entry.directory || projectRoot;
+            const args = entry.arguments || (entry.command ? shlexSplit(entry.command) : []);
+            for (let i = 0; i < args.length; i++) {
+                const arg = args[i];
+                let includeDir;
+                // -I<dir> (no space)
+                if (arg.startsWith('-I') && arg.length > 2) {
+                    includeDir = arg.substring(2);
+                }
+                // -isystem <dir> (space-separated)
+                else if ((arg === '-isystem' || arg === '-I') && i + 1 < args.length) {
+                    includeDir = args[i + 1];
+                    i++; // skip next arg
+                }
+                if (includeDir) {
+                    // Normalize: resolve relative to the compilation directory
+                    const absPath = path.isAbsolute(includeDir)
+                        ? includeDir
+                        : path.resolve(dir, includeDir);
+                    const relPath = path.relative(projectRoot, absPath).replace(/\\/g, '/');
+                    // Skip system directories and paths outside the project
+                    // (relative paths starting with .. or absolute paths like
+                    // /usr/include or C:\usr on Windows)
+                    if (!relPath.startsWith('..') && relPath.length > 0 && !path.isAbsolute(relPath)) {
+                        dirSet.add(relPath);
+                    }
+                }
+            }
+        }
+        return Array.from(dirSet);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Minimal shlex-style split for compiler command strings.
+ * Handles double-quoted and single-quoted arguments.
+ */
+function shlexSplit(cmd) {
+    const result = [];
+    let i = 0;
+    while (i < cmd.length) {
+        // Skip whitespace
+        while (i < cmd.length && /\s/.test(cmd[i]))
+            i++;
+        if (i >= cmd.length)
+            break;
+        const ch = cmd[i];
+        if (ch === '"') {
+            i++;
+            let arg = '';
+            while (i < cmd.length && cmd[i] !== '"') {
+                if (cmd[i] === '\\' && i + 1 < cmd.length) {
+                    i++;
+                    arg += cmd[i];
+                }
+                else {
+                    arg += cmd[i];
+                }
+                i++;
+            }
+            i++; // closing quote
+            result.push(arg);
+        }
+        else if (ch === "'") {
+            i++;
+            let arg = '';
+            while (i < cmd.length && cmd[i] !== "'") {
+                arg += cmd[i];
+                i++;
+            }
+            i++; // closing quote
+            result.push(arg);
+        }
+        else {
+            let arg = '';
+            while (i < cmd.length && !/\s/.test(cmd[i])) {
+                arg += cmd[i];
+                i++;
+            }
+            result.push(arg);
+        }
+    }
+    return result;
+}
+/**
+ * Heuristic include directory discovery when no compile_commands.json exists.
+ * Checks common convention directories and scans top-level dirs for headers.
+ */
+function loadCppIncludeDirsHeuristic(projectRoot) {
+    const dirs = [];
+    const conventionDirs = ['include', 'src', 'lib', 'api', 'inc'];
+    try {
+        const entries = fs.readdirSync(projectRoot, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const name = entry.name;
+            // Convention directories
+            if (conventionDirs.includes(name.toLowerCase())) {
+                dirs.push(name);
+                continue;
+            }
+            // Any top-level directory containing .h or .hpp files
+            try {
+                const subFiles = fs.readdirSync(path.join(projectRoot, name));
+                if (subFiles.some(f => /\.(h|hpp|hxx|hh)$/i.test(f))) {
+                    dirs.push(name);
+                }
+            }
+            catch {
+                // ignore permission errors
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return dirs;
+}
+/**
+ * Resolve a C/C++ include path by searching include directories.
+ * Called as a fallback after relative and aliased resolution fail.
+ */
+function resolveCppIncludePath(importPath, language, context) {
+    const includeDirs = context.getCppIncludeDirs?.() ?? [];
+    const extensions = EXTENSION_RESOLUTION[language] ?? [];
+    for (const dir of includeDirs) {
+        const normalizedDir = dir.replace(/\\/g, '/');
+        for (const ext of extensions) {
+            const candidate = normalizedDir + '/' + importPath + ext;
+            if (context.fileExists(candidate))
+                return candidate;
+        }
+        // Try as-is (already has extension)
+        const candidate = normalizedDir + '/' + importPath;
+        if (context.fileExists(candidate))
+            return candidate;
+    }
+    return null;
+}
 /**
  * Extract import mappings from a file
  */
@@ -218,9 +503,15 @@ function extractImportMappings(_filePath, content, language) {
     else if (language === 'go') {
         mappings.push(...extractGoImports(content));
     }
+    else if (language === 'java' || language === 'kotlin') {
+        mappings.push(...extractJavaImports(content));
+    }
     else if (language === 'php') {
         mappings.push(...extractPHPImports(content));
     }
+    else if (language === 'c' || language === 'cpp') {
+        mappings.push(...extractCppImports(content));
+    }
     return mappings;
 }
 /**
@@ -406,6 +697,50 @@ function extractGoImports(content) {
     }
     return mappings;
 }
+/**
+ * Extract Java / Kotlin import mappings.
+ *
+ * Java/Kotlin imports carry the full qualified name of the imported
+ * symbol — `import com.example.dao.converter.FooConverter;` — which is
+ * exactly the disambiguation signal we need when two packages both
+ * declare a `FooConverter`. Pre-#314 the resolver had no Java branch
+ * here at all, so this mapping was empty and cross-module name
+ * collisions were resolved by file-path proximity (often wrongly).
+ *
+ * `import static com.example.Foo.bar;` is parsed as a local-name `bar`
+ * pointing at FQN `com.example.Foo.bar` so static-method call sites
+ * (`bar(...)`) can resolve through the same import lookup.
+ */
+function extractJavaImports(content) {
+    const mappings = [];
+    // Strip line and block comments so `// import foo;` doesn't false-match.
+    const stripped = content
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/\/\/[^\n]*/g, '');
+    // `import [static] <fqn>[.*];`
+    const re = /^\s*import\s+(static\s+)?([\w.]+(?:\.\*)?)\s*;/gm;
+    let match;
+    while ((match = re.exec(stripped)) !== null) {
+        const fqn = match[2];
+        // `import com.example.*;` — wildcard. We can't materialize a single
+        // local name; skip and let name-matching handle members reachable
+        // through the wildcard. (Future enhancement: enumerate package files.)
+        if (fqn.endsWith('.*'))
+            continue;
+        const parts = fqn.split('.');
+        const localName = parts[parts.length - 1];
+        if (!localName)
+            continue;
+        mappings.push({
+            localName,
+            exportedName: localName,
+            source: fqn,
+            isDefault: false,
+            isNamespace: false,
+        });
+    }
+    return mappings;
+}
 /**
  * Extract PHP import mappings (use statements)
  */
@@ -427,6 +762,34 @@ function extractPHPImports(content) {
     }
     return mappings;
 }
+/**
+ * Extract C/C++ import mappings from #include directives.
+ *
+ * #include brings all symbols from the included header into scope
+ * (namespace import), so each mapping uses isNamespace: true and
+ * exportedName: '*'. The localName is set to the header's basename
+ * without extension so that symbol references like `MyClass` can
+ * match against any include that might provide it.
+ */
+function extractCppImports(content) {
+    const mappings = [];
+    // Match both #include <...> and #include "..."
+    const includeRegex = /^\s*#\s*include\s+[<"]([^>"]+)[>"]/gm;
+    let match;
+    while ((match = includeRegex.exec(content)) !== null) {
+        const modulePath = match[1];
+        // Basename without extension for localName matching
+        const basename = modulePath.split('/').pop().replace(/\.(h|hpp|hxx|hh|inl|ipp|cxx|cc|cpp)$/, '');
+        mappings.push({
+            localName: basename || modulePath,
+            exportedName: '*',
+            source: modulePath,
+            isDefault: false,
+            isNamespace: true,
+        });
+    }
+    return mappings;
+}
 // Cache import mappings per file to avoid re-reading and re-parsing
 const importMappingCache = new Map();
 /**
@@ -434,6 +797,7 @@ const importMappingCache = new Map();
  */
 function clearImportMappingCache() {
     importMappingCache.clear();
+    cppIncludeDirCache.clear();
 }
 /**
  * Strip JS line + block comments from `content` while preserving
@@ -557,11 +921,55 @@ function extractReExports(content, language) {
  * Resolve a reference using import mappings
  */
 function resolveViaImport(ref, context) {
+    // C/C++ #include references — resolve directly to the included file
+    // (file→file edge), bypassing symbol lookup. The extractor emits these
+    // with `referenceKind: 'imports'` and `referenceName: <include path>`
+    // (e.g. "uint256.h" or "common/args.h"). Without this branch the
+    // include-dir scan path inside resolveImportPath never produces an
+    // edge — resolveViaImport's symbol lookup below would search the
+    // resolved file for a symbol named like the file extension and fail.
+    if ((ref.language === 'c' || ref.language === 'cpp') && ref.referenceKind === 'imports') {
+        const resolvedPath = resolveImportPath(ref.referenceName, ref.filePath, ref.language, context);
+        if (!resolvedPath)
+            return null;
+        const basename = resolvedPath.split('/').pop();
+        const fileNodes = context.getNodesByName(basename).filter((n) => n.kind === 'file');
+        const fileNode = fileNodes.find((n) => n.filePath === resolvedPath);
+        if (fileNode) {
+            return {
+                original: ref,
+                targetNodeId: fileNode.id,
+                confidence: 0.9,
+                resolvedBy: 'import',
+            };
+        }
+        return null;
+    }
     // Use cached import mappings (avoids re-reading and re-parsing per ref)
     const imports = context.getImportMappings(ref.filePath, ref.language);
     if (imports.length === 0 && !context.readFile(ref.filePath)) {
         return null;
     }
+    // Go cross-package calls: `pkga.FuncX(...)` extracts to referenceName
+    // `pkga.FuncX` and the import `github.com/example/myproject/pkga`
+    // maps to a *package directory* containing one or more .go files.
+    // The generic file-based lookup below can't follow that — issue #388.
+    if (ref.language === 'go') {
+        const goResult = resolveGoCrossPackageReference(ref, imports, context);
+        if (goResult)
+            return goResult;
+    }
+    // Java / Kotlin: imports are FQNs (`import com.example.Foo;`) — no
+    // resolvable file path the JS/TS-style chain below could follow. Look
+    // up the symbol by name and filter to the candidate whose file path
+    // matches the imported FQN. This is the disambiguation signal that
+    // breaks the same-name class collision the path-proximity matcher
+    // can't resolve (issue #314).
+    if (ref.language === 'java' || ref.language === 'kotlin') {
+        const javaResult = resolveJavaImportedReference(ref, imports, context);
+        if (javaResult)
+            return javaResult;
+    }
     // Check if the reference name matches any import
     for (const imp of imports) {
         if (imp.localName === ref.referenceName || ref.referenceName.startsWith(imp.localName + '.')) {
@@ -586,6 +994,132 @@ function resolveViaImport(ref, context) {
     }
     return null;
 }
+/**
+ * Resolve a Java/Kotlin reference whose receiver is the simple name of
+ * an imported FQN: `Foo.bar(...)` where `import com.example.Foo;`. The
+ * imported FQN converts to a file-path suffix (`com/example/Foo.java`
+ * or `.kt`) which uniquely identifies the right symbol when multiple
+ * classes share the same simple name.
+ *
+ * Also handles bare references to the imported class itself
+ * (`new Foo()` extraction emits `Foo` as a `references`/`instantiates`
+ * ref) and `import static <Foo>.bar` style imports of a single member.
+ */
+function resolveJavaImportedReference(ref, imports, context) {
+    if (imports.length === 0)
+        return null;
+    const ext = ref.language === 'kotlin' ? '.kt' : '.java';
+    for (const imp of imports) {
+        const matchesBare = imp.localName === ref.referenceName;
+        const matchesQualified = ref.referenceName.startsWith(imp.localName + '.');
+        if (!matchesBare && !matchesQualified)
+            continue;
+        // Convert FQN to a file-path suffix. `com.example.Foo` ->
+        // `com/example/Foo.java` (or `.kt`). The actual file may live
+        // under any source root (`src/main/java/`, `src/`, etc.), so match
+        // by suffix rather than exact path.
+        const fqnPath = imp.source.replace(/\./g, '/') + ext;
+        // Which symbol name to look up: the class itself, or a member.
+        const memberName = matchesBare
+            ? imp.localName
+            : ref.referenceName.substring(imp.localName.length + 1);
+        const candidates = context.getNodesByName(memberName);
+        for (const node of candidates) {
+            if (node.language !== ref.language)
+                continue;
+            const fp = node.filePath.replace(/\\/g, '/');
+            if (fp.endsWith(fqnPath) || fp.endsWith('/' + fqnPath)) {
+                return {
+                    original: ref,
+                    targetNodeId: node.id,
+                    confidence: 0.9,
+                    resolvedBy: 'import',
+                };
+            }
+        }
+        // `import static com.example.Foo.bar;` — the FQN's tail is the
+        // member name, the part before is the owner class. Look up the
+        // member named `<imp.localName>` (e.g. `bar`) and prefer the
+        // candidate whose file matches the parent FQN's path.
+        if (matchesBare) {
+            const dot = imp.source.lastIndexOf('.');
+            if (dot > 0) {
+                const ownerFqn = imp.source.substring(0, dot);
+                const ownerPath = ownerFqn.replace(/\./g, '/') + ext;
+                for (const node of candidates) {
+                    if (node.language !== ref.language)
+                        continue;
+                    const fp = node.filePath.replace(/\\/g, '/');
+                    if (fp.endsWith(ownerPath) || fp.endsWith('/' + ownerPath)) {
+                        return {
+                            original: ref,
+                            targetNodeId: node.id,
+                            confidence: 0.9,
+                            resolvedBy: 'import',
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Resolve a Go cross-package qualified reference (`pkga.FuncX`) by matching
+ * the package alias against an in-module import, stripping the module prefix
+ * to a project-relative directory, and locating the exported symbol in any
+ * `.go` file under that directory. Returns `null` for stdlib / third-party
+ * imports (no `go.mod`-relative match) so the rest of `resolveViaImport`
+ * can still try the file-based path.
+ */
+function resolveGoCrossPackageReference(ref, imports, context) {
+    const mod = context.getGoModule?.();
+    if (!mod)
+        return null;
+    // Qualified call: receiver before `.`, member after. A bare reference
+    // (no dot) is a same-file/in-package call — handled elsewhere.
+    const dotIdx = ref.referenceName.indexOf('.');
+    if (dotIdx <= 0)
+        return null;
+    const receiver = ref.referenceName.substring(0, dotIdx);
+    const memberName = ref.referenceName.substring(dotIdx + 1);
+    if (!memberName)
+        return null;
+    for (const imp of imports) {
+        if (imp.localName !== receiver)
+            continue;
+        // Only in-module imports map to a known directory.
+        if (imp.source !== mod.modulePath && !imp.source.startsWith(mod.modulePath + '/')) {
+            continue;
+        }
+        const pkgDir = imp.source === mod.modulePath
+            ? ''
+            : imp.source.substring(mod.modulePath.length + 1);
+        // Look up the member by name and pick the candidate whose file lives
+        // directly in the package directory. Match the immediate parent dir
+        // exactly so a call to `pkga.FuncX` doesn't accidentally land on a
+        // `FuncX` declared in `pkga/subpkg/`.
+        const candidates = context.getNodesByName(memberName);
+        for (const node of candidates) {
+            if (node.language !== 'go')
+                continue;
+            if (!node.isExported)
+                continue;
+            const fp = node.filePath.replace(/\\/g, '/');
+            const lastSlash = fp.lastIndexOf('/');
+            const fileDir = lastSlash >= 0 ? fp.substring(0, lastSlash) : '';
+            if (fileDir === pkgDir) {
+                return {
+                    original: ref,
+                    targetNodeId: node.id,
+                    confidence: 0.9,
+                    resolvedBy: 'import',
+                };
+            }
+        }
+    }
+    return null;
+}
 /** Recursive depth cap for re-export chain following. Real codebases
  *  rarely chain barrels more than 2–3 deep; 8 is a generous safety
  *  net that still bounds worst-case work. */