@duytransipher/gitnexus 1.4.6-sipher.0

package/dist/core/ingestion/resolvers/go.js

@@ -0,0 +1,42 @@
+/**
+ * Go package import resolution.
+ * Handles Go module path-based package imports.
+ */
+/**
+ * Extract the package directory suffix from a Go import path.
+ * Returns the suffix string (e.g., "/internal/auth/") or null if invalid.
+ */
+export function resolveGoPackageDir(importPath, goModule) {
+    if (!importPath.startsWith(goModule.modulePath))
+        return null;
+    const relativePkg = importPath.slice(goModule.modulePath.length + 1);
+    if (!relativePkg)
+        return null;
+    return '/' + relativePkg + '/';
+}
+/**
+ * Resolve a Go internal package import to all .go files in the package directory.
+ * Returns an array of file paths.
+ */
+export function resolveGoPackage(importPath, goModule, normalizedFileList, allFileList) {
+    if (!importPath.startsWith(goModule.modulePath))
+        return [];
+    // Strip module path to get relative package path
+    const relativePkg = importPath.slice(goModule.modulePath.length + 1); // e.g., "internal/auth"
+    if (!relativePkg)
+        return [];
+    const pkgSuffix = '/' + relativePkg + '/';
+    const matches = [];
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/"
+        const normalized = '/' + normalizedFileList[i];
+        // File must be directly in the package directory (not a subdirectory)
+        if (normalized.includes(pkgSuffix) && normalized.endsWith('.go') && !normalized.endsWith('_test.go')) {
+            const afterPkg = normalized.substring(normalized.indexOf(pkgSuffix) + pkgSuffix.length);
+            if (!afterPkg.includes('/')) {
+                matches.push(allFileList[i]);
+            }
+        }
+    }
+    return matches;
+}

package/dist/core/ingestion/resolvers/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Language-specific import resolvers.
+ * Extracted from import-processor.ts for maintainability.
+ */
+export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve } from './utils.js';
+export type { SuffixIndex } from './utils.js';
+export { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport } from './jvm.js';
+export { resolveGoPackageDir, resolveGoPackage } from './go.js';
+export type { GoModuleConfig } from './go.js';
+export { resolveCSharpImport, resolveCSharpNamespaceDir } from './csharp.js';
+export type { CSharpProjectConfig } from './csharp.js';
+export { resolvePhpImport } from './php.js';
+export type { ComposerConfig } from './php.js';
+export { resolveRustImport, tryRustModulePath } from './rust.js';
+export { resolveRubyImport } from './ruby.js';
+export { resolvePythonImport } from './python.js';
+export { resolveImportPath, RESOLVE_CACHE_CAP } from './standard.js';
+export type { TsconfigPaths } from './standard.js';

package/dist/core/ingestion/resolvers/index.js

@@ -0,0 +1,13 @@
+/**
+ * Language-specific import resolvers.
+ * Extracted from import-processor.ts for maintainability.
+ */
+export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve } from './utils.js';
+export { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport } from './jvm.js';
+export { resolveGoPackageDir, resolveGoPackage } from './go.js';
+export { resolveCSharpImport, resolveCSharpNamespaceDir } from './csharp.js';
+export { resolvePhpImport } from './php.js';
+export { resolveRustImport, tryRustModulePath } from './rust.js';
+export { resolveRubyImport } from './ruby.js';
+export { resolvePythonImport } from './python.js';
+export { resolveImportPath, RESOLVE_CACHE_CAP } from './standard.js';

package/dist/core/ingestion/resolvers/jvm.d.ts

@@ -0,0 +1,23 @@
+/**
+ * JVM import resolution (Java + Kotlin).
+ * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
+ */
+import type { SuffixIndex } from './utils.js';
+/** Kotlin file extensions for JVM resolver reuse */
+export declare const KOTLIN_EXTENSIONS: readonly string[];
+/**
+ * Append .* to a Kotlin import path if the AST has a wildcard_import sibling node.
+ * Pure function — returns a new string without mutating the input.
+ */
+export declare const appendKotlinWildcard: (importPath: string, importNode: any) => string;
+/**
+ * Resolve a JVM wildcard import (com.example.*) to all matching files.
+ * Works for both Java (.java) and Kotlin (.kt, .kts).
+ */
+export declare function resolveJvmWildcard(importPath: string, normalizedFileList: string[], allFileList: string[], extensions: readonly string[], index?: SuffixIndex): string[];
+/**
+ * Try to resolve a JVM member/static import by stripping the member name.
+ * Java: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
+ * Kotlin: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
+ */
+export declare function resolveJvmMemberImport(importPath: string, normalizedFileList: string[], allFileList: string[], extensions: readonly string[], index?: SuffixIndex): string | null;

package/dist/core/ingestion/resolvers/jvm.js

@@ -0,0 +1,87 @@
+/**
+ * JVM import resolution (Java + Kotlin).
+ * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
+ */
+/** Kotlin file extensions for JVM resolver reuse */
+export const KOTLIN_EXTENSIONS = ['.kt', '.kts'];
+/**
+ * Append .* to a Kotlin import path if the AST has a wildcard_import sibling node.
+ * Pure function — returns a new string without mutating the input.
+ */
+export const appendKotlinWildcard = (importPath, importNode) => {
+    for (let i = 0; i < importNode.childCount; i++) {
+        if (importNode.child(i)?.type === 'wildcard_import') {
+            return importPath.endsWith('.*') ? importPath : `${importPath}.*`;
+        }
+    }
+    return importPath;
+};
+/**
+ * Resolve a JVM wildcard import (com.example.*) to all matching files.
+ * Works for both Java (.java) and Kotlin (.kt, .kts).
+ */
+export function resolveJvmWildcard(importPath, normalizedFileList, allFileList, extensions, index) {
+    // "com.example.util.*" -> "com/example/util"
+    const packagePath = importPath.slice(0, -2).replace(/\./g, '/');
+    if (index) {
+        const candidates = extensions.flatMap(ext => index.getFilesInDir(packagePath, ext));
+        // Filter to only direct children (no subdirectories)
+        const packageSuffix = '/' + packagePath + '/';
+        return candidates.filter(f => {
+            const normalized = f.replace(/\\/g, '/');
+            const idx = normalized.indexOf(packageSuffix);
+            if (idx < 0)
+                return false;
+            const afterPkg = normalized.substring(idx + packageSuffix.length);
+            return !afterPkg.includes('/');
+        });
+    }
+    // Fallback: linear scan
+    const packageSuffix = '/' + packagePath + '/';
+    const matches = [];
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        const normalized = normalizedFileList[i];
+        if (normalized.includes(packageSuffix) &&
+            extensions.some(ext => normalized.endsWith(ext))) {
+            const afterPackage = normalized.substring(normalized.indexOf(packageSuffix) + packageSuffix.length);
+            if (!afterPackage.includes('/')) {
+                matches.push(allFileList[i]);
+            }
+        }
+    }
+    return matches;
+}
+/**
+ * Try to resolve a JVM member/static import by stripping the member name.
+ * Java: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
+ * Kotlin: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
+ */
+export function resolveJvmMemberImport(importPath, normalizedFileList, allFileList, extensions, index) {
+    // Member imports: com.example.Constants.VALUE or com.example.Constants.*
+    // The last segment is a member name if it starts with lowercase, is ALL_CAPS, or is a wildcard
+    const segments = importPath.split('.');
+    if (segments.length < 3)
+        return null;
+    const lastSeg = segments[segments.length - 1];
+    if (lastSeg === '*' || /^[a-z]/.test(lastSeg) || /^[A-Z_]+$/.test(lastSeg)) {
+        const classPath = segments.slice(0, -1).join('/');
+        for (const ext of extensions) {
+            const classSuffix = classPath + ext;
+            if (index) {
+                const result = index.get(classSuffix) || index.getInsensitive(classSuffix);
+                if (result)
+                    return result;
+            }
+            else {
+                const fullSuffix = '/' + classSuffix;
+                for (let i = 0; i < normalizedFileList.length; i++) {
+                    if (normalizedFileList[i].endsWith(fullSuffix) ||
+                        normalizedFileList[i].toLowerCase().endsWith(fullSuffix.toLowerCase())) {
+                        return allFileList[i];
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}

package/dist/core/ingestion/resolvers/php.d.ts

@@ -0,0 +1,15 @@
+/**
+ * PHP PSR-4 import resolution.
+ * Handles use-statement resolution via composer.json autoload mappings.
+ */
+import type { SuffixIndex } from './utils.js';
+/** PHP Composer PSR-4 autoload config */
+export interface ComposerConfig {
+    /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */
+    psr4: Map<string, string>;
+}
+/**
+ * Resolve a PHP use-statement import path using PSR-4 mappings.
+ * e.g. "App\Http\Controllers\UserController" -> "app/Http/Controllers/UserController.php"
+ */
+export declare function resolvePhpImport(importPath: string, composerConfig: ComposerConfig | null, allFiles: Set<string>, normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;

package/dist/core/ingestion/resolvers/php.js

@@ -0,0 +1,35 @@
+/**
+ * PHP PSR-4 import resolution.
+ * Handles use-statement resolution via composer.json autoload mappings.
+ */
+import { suffixResolve } from './utils.js';
+/**
+ * Resolve a PHP use-statement import path using PSR-4 mappings.
+ * e.g. "App\Http\Controllers\UserController" -> "app/Http/Controllers/UserController.php"
+ */
+export function resolvePhpImport(importPath, composerConfig, allFiles, normalizedFileList, allFileList, index) {
+    // Normalize: replace backslashes with forward slashes
+    const normalized = importPath.replace(/\\/g, '/');
+    // Try PSR-4 resolution if composer.json was found
+    if (composerConfig) {
+        // Sort namespaces by length descending (longest match wins)
+        const sorted = [...composerConfig.psr4.entries()].sort((a, b) => b[0].length - a[0].length);
+        for (const [nsPrefix, dirPrefix] of sorted) {
+            const nsPrefixSlash = nsPrefix.replace(/\\/g, '/');
+            if (normalized.startsWith(nsPrefixSlash + '/') || normalized === nsPrefixSlash) {
+                const remainder = normalized.slice(nsPrefixSlash.length).replace(/^\//, '');
+                const filePath = dirPrefix + (remainder ? '/' + remainder : '') + '.php';
+                if (allFiles.has(filePath))
+                    return filePath;
+                if (index) {
+                    const result = index.getInsensitive(filePath);
+                    if (result)
+                        return result;
+                }
+            }
+        }
+    }
+    // Fallback: suffix matching (works without composer.json)
+    const pathParts = normalized.split('/').filter(Boolean);
+    return suffixResolve(pathParts, normalizedFileList, allFileList, index);
+}

package/dist/core/ingestion/resolvers/python.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Python import resolution — PEP 328 relative imports and proximity-based bare imports.
+ * Import system spec: PEP 302 (original), PEP 451 (current).
+ */
+/**
+ * Resolve a Python import to a file path.
+ *
+ * 1. Relative (PEP 328): `.module`, `..module` — 1 dot = current package, each extra dot goes up one level.
+ * 2. Proximity bare import: static heuristic — checks the importer's own directory first.
+ *    Approximates the common case where co-located files find each other without an installed package.
+ *    Single-segment only — multi-segment (e.g. `os.path`) falls through to suffixResolve.
+ *    Checks package (__init__.py) before module (.py), matching CPython's finder order (PEP 451 §4).
+ *    Coexistence of both is physically impossible (same name = file vs directory), so the order
+ *    only matters for spec compliance.
+ *    Note: namespace packages (PEP 420, directory without __init__.py) are not handled.
+ *
+ * Returns null to let the caller fall through to suffixResolve.
+ */
+export declare function resolvePythonImport(currentFile: string, importPath: string, allFiles: Set<string>): string | null;

package/dist/core/ingestion/resolvers/python.js

@@ -0,0 +1,52 @@
+/**
+ * Python import resolution — PEP 328 relative imports and proximity-based bare imports.
+ * Import system spec: PEP 302 (original), PEP 451 (current).
+ */
+import { tryResolveWithExtensions } from './utils.js';
+/**
+ * Resolve a Python import to a file path.
+ *
+ * 1. Relative (PEP 328): `.module`, `..module` — 1 dot = current package, each extra dot goes up one level.
+ * 2. Proximity bare import: static heuristic — checks the importer's own directory first.
+ *    Approximates the common case where co-located files find each other without an installed package.
+ *    Single-segment only — multi-segment (e.g. `os.path`) falls through to suffixResolve.
+ *    Checks package (__init__.py) before module (.py), matching CPython's finder order (PEP 451 §4).
+ *    Coexistence of both is physically impossible (same name = file vs directory), so the order
+ *    only matters for spec compliance.
+ *    Note: namespace packages (PEP 420, directory without __init__.py) are not handled.
+ *
+ * Returns null to let the caller fall through to suffixResolve.
+ */
+export function resolvePythonImport(currentFile, importPath, allFiles) {
+    // Relative import — PEP 328 (https://peps.python.org/pep-0328/)
+    if (importPath.startsWith('.')) {
+        const dotMatch = importPath.match(/^(\.+)(.*)/);
+        if (!dotMatch)
+            return null;
+        const dotCount = dotMatch[1].length;
+        const modulePart = dotMatch[2];
+        const dirParts = currentFile.split('/').slice(0, -1);
+        // PEP 328: more dots than directory levels → beyond top-level package → invalid
+        if (dotCount - 1 > dirParts.length)
+            return null;
+        for (let i = 1; i < dotCount; i++)
+            dirParts.pop();
+        if (modulePart) {
+            dirParts.push(...modulePart.replace(/\./g, '/').split('/'));
+        }
+        return tryResolveWithExtensions(dirParts.join('/'), allFiles);
+    }
+    // Proximity bare import — single-segment only; package before module (PEP 451 §4)
+    const pathLike = importPath.replace(/\./g, '/');
+    if (pathLike.includes('/'))
+        return null;
+    // Normalize for Windows backslashes
+    const importerDir = currentFile.replace(/\\/g, '/').split('/').slice(0, -1).join('/');
+    if (!importerDir)
+        return null;
+    if (allFiles.has(`${importerDir}/${pathLike}/__init__.py`))
+        return `${importerDir}/${pathLike}/__init__.py`;
+    if (allFiles.has(`${importerDir}/${pathLike}.py`))
+        return `${importerDir}/${pathLike}.py`;
+    return null;
+}

package/dist/core/ingestion/resolvers/ruby.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Ruby require/require_relative import resolution.
+ * Handles path resolution for Ruby's require and require_relative calls.
+ */
+import type { SuffixIndex } from './utils.js';
+/**
+ * Resolve a Ruby require/require_relative path to a matching .rb file.
+ *
+ * require_relative paths are pre-normalized to './' prefix by the caller.
+ * require paths use suffix matching (gem-style paths like 'json', 'net/http').
+ */
+export declare function resolveRubyImport(importPath: string, normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;

package/dist/core/ingestion/resolvers/ruby.js

@@ -0,0 +1,15 @@
+/**
+ * Ruby require/require_relative import resolution.
+ * Handles path resolution for Ruby's require and require_relative calls.
+ */
+import { suffixResolve } from './utils.js';
+/**
+ * Resolve a Ruby require/require_relative path to a matching .rb file.
+ *
+ * require_relative paths are pre-normalized to './' prefix by the caller.
+ * require paths use suffix matching (gem-style paths like 'json', 'net/http').
+ */
+export function resolveRubyImport(importPath, normalizedFileList, allFileList, index) {
+    const pathParts = importPath.replace(/^\.\//, '').split('/').filter(Boolean);
+    return suffixResolve(pathParts, normalizedFileList, allFileList, index);
+}

package/dist/core/ingestion/resolvers/rust.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rust module import resolution.
+ * Handles crate::, super::, self:: prefix paths and :: separators.
+ */
+/**
+ * Resolve Rust use-path to a file.
+ * Handles crate::, super::, self:: prefixes and :: path separators.
+ */
+export declare function resolveRustImport(currentFile: string, importPath: string, allFiles: Set<string>): string | null;
+/**
+ * Try to resolve a Rust module path to a file.
+ * Tries: path.rs, path/mod.rs, and with the last segment stripped
+ * (last segment might be a symbol name, not a module).
+ */
+export declare function tryRustModulePath(modulePath: string, allFiles: Set<string>): string | null;

package/dist/core/ingestion/resolvers/rust.js

@@ -0,0 +1,73 @@
+/**
+ * Rust module import resolution.
+ * Handles crate::, super::, self:: prefix paths and :: separators.
+ */
+/**
+ * Resolve Rust use-path to a file.
+ * Handles crate::, super::, self:: prefixes and :: path separators.
+ */
+export function resolveRustImport(currentFile, importPath, allFiles) {
+    let rustPath;
+    if (importPath.startsWith('crate::')) {
+        // crate:: resolves from src/ directory (standard Rust layout)
+        rustPath = importPath.slice(7).replace(/::/g, '/');
+        // Try from src/ (standard layout)
+        const fromSrc = tryRustModulePath('src/' + rustPath, allFiles);
+        if (fromSrc)
+            return fromSrc;
+        // Try from repo root (non-standard)
+        const fromRoot = tryRustModulePath(rustPath, allFiles);
+        if (fromRoot)
+            return fromRoot;
+        return null;
+    }
+    if (importPath.startsWith('super::')) {
+        // super:: = parent directory of current file's module
+        const currentDir = currentFile.split('/').slice(0, -1);
+        currentDir.pop(); // Go up one level for super::
+        rustPath = importPath.slice(7).replace(/::/g, '/');
+        const fullPath = [...currentDir, rustPath].join('/');
+        return tryRustModulePath(fullPath, allFiles);
+    }
+    if (importPath.startsWith('self::')) {
+        // self:: = current module's directory
+        const currentDir = currentFile.split('/').slice(0, -1);
+        rustPath = importPath.slice(6).replace(/::/g, '/');
+        const fullPath = [...currentDir, rustPath].join('/');
+        return tryRustModulePath(fullPath, allFiles);
+    }
+    // Bare path without prefix (e.g., from a use in a nested module)
+    // Convert :: to / and try suffix matching
+    if (importPath.includes('::')) {
+        rustPath = importPath.replace(/::/g, '/');
+        return tryRustModulePath(rustPath, allFiles);
+    }
+    return null;
+}
+/**
+ * Try to resolve a Rust module path to a file.
+ * Tries: path.rs, path/mod.rs, and with the last segment stripped
+ * (last segment might be a symbol name, not a module).
+ */
+export function tryRustModulePath(modulePath, allFiles) {
+    // Try direct: path.rs
+    if (allFiles.has(modulePath + '.rs'))
+        return modulePath + '.rs';
+    // Try directory: path/mod.rs
+    if (allFiles.has(modulePath + '/mod.rs'))
+        return modulePath + '/mod.rs';
+    // Try path/lib.rs (for crate root)
+    if (allFiles.has(modulePath + '/lib.rs'))
+        return modulePath + '/lib.rs';
+    // The last segment might be a symbol (function, struct, etc.), not a module.
+    // Strip it and try again.
+    const lastSlash = modulePath.lastIndexOf('/');
+    if (lastSlash > 0) {
+        const parentPath = modulePath.substring(0, lastSlash);
+        if (allFiles.has(parentPath + '.rs'))
+            return parentPath + '.rs';
+        if (allFiles.has(parentPath + '/mod.rs'))
+            return parentPath + '/mod.rs';
+    }
+    return null;
+}

package/dist/core/ingestion/resolvers/standard.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Standard import path resolution.
+ * Handles relative imports, path alias rewriting, and generic suffix matching.
+ * Used as the fallback when language-specific resolvers don't match.
+ */
+import type { SuffixIndex } from './utils.js';
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+/** TypeScript path alias config parsed from tsconfig.json */
+export interface TsconfigPaths {
+    /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
+    aliases: Map<string, string>;
+    /** Base URL for path resolution (relative to repo root) */
+    baseUrl: string;
+}
+/** Max entries in the resolve cache. Beyond this, entries are evicted.
+ *  100K entries ≈ 15MB — covers the most common import patterns. */
+export declare const RESOLVE_CACHE_CAP = 100000;
+/**
+ * Resolve an import path to a file path in the repository.
+ *
+ * Language-specific preprocessing is applied before the generic resolution:
+ * - TypeScript/JavaScript: rewrites tsconfig path aliases
+ * - Rust: converts crate::/super::/self:: to relative paths
+ *
+ * Java wildcards and Go package imports are handled separately in processImports
+ * because they resolve to multiple files.
+ */
+export declare const resolveImportPath: (currentFile: string, importPath: string, allFiles: Set<string>, allFileList: string[], normalizedFileList: string[], resolveCache: Map<string, string | null>, language: SupportedLanguages, tsconfigPaths: TsconfigPaths | null, index?: SuffixIndex) => string | null;

package/dist/core/ingestion/resolvers/standard.js

@@ -0,0 +1,123 @@
+/**
+ * Standard import path resolution.
+ * Handles relative imports, path alias rewriting, and generic suffix matching.
+ * Used as the fallback when language-specific resolvers don't match.
+ */
+import { tryResolveWithExtensions, suffixResolve } from './utils.js';
+import { resolveRustImport } from './rust.js';
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+/** Max entries in the resolve cache. Beyond this, entries are evicted.
+ *  100K entries ≈ 15MB — covers the most common import patterns. */
+export const RESOLVE_CACHE_CAP = 100_000;
+/**
+ * Resolve an import path to a file path in the repository.
+ *
+ * Language-specific preprocessing is applied before the generic resolution:
+ * - TypeScript/JavaScript: rewrites tsconfig path aliases
+ * - Rust: converts crate::/super::/self:: to relative paths
+ *
+ * Java wildcards and Go package imports are handled separately in processImports
+ * because they resolve to multiple files.
+ */
+export const resolveImportPath = (currentFile, importPath, allFiles, allFileList, normalizedFileList, resolveCache, language, tsconfigPaths, index) => {
+    const cacheKey = `${currentFile}::${importPath}`;
+    if (resolveCache.has(cacheKey))
+        return resolveCache.get(cacheKey) ?? null;
+    const cache = (result) => {
+        // Evict oldest 20% when cap is reached instead of clearing all
+        if (resolveCache.size >= RESOLVE_CACHE_CAP) {
+            const evictCount = Math.floor(RESOLVE_CACHE_CAP * 0.2);
+            const iter = resolveCache.keys();
+            for (let i = 0; i < evictCount; i++) {
+                const key = iter.next().value;
+                if (key !== undefined)
+                    resolveCache.delete(key);
+            }
+        }
+        resolveCache.set(cacheKey, result);
+        return result;
+    };
+    // ---- TypeScript/JavaScript: rewrite path aliases ----
+    if ((language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) &&
+        tsconfigPaths &&
+        !importPath.startsWith('.')) {
+        for (const [aliasPrefix, targetPrefix] of tsconfigPaths.aliases) {
+            if (importPath.startsWith(aliasPrefix)) {
+                const remainder = importPath.slice(aliasPrefix.length);
+                // Build the rewritten path relative to baseUrl
+                const rewritten = tsconfigPaths.baseUrl === '.'
+                    ? targetPrefix + remainder
+                    : tsconfigPaths.baseUrl + '/' + targetPrefix + remainder;
+                // Try direct resolution from repo root
+                const resolved = tryResolveWithExtensions(rewritten, allFiles);
+                if (resolved)
+                    return cache(resolved);
+                // Try suffix matching as fallback
+                const parts = rewritten.split('/').filter(Boolean);
+                const suffixResult = suffixResolve(parts, normalizedFileList, allFileList, index);
+                if (suffixResult)
+                    return cache(suffixResult);
+            }
+        }
+    }
+    // ---- Rust: convert module path syntax to file paths ----
+    if (language === SupportedLanguages.Rust) {
+        // Handle grouped imports: use crate::module::{Foo, Bar, Baz}
+        // Extract the prefix path before ::{...} and resolve the module, not the symbols
+        let rustImportPath = importPath;
+        const braceIdx = importPath.indexOf('::{');
+        if (braceIdx !== -1) {
+            rustImportPath = importPath.substring(0, braceIdx);
+        }
+        else if (importPath.startsWith('{') && importPath.endsWith('}')) {
+            // Top-level grouped imports: use {crate::a, crate::b}
+            // Iterate each part and return the first that resolves. This function returns a single
+            // string, so callers that need ALL edges must intercept before reaching here (see the
+            // Rust grouped-import blocks in processImports / processImportsBatch). This fallback
+            // handles any path that reaches resolveImportPath directly.
+            const inner = importPath.slice(1, -1);
+            const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
+            for (const part of parts) {
+                const partResult = resolveRustImport(currentFile, part, allFiles);
+                if (partResult)
+                    return cache(partResult);
+            }
+            return cache(null);
+        }
+        const rustResult = resolveRustImport(currentFile, rustImportPath, allFiles);
+        if (rustResult)
+            return cache(rustResult);
+        // Fall through to generic resolution if Rust-specific didn't match
+    }
+    // ---- Generic relative import resolution (./ and ../) ----
+    const currentDir = currentFile.split('/').slice(0, -1);
+    const parts = importPath.split('/');
+    for (const part of parts) {
+        if (part === '.')
+            continue;
+        if (part === '..') {
+            currentDir.pop();
+        }
+        else {
+            currentDir.push(part);
+        }
+    }
+    const basePath = currentDir.join('/');
+    if (importPath.startsWith('.')) {
+        const resolved = tryResolveWithExtensions(basePath, allFiles);
+        return cache(resolved);
+    }
+    // ---- Generic package/absolute import resolution (suffix matching) ----
+    // Java wildcards are handled in processImports, not here
+    if (importPath.endsWith('.*')) {
+        return cache(null);
+    }
+    // C/C++ includes use actual file paths (e.g. "animal.h") — don't convert dots to slashes
+    const isCpp = language === SupportedLanguages.C || language === SupportedLanguages.CPlusPlus;
+    const pathLike = importPath.includes('/') || isCpp
+        ? importPath
+        : importPath.replace(/\./g, '/');
+    const pathParts = pathLike.split('/').filter(Boolean);
+    const resolved = suffixResolve(pathParts, normalizedFileList, allFileList, index);
+    return cache(resolved);
+};

package/dist/core/ingestion/resolvers/utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared utilities for import resolution.
+ * Extracted from import-processor.ts to reduce file size.
+ */
+/** All file extensions to try during resolution */
+export declare const EXTENSIONS: string[];
+/**
+ * Try to match a path (with extensions) against the known file set.
+ * Returns the matched file path or null.
+ */
+export declare function tryResolveWithExtensions(basePath: string, allFiles: Set<string>): string | null;
+/**
+ * Build a suffix index for O(1) endsWith lookups.
+ * Maps every possible path suffix to its original file path.
+ * e.g. for "src/com/example/Foo.java":
+ *   "Foo.java" -> "src/com/example/Foo.java"
+ *   "example/Foo.java" -> "src/com/example/Foo.java"
+ *   "com/example/Foo.java" -> "src/com/example/Foo.java"
+ *   etc.
+ */
+export interface SuffixIndex {
+    /** Exact suffix lookup (case-sensitive) */
+    get(suffix: string): string | undefined;
+    /** Case-insensitive suffix lookup */
+    getInsensitive(suffix: string): string | undefined;
+    /** Get all files in a directory suffix */
+    getFilesInDir(dirSuffix: string, extension: string): string[];
+}
+export declare function buildSuffixIndex(normalizedFileList: string[], allFileList: string[]): SuffixIndex;
+/**
+ * Suffix-based resolution using index. O(1) per lookup instead of O(files).
+ */
+export declare function suffixResolve(pathParts: string[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;