gitnexus 1.3.10 → 1.4.0

package/dist/core/ingestion/pipeline.js

@@ -1,9 +1,10 @@
 import { createKnowledgeGraph } from '../graph/graph.js';
 import { processStructure } from './structure-processor.js';
 import { processParsing } from './parsing-processor.js';
-import { processImports, processImportsFromExtracted, createImportMap, buildImportResolutionContext } from './import-processor.js';
+import { processImports, processImportsFromExtracted, createImportMap, createPackageMap, createNamedImportMap, buildImportResolutionContext } from './import-processor.js';
 import { processCalls, processCallsFromExtracted, processRoutesFromExtracted } from './call-processor.js';
 import { processHeritage, processHeritageFromExtracted } from './heritage-processor.js';
+import { computeMRO } from './mro-processor.js';
 import { processCommunities } from './community-processor.js';
 import { processProcesses } from './process-processor.js';
 import { createSymbolTable } from './symbol-table.js';
@@ -12,6 +13,9 @@ import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
 import { getLanguageFromFilename } from './utils.js';
 import { isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { createWorkerPool } from './workers/worker-pool.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 const isDev = process.env.NODE_ENV === 'development';
 /** Max bytes of source content to load per parse chunk. Each chunk's source +
  *  parsed ASTs + extracted records + worker serialization overhead all live in
@@ -25,6 +29,8 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
     const symbolTable = createSymbolTable();
     let astCache = createASTCache(AST_CACHE_CAP);
     const importMap = createImportMap();
+    const packageMap = createPackageMap();
+    const namedImportMap = createNamedImportMap();
     const cleanup = () => {
         astCache.clear();
         symbolTable.clear();
@@ -124,11 +130,21 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         // Create worker pool once, reuse across chunks
         let workerPool;
         try {
-            const workerUrl = new URL('./workers/parse-worker.js', import.meta.url);
+            let workerUrl = new URL('./workers/parse-worker.js', import.meta.url);
+            // When running under vitest, import.meta.url points to src/ where no .js exists.
+            // Fall back to the compiled dist/ worker so the pool can spawn real worker threads.
+            const thisDir = fileURLToPath(new URL('.', import.meta.url));
+            if (!fs.existsSync(fileURLToPath(workerUrl))) {
+                const distWorker = path.resolve(thisDir, '..', '..', '..', 'dist', 'core', 'ingestion', 'workers', 'parse-worker.js');
+                if (fs.existsSync(distWorker)) {
+                    workerUrl = pathToFileURL(distWorker);
+                }
+            }
             workerPool = createWorkerPool(workerUrl);
         }
         catch (err) {
-            // Worker pool creation failed — sequential fallback
+            if (isDev)
+                console.warn('Worker pool creation failed, using sequential fallback:', err.message);
         }
         let filesParsedSoFar = 0;
         // AST cache sized for one chunk (sequential fallback uses it for import/call/heritage)
@@ -165,22 +181,18 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
                 }, workerPool);
                 if (chunkWorkerData) {
                     // Imports
-                    await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, importMap, undefined, repoPath, importCtx);
-                    // Calls — resolve immediately, then free the array
-                    if (chunkWorkerData.calls.length > 0) {
-                        await processCallsFromExtracted(graph, chunkWorkerData.calls, symbolTable, importMap);
-                    }
-                    // Heritage — resolve immediately, then free
-                    if (chunkWorkerData.heritage.length > 0) {
-                        await processHeritageFromExtracted(graph, chunkWorkerData.heritage, symbolTable);
-                    }
-                    // Routes — resolve immediately (Laravel route→controller CALLS edges)
-                    if (chunkWorkerData.routes && chunkWorkerData.routes.length > 0) {
-                        await processRoutesFromExtracted(graph, chunkWorkerData.routes, symbolTable, importMap);
-                    }
+                    await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, importMap, undefined, repoPath, importCtx, packageMap, namedImportMap);
+                    // Calls + Heritage + Routes — resolve in parallel (no shared mutable state between them)
+                    // This is safe because each writes disjoint relationship types into idempotent id-keyed Maps,
+                    // and the single-threaded event loop prevents races between synchronous addRelationship calls.
+                    await Promise.all([
+                        processCallsFromExtracted(graph, chunkWorkerData.calls, symbolTable, importMap, packageMap, undefined, namedImportMap),
+                        processHeritageFromExtracted(graph, chunkWorkerData.heritage, symbolTable, importMap, packageMap),
+                        processRoutesFromExtracted(graph, chunkWorkerData.routes ?? [], symbolTable, importMap, packageMap),
+                    ]);
                 }
                 else {
-                    await processImports(graph, chunkFiles, astCache, importMap, undefined, repoPath, allPaths);
+                    await processImports(graph, chunkFiles, astCache, importMap, undefined, repoPath, allPaths, packageMap, namedImportMap);
                     sequentialChunkPaths.push(chunkPaths);
                 }
                 filesParsedSoFar += chunkFiles.length;
@@ -199,8 +211,8 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
                 .filter(p => chunkContents.has(p))
                 .map(p => ({ path: p, content: chunkContents.get(p) }));
             astCache = createASTCache(chunkFiles.length);
-            await processCalls(graph, chunkFiles, astCache, symbolTable, importMap);
-            await processHeritage(graph, chunkFiles, astCache, symbolTable);
+            await processCalls(graph, chunkFiles, astCache, symbolTable, importMap, packageMap, undefined, namedImportMap);
+            await processHeritage(graph, chunkFiles, astCache, symbolTable, importMap, packageMap);
             astCache.clear();
         }
         // Free import resolution context — suffix index + resolve cache no longer needed
@@ -209,13 +221,16 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         importCtx.resolveCache.clear();
         importCtx.suffixIndex = null;
         importCtx.normalizedFileList = null;
-        if (isDev) {
-            let importsCount = 0;
-            for (const r of graph.iterRelationships()) {
-                if (r.type === 'IMPORTS')
-                    importsCount++;
-            }
-            console.log(`📊 Pipeline: graph has ${importsCount} IMPORTS, ${graph.relationshipCount} total relationships`);
+        // ── Phase 4.5: Method Resolution Order ──────────────────────────────
+        onProgress({
+            phase: 'parsing',
+            percent: 81,
+            message: 'Computing method resolution order...',
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+        });
+        const mroResult = computeMRO(graph);
+        if (isDev && mroResult.entries.length > 0) {
+            console.log(`🔀 MRO: ${mroResult.entries.length} classes analyzed, ${mroResult.ambiguityCount} ambiguities found, ${mroResult.overrideEdges} OVERRIDES edges`);
         }
         // ── Phase 5: Communities ───────────────────────────────────────────
         onProgress({

package/dist/core/ingestion/process-processor.js

@@ -10,6 +10,7 @@
  * Processes help agents understand how features work through the codebase.
  */
 import { calculateEntryPointScore, isTestFile } from './entry-point-scoring.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
 const isDev = process.env.NODE_ENV === 'development';
 const DEFAULT_CONFIG = {
     maxTraceDepth: 10,
@@ -178,7 +179,7 @@ const findEntryPoints = (graph, reverseCallsEdges, callsEdges) => {
         if (callees.length === 0)
             continue;
         // Calculate entry point score using new scoring system
-        const { score: baseScore, reasons } = calculateEntryPointScore(node.properties.name, node.properties.language || 'javascript', node.properties.isExported ?? false, callers.length, callees.length, filePath // Pass filePath for framework detection
+        const { score: baseScore, reasons } = calculateEntryPointScore(node.properties.name, node.properties.language ?? SupportedLanguages.JavaScript, node.properties.isExported ?? false, callers.length, callees.length, filePath // Pass filePath for framework detection
         );
         let score = baseScore;
         const astFrameworkMultiplier = node.properties.astFrameworkMultiplier ?? 1.0;

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

@@ -0,0 +1,22 @@
+/**
+ * C# namespace import resolution.
+ * Handles using-directive resolution via .csproj root namespace stripping.
+ */
+import type { SuffixIndex } from './utils.js';
+/** C# project config parsed from .csproj files */
+export interface CSharpProjectConfig {
+    /** Root namespace from <RootNamespace> or assembly name (default: project directory name) */
+    rootNamespace: string;
+    /** Directory containing the .csproj file */
+    projectDir: string;
+}
+/**
+ * Resolve a C# using-directive import path to matching .cs files.
+ * Tries single-file match first, then directory match for namespace imports.
+ */
+export declare function resolveCSharpImport(importPath: string, csharpConfigs: CSharpProjectConfig[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string[];
+/**
+ * Compute the directory suffix for a C# namespace import (for PackageMap).
+ * Returns a suffix like "/ProjectDir/Models/" or null if no config matches.
+ */
+export declare function resolveCSharpNamespaceDir(importPath: string, csharpConfigs: CSharpProjectConfig[]): string | null;

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

@@ -0,0 +1,109 @@
+/**
+ * C# namespace import resolution.
+ * Handles using-directive resolution via .csproj root namespace stripping.
+ */
+import { suffixResolve } from './utils.js';
+/**
+ * Resolve a C# using-directive import path to matching .cs files.
+ * Tries single-file match first, then directory match for namespace imports.
+ */
+export function resolveCSharpImport(importPath, csharpConfigs, normalizedFileList, allFileList, index) {
+    const namespacePath = importPath.replace(/\./g, '/');
+    const results = [];
+    for (const config of csharpConfigs) {
+        const nsPath = config.rootNamespace.replace(/\./g, '/');
+        let relative;
+        if (namespacePath.startsWith(nsPath + '/')) {
+            relative = namespacePath.slice(nsPath.length + 1);
+        }
+        else if (namespacePath === nsPath) {
+            // The import IS the root namespace — resolve to all .cs files in project root
+            relative = '';
+        }
+        else {
+            continue;
+        }
+        const dirPrefix = config.projectDir
+            ? (relative ? config.projectDir + '/' + relative : config.projectDir)
+            : relative;
+        // 1. Try as single file: relative.cs (e.g., "Models/DlqMessage.cs")
+        if (relative) {
+            const candidate = dirPrefix + '.cs';
+            if (index) {
+                const result = index.get(candidate) || index.getInsensitive(candidate);
+                if (result)
+                    return [result];
+            }
+            // Also try suffix match
+            const suffixResult = index?.get(relative + '.cs') || index?.getInsensitive(relative + '.cs');
+            if (suffixResult)
+                return [suffixResult];
+        }
+        // 2. Try as directory: all .cs files directly inside (namespace import)
+        if (index) {
+            const dirFiles = index.getFilesInDir(dirPrefix, '.cs');
+            for (const f of dirFiles) {
+                const normalized = f.replace(/\\/g, '/');
+                // Check it's a direct child by finding the dirPrefix and ensuring no deeper slashes
+                const prefixIdx = normalized.indexOf(dirPrefix + '/');
+                if (prefixIdx < 0)
+                    continue;
+                const afterDir = normalized.substring(prefixIdx + dirPrefix.length + 1);
+                if (!afterDir.includes('/')) {
+                    results.push(f);
+                }
+            }
+            if (results.length > 0)
+                return results;
+        }
+        // 3. Linear scan fallback for directory matching
+        if (results.length === 0) {
+            const dirTrail = dirPrefix + '/';
+            for (let i = 0; i < normalizedFileList.length; i++) {
+                const normalized = normalizedFileList[i];
+                if (!normalized.endsWith('.cs'))
+                    continue;
+                const prefixIdx = normalized.indexOf(dirTrail);
+                if (prefixIdx < 0)
+                    continue;
+                const afterDir = normalized.substring(prefixIdx + dirTrail.length);
+                if (!afterDir.includes('/')) {
+                    results.push(allFileList[i]);
+                }
+            }
+            if (results.length > 0)
+                return results;
+        }
+    }
+    // Fallback: suffix matching without namespace stripping (single file)
+    const pathParts = namespacePath.split('/').filter(Boolean);
+    const fallback = suffixResolve(pathParts, normalizedFileList, allFileList, index);
+    return fallback ? [fallback] : [];
+}
+/**
+ * Compute the directory suffix for a C# namespace import (for PackageMap).
+ * Returns a suffix like "/ProjectDir/Models/" or null if no config matches.
+ */
+export function resolveCSharpNamespaceDir(importPath, csharpConfigs) {
+    const namespacePath = importPath.replace(/\./g, '/');
+    for (const config of csharpConfigs) {
+        const nsPath = config.rootNamespace.replace(/\./g, '/');
+        let relative;
+        if (namespacePath.startsWith(nsPath + '/')) {
+            relative = namespacePath.slice(nsPath.length + 1);
+        }
+        else if (namespacePath === nsPath) {
+            relative = '';
+        }
+        else {
+            continue;
+        }
+        const dirPrefix = config.projectDir
+            ? (relative ? config.projectDir + '/' + relative : config.projectDir)
+            : relative;
+        if (!dirPrefix)
+            continue;
+        return '/' + dirPrefix + '/';
+    }
+    return null;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Go package import resolution.
+ * Handles Go module path-based package imports.
+ */
+/** Go module config parsed from go.mod */
+export interface GoModuleConfig {
+    /** Module path (e.g., "github.com/user/repo") */
+    modulePath: string;
+}
+/**
+ * Extract the package directory suffix from a Go import path.
+ * Returns the suffix string (e.g., "/internal/auth/") or null if invalid.
+ */
+export declare function resolveGoPackageDir(importPath: string, goModule: GoModuleConfig): string | null;
+/**
+ * Resolve a Go internal package import to all .go files in the package directory.
+ * Returns an array of file paths.
+ */
+export declare function resolveGoPackage(importPath: string, goModule: GoModuleConfig, normalizedFileList: string[], allFileList: string[]): string[];

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,16 @@
+/**
+ * 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 { resolveImportPath, RESOLVE_CACHE_CAP } from './standard.js';
+export type { TsconfigPaths } from './standard.js';

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

@@ -0,0 +1,11 @@
+/**
+ * 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 { 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/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;