gitnexus 1.4.7 → 1.4.9

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

@@ -1,15 +1,37 @@
 import Parser from 'tree-sitter';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
-import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
+import { getProvider, getProviderForFile, providersWithImplicitWiring } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-import { extractNamedBindings } from './named-binding-extraction.js';
+import { getLanguageFromFilename } from './utils/language-detection.js';
+import { isVerboseIngestionEnabled } from './utils/verbose.js';
+import { yieldToEventLoop } from './utils/event-loop.js';
 import { getTreeSitterBufferSize } from './constants.js';
-import { loadTsconfigPaths, loadGoModulePath, loadComposerConfig, loadCSharpProjectConfig, loadSwiftPackageConfig, } from './language-config.js';
-import { buildSuffixIndex, resolveImportPath, appendKotlinWildcard, KOTLIN_EXTENSIONS, resolveJvmWildcard, resolveJvmMemberImport, resolveGoPackageDir, resolveGoPackage, resolveCSharpImport, resolveCSharpNamespaceDir, resolvePhpImport, resolveRustImport, resolveRubyImport, resolvePythonImport, } from './resolvers/index.js';
-import { callRouters } from './call-routing.js';
+import { loadImportConfigs } from './language-config.js';
+import { buildSuffixIndex } from './import-resolvers/utils.js';
 const isDev = process.env.NODE_ENV === 'development';
+/** Group files by provider (only those with implicit import wiring), then call each wirer
+ *  with its own language's files. O(n) over files, O(1) per provider lookup. */
+function wireImplicitImports(files, importMap, addImportEdge, projectConfig) {
+    if (providersWithImplicitWiring.length === 0)
+        return;
+    const grouped = new Map();
+    for (const file of files) {
+        const provider = getProviderForFile(file);
+        if (!provider?.implicitImportWirer)
+            continue;
+        let list = grouped.get(provider);
+        if (!list) {
+            list = [];
+            grouped.set(provider, list);
+        }
+        list.push(file);
+    }
+    for (const [provider, langFiles] of grouped) {
+        if (langFiles.length > 1) {
+            provider.implicitImportWirer(langFiles, importMap, addImportEdge, projectConfig);
+        }
+    }
+}
 /**
  * Check if a file path is directly inside a package directory identified by its suffix.
  * Used by the symbol resolver for Go and C# directory-level import matching.
@@ -22,125 +44,59 @@ export function isFileInPackageDir(filePath, dirSuffix) {
     const afterDir = normalized.substring(normalized.indexOf(dirSuffix) + dirSuffix.length);
     return !afterDir.includes('/');
 }
+// ImportResolutionContext is defined in ./import-resolvers/types.ts — re-exported here for consumers.
 export function buildImportResolutionContext(allPaths) {
     const allFileList = allPaths;
     const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/'));
     const allFilePaths = new Set(allFileList);
-    const suffixIndex = buildSuffixIndex(normalizedFileList, allFileList);
-    return { allFilePaths, allFileList, normalizedFileList, suffixIndex, resolveCache: new Map() };
+    const index = buildSuffixIndex(normalizedFileList, allFileList);
+    return { allFilePaths, allFileList, normalizedFileList, index, resolveCache: new Map() };
 }
+// Config loaders extracted to ./language-config.ts (Phase 2 refactor)
+// Resolver types are in ./import-resolvers/types.ts; named binding types in ./named-bindings/types.ts
+// ============================================================================
+// Import path preprocessing
+// ============================================================================
 /**
- * Shared language dispatch for import resolution.
- * Used by both processImports and processImportsFromExtracted.
+ * Clean and preprocess a raw import source text into a resolved import path.
+ * Strips quotes/angle brackets (universal) and applies provider-specific
+ * transformations (currently only Kotlin wildcard import detection).
  */
-function resolveLanguageImport(filePath, rawImportPath, language, configs, ctx) {
-    const { allFilePaths, allFileList, normalizedFileList, index, resolveCache } = ctx;
-    const { tsconfigPaths, goModule, composerConfig, swiftPackageConfig, csharpConfigs } = configs;
-    // JVM languages (Java + Kotlin): handle wildcards and member imports
-    if (language === SupportedLanguages.Java || language === SupportedLanguages.Kotlin) {
-        const exts = language === SupportedLanguages.Java ? ['.java'] : KOTLIN_EXTENSIONS;
-        if (rawImportPath.endsWith('.*')) {
-            const matchedFiles = resolveJvmWildcard(rawImportPath, normalizedFileList, allFileList, exts, index);
-            if (matchedFiles.length === 0 && language === SupportedLanguages.Kotlin) {
-                const javaMatches = resolveJvmWildcard(rawImportPath, normalizedFileList, allFileList, ['.java'], index);
-                if (javaMatches.length > 0)
-                    return { kind: 'files', files: javaMatches };
-            }
-            if (matchedFiles.length > 0)
-                return { kind: 'files', files: matchedFiles };
-            // Fall through to standard resolution
-        }
-        else {
-            let memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, exts, index);
-            if (!memberResolved && language === SupportedLanguages.Kotlin) {
-                memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, ['.java'], index);
-            }
-            if (memberResolved)
-                return { kind: 'files', files: [memberResolved] };
-            // Fall through to standard resolution
-        }
-    }
-    // Go: handle package-level imports
-    if (language === SupportedLanguages.Go && goModule && rawImportPath.startsWith(goModule.modulePath)) {
-        const pkgSuffix = resolveGoPackageDir(rawImportPath, goModule);
-        if (pkgSuffix) {
-            const pkgFiles = resolveGoPackage(rawImportPath, goModule, normalizedFileList, allFileList);
-            if (pkgFiles.length > 0) {
-                return { kind: 'package', files: pkgFiles, dirSuffix: pkgSuffix };
-            }
-        }
-        // Fall through if no files found (package might be external)
-    }
-    // C#: handle namespace-based imports (using directives)
-    if (language === SupportedLanguages.CSharp && csharpConfigs.length > 0) {
-        const resolvedFiles = resolveCSharpImport(rawImportPath, csharpConfigs, normalizedFileList, allFileList, index);
-        if (resolvedFiles.length > 1) {
-            const dirSuffix = resolveCSharpNamespaceDir(rawImportPath, csharpConfigs);
-            if (dirSuffix) {
-                return { kind: 'package', files: resolvedFiles, dirSuffix };
-            }
-        }
-        if (resolvedFiles.length > 0)
-            return { kind: 'files', files: resolvedFiles };
+export function preprocessImportPath(sourceText, importNode, provider) {
+    const cleaned = sourceText.replace(/['"<>]/g, '');
+    // Defense-in-depth: reject null bytes and control characters (matches Ruby call-routing pattern)
+    if (!cleaned || cleaned.length > 2048 || /[\x00-\x1f]/.test(cleaned))
         return null;
+    if (provider.importPathPreprocessor) {
+        return provider.importPathPreprocessor(cleaned, importNode);
     }
-    // PHP: handle namespace-based imports (use statements)
-    if (language === SupportedLanguages.PHP) {
-        const resolved = resolvePhpImport(rawImportPath, composerConfig, allFilePaths, normalizedFileList, allFileList, index);
-        return resolved ? { kind: 'files', files: [resolved] } : null;
-    }
-    // Swift: handle module imports
-    if (language === SupportedLanguages.Swift && swiftPackageConfig) {
-        const targetDir = swiftPackageConfig.targets.get(rawImportPath);
-        if (targetDir) {
-            const dirPrefix = targetDir + '/';
-            const files = [];
-            for (let i = 0; i < normalizedFileList.length; i++) {
-                if (normalizedFileList[i].startsWith(dirPrefix) && normalizedFileList[i].endsWith('.swift')) {
-                    files.push(allFileList[i]);
-                }
-            }
-            if (files.length > 0)
-                return { kind: 'files', files };
-        }
-        return null; // External framework (Foundation, UIKit, etc.)
-    }
-    // Python: relative imports (PEP 328) + proximity-based bare imports
-    // Falls through to standard suffix resolution when proximity finds no match.
-    if (language === SupportedLanguages.Python) {
-        const resolved = resolvePythonImport(filePath, rawImportPath, allFilePaths);
-        if (resolved)
-            return { kind: 'files', files: [resolved] };
-        if (rawImportPath.startsWith('.'))
-            return null; // relative but unresolved — don't suffix-match
-    }
-    // Ruby: require / require_relative
-    if (language === SupportedLanguages.Ruby) {
-        const resolved = resolveRubyImport(rawImportPath, normalizedFileList, allFileList, index);
-        return resolved ? { kind: 'files', files: [resolved] } : null;
-    }
-    // Rust: expand top-level grouped imports: use {crate::a, crate::b}
-    if (language === SupportedLanguages.Rust && rawImportPath.startsWith('{') && rawImportPath.endsWith('}')) {
-        const inner = rawImportPath.slice(1, -1);
-        const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
-        const resolved = [];
-        for (const part of parts) {
-            const r = resolveRustImport(filePath, part, allFilePaths);
-            if (r)
-                resolved.push(r);
-        }
-        return resolved.length > 0 ? { kind: 'files', files: resolved } : null;
-    }
-    // Standard single-file resolution
-    const resolvedPath = resolveImportPath(filePath, rawImportPath, allFilePaths, allFileList, normalizedFileList, resolveCache, language, tsconfigPaths, index);
-    return resolvedPath ? { kind: 'files', files: [resolvedPath] } : null;
+    return cleaned;
+}
+/** Create IMPORTS edge helpers that share a resolved-count tracker. */
+function createImportEdgeHelpers(graph, importMap) {
+    let totalImportsResolved = 0;
+    const addImportGraphEdge = (filePath, resolvedPath) => {
+        const sourceId = generateId('File', filePath);
+        const targetId = generateId('File', resolvedPath);
+        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
+        totalImportsResolved++;
+        graph.addRelationship({ id: relId, sourceId, targetId, type: 'IMPORTS', confidence: 1.0, reason: '' });
+    };
+    const addImportEdge = (filePath, resolvedPath) => {
+        addImportGraphEdge(filePath, resolvedPath);
+        if (!importMap.has(filePath))
+            importMap.set(filePath, new Set());
+        importMap.get(filePath).add(resolvedPath);
+    };
+    return { addImportEdge, addImportGraphEdge, getResolvedCount: () => totalImportsResolved };
 }
 /**
  * Apply an ImportResult: emit graph edges and update ImportMap/PackageMap.
  * If namedBindings are provided and the import resolves to a single file,
  * also populate the NamedImportMap for precise Tier 2a resolution.
+ * Bindings tagged with `isModuleAlias` are routed to moduleAliasMap instead.
  */
-function applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, namedBindings, namedImportMap) {
+function applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, namedBindings, namedImportMap, moduleAliasMap) {
     if (!result)
         return;
     if (result.kind === 'package' && packageMap) {
@@ -158,14 +114,66 @@ function applyImportResult(result, filePath, importMap, packageMap, addImportEdg
         for (const resolvedFile of files) {
             addImportEdge(filePath, resolvedFile);
         }
-        // Record named bindings for precise Tier 2a resolution
-        if (namedBindings && namedImportMap && files.length === 1) {
+        // Route module aliases (import X as Y) directly to moduleAliasMap.
+        // These are module-level aliases, not symbol bindings — they don't belong in namedImportMap.
+        if (namedBindings && moduleAliasMap && files.length === 1) {
             const resolvedFile = files[0];
+            for (const binding of namedBindings) {
+                if (!binding.isModuleAlias)
+                    continue;
+                let aliasMap = moduleAliasMap.get(filePath);
+                if (!aliasMap) {
+                    aliasMap = new Map();
+                    moduleAliasMap.set(filePath, aliasMap);
+                }
+                aliasMap.set(binding.local, resolvedFile);
+            }
+        }
+        // Record named bindings for precise Tier 2a resolution.
+        // If the same local name is imported from multiple files (e.g., Java static imports
+        // of overloaded methods), remove the entry so resolution falls through to Tier 2a
+        // import-scoped which sees all candidates and can apply arity narrowing.
+        if (namedBindings && namedImportMap) {
             if (!namedImportMap.has(filePath))
                 namedImportMap.set(filePath, new Map());
             const fileBindings = namedImportMap.get(filePath);
-            for (const binding of namedBindings) {
-                fileBindings.set(binding.local, { sourcePath: resolvedFile, exportedName: binding.exported });
+            if (files.length === 1) {
+                const resolvedFile = files[0];
+                for (const binding of namedBindings) {
+                    if (binding.isModuleAlias)
+                        continue; // already routed to moduleAliasMap
+                    const existing = fileBindings.get(binding.local);
+                    if (existing && existing.sourcePath !== resolvedFile) {
+                        fileBindings.delete(binding.local);
+                    }
+                    else {
+                        fileBindings.set(binding.local, { sourcePath: resolvedFile, exportedName: binding.exported });
+                    }
+                }
+            }
+            else {
+                // Multi-file resolution (e.g., Rust `use crate::models::{User, Repo}`).
+                // Match each binding to a resolved file by comparing the lowercase binding name
+                // to the file's basename (without extension). If no match, skip the binding.
+                for (const binding of namedBindings) {
+                    if (binding.isModuleAlias)
+                        continue;
+                    const lowerName = binding.exported.toLowerCase();
+                    const matchedFile = files.find(f => {
+                        const base = f.replace(/\\/g, '/').split('/').pop() ?? '';
+                        const nameWithoutExt = base.substring(0, base.lastIndexOf('.')).toLowerCase();
+                        return nameWithoutExt === lowerName;
+                    });
+                    if (matchedFile) {
+                        const existing = fileBindings.get(binding.local);
+                        if (existing && existing.sourcePath !== matchedFile) {
+                            fileBindings.delete(binding.local);
+                        }
+                        else {
+                            fileBindings.set(binding.local, { sourcePath: matchedFile, exportedName: binding.exported });
+                        }
+                    }
+                }
             }
         }
     }
@@ -177,6 +185,7 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
     const importMap = ctx.importMap;
     const packageMap = ctx.packageMap;
     const namedImportMap = ctx.namedImportMap;
+    const moduleAliasMap = ctx.moduleAliasMap;
     // Use allPaths (full repo) when available for cross-chunk resolution, else fall back to chunk files
     const allFileList = allPaths ?? files.map(f => f.path);
     const allFilePaths = new Set(allFileList);
@@ -190,40 +199,10 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
     const index = buildSuffixIndex(normalizedFileList, allFileList);
     // Track import statistics
     let totalImportsFound = 0;
-    let totalImportsResolved = 0;
     // Load language-specific configs once before the file loop
-    const effectiveRoot = repoRoot || '';
-    const configs = {
-        tsconfigPaths: await loadTsconfigPaths(effectiveRoot),
-        goModule: await loadGoModulePath(effectiveRoot),
-        composerConfig: await loadComposerConfig(effectiveRoot),
-        swiftPackageConfig: await loadSwiftPackageConfig(effectiveRoot),
-        csharpConfigs: await loadCSharpProjectConfig(effectiveRoot),
-    };
-    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache };
-    // Helper: add an IMPORTS edge to the graph only (no ImportMap update)
-    const addImportGraphEdge = (filePath, resolvedPath) => {
-        const sourceId = generateId('File', filePath);
-        const targetId = generateId('File', resolvedPath);
-        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
-        totalImportsResolved++;
-        graph.addRelationship({
-            id: relId,
-            sourceId,
-            targetId,
-            type: 'IMPORTS',
-            confidence: 1.0,
-            reason: '',
-        });
-    };
-    // Helper: add an IMPORTS edge + update import map
-    const addImportEdge = (filePath, resolvedPath) => {
-        addImportGraphEdge(filePath, resolvedPath);
-        if (!importMap.has(filePath)) {
-            importMap.set(filePath, new Set());
-        }
-        importMap.get(filePath).add(resolvedPath);
-    };
+    const configs = await loadImportConfigs(repoRoot || '');
+    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache, configs };
+    const { addImportEdge, addImportGraphEdge, getResolvedCount } = createImportEdgeHelpers(graph, importMap);
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
         onProgress?.(i + 1, files.length);
@@ -239,7 +218,8 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
             }
             continue;
         }
-        const queryStr = LANGUAGE_QUERIES[language];
+        const provider = getProvider(language);
+        const queryStr = provider.treeSitterQueries;
         if (!queryStr)
             continue;
         // 2. ALWAYS load the language before querying (parser is stateful)
@@ -291,24 +271,23 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
                     }
                     return;
                 }
-                // Clean path (remove quotes and angle brackets for C/C++ includes)
-                const rawImportPath = language === SupportedLanguages.Kotlin
-                    ? appendKotlinWildcard(sourceNode.text.replace(/['"<>]/g, ''), captureMap['import'])
-                    : sourceNode.text.replace(/['"<>]/g, '');
+                const rawImportPath = preprocessImportPath(sourceNode.text, captureMap['import'], provider);
+                if (!rawImportPath)
+                    return;
                 totalImportsFound++;
-                const result = resolveLanguageImport(file.path, rawImportPath, language, configs, resolveCtx);
-                const bindings = namedImportMap ? extractNamedBindings(captureMap['import'], language) : undefined;
-                applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge, bindings, namedImportMap);
+                const result = provider.importResolver(rawImportPath, file.path, resolveCtx);
+                const extractor = provider.namedBindingExtractor;
+                const bindings = namedImportMap && extractor ? extractor(captureMap['import']) : undefined;
+                applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge, bindings, namedImportMap, moduleAliasMap);
             }
             // ---- Language-specific call-as-import routing (Ruby require, etc.) ----
             if (captureMap['call']) {
                 const callNameNode = captureMap['call.name'];
                 if (callNameNode) {
-                    const callRouter = callRouters[language];
-                    const routed = callRouter(callNameNode.text, captureMap['call']);
+                    const routed = provider.callRouter?.(callNameNode.text, captureMap['call']);
                     if (routed && routed.kind === 'import') {
                         totalImportsFound++;
-                        const result = resolveLanguageImport(file.path, routed.importPath, language, configs, resolveCtx);
+                        const result = provider.importResolver(routed.importPath, file.path, resolveCtx);
                         applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge);
                     }
                 }
@@ -316,13 +295,14 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         });
         // Tree is now owned by the LRU cache — no manual delete needed
     }
+    wireImplicitImports(allFileList, importMap, addImportEdge, configs);
     if (skippedByLang && skippedByLang.size > 0) {
         for (const [lang, count] of skippedByLang.entries()) {
             console.warn(`[ingestion] Skipped ${count} ${lang} file(s) in import processing — ${lang} parser not available.`);
         }
     }
     if (isDev) {
-        console.log(`📊 Import processing complete: ${totalImportsResolved}/${totalImportsFound} imports resolved to graph edges`);
+        console.log(`📊 Import processing complete: ${getResolvedCount()}/${totalImportsFound} imports resolved to graph edges`);
     }
 };
 // ============================================================================
@@ -332,41 +312,13 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
     const importMap = ctx.importMap;
     const packageMap = ctx.packageMap;
     const namedImportMap = ctx.namedImportMap;
+    const moduleAliasMap = ctx.moduleAliasMap;
     const importCtx = prebuiltCtx ?? buildImportResolutionContext(files.map(f => f.path));
-    const { allFilePaths, allFileList, normalizedFileList, suffixIndex: index, resolveCache } = importCtx;
+    const { allFilePaths, allFileList, normalizedFileList, index, resolveCache } = importCtx;
     let totalImportsFound = 0;
-    let totalImportsResolved = 0;
-    const effectiveRoot = repoRoot || '';
-    const configs = {
-        tsconfigPaths: await loadTsconfigPaths(effectiveRoot),
-        goModule: await loadGoModulePath(effectiveRoot),
-        composerConfig: await loadComposerConfig(effectiveRoot),
-        swiftPackageConfig: await loadSwiftPackageConfig(effectiveRoot),
-        csharpConfigs: await loadCSharpProjectConfig(effectiveRoot),
-    };
-    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache };
-    // Helper: add an IMPORTS edge to the graph only (no ImportMap update)
-    const addImportGraphEdge = (filePath, resolvedPath) => {
-        const sourceId = generateId('File', filePath);
-        const targetId = generateId('File', resolvedPath);
-        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
-        totalImportsResolved++;
-        graph.addRelationship({
-            id: relId,
-            sourceId,
-            targetId,
-            type: 'IMPORTS',
-            confidence: 1.0,
-            reason: '',
-        });
-    };
-    const addImportEdge = (filePath, resolvedPath) => {
-        addImportGraphEdge(filePath, resolvedPath);
-        if (!importMap.has(filePath)) {
-            importMap.set(filePath, new Set());
-        }
-        importMap.get(filePath).add(resolvedPath);
-    };
+    const configs = await loadImportConfigs(repoRoot || '');
+    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache, configs };
+    const { addImportEdge, addImportGraphEdge, getResolvedCount } = createImportEdgeHelpers(graph, importMap);
     // Group by file for progress reporting (users see file count, not import count)
     const importsByFile = new Map();
     for (const imp of extractedImports) {
@@ -387,12 +339,14 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
         }
         for (const imp of fileImports) {
             totalImportsFound++;
-            const result = resolveLanguageImport(filePath, imp.rawImportPath, imp.language, configs, resolveCtx);
-            applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, imp.namedBindings, namedImportMap);
+            const provider = getProvider(imp.language);
+            const result = provider.importResolver(imp.rawImportPath, filePath, resolveCtx);
+            applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, imp.namedBindings, namedImportMap, moduleAliasMap);
         }
     }
     onProgress?.(totalFiles, totalFiles);
+    wireImplicitImports(files.map(f => f.path), importMap, addImportEdge, configs);
     if (isDev) {
-        console.log(`📊 Import processing (fast path): ${totalImportsResolved}/${totalImportsFound} imports resolved to graph edges`);
+        console.log(`📊 Import processing (fast path): ${getResolvedCount()}/${totalImportsFound} imports resolved to graph edges`);
     }
 };

package/dist/core/ingestion/{resolvers → import-resolvers}/csharp.d.ts

@@ -3,20 +3,17 @@
  * 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;
-}
+import type { ImportResult, ResolveCtx } from './types.js';
+import type { CSharpProjectConfig } from '../language-config.js';
 /**
- * Resolve a C# using-directive import path to matching .cs files.
+ * Resolve a C# using-directive import path to matching .cs files (low-level helper).
  * 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[];
+export declare function resolveCSharpImportInternal(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;
+/** C#: namespace-based resolution via .csproj configs, with suffix-match fallback. */
+export declare function resolveCSharpImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;

package/dist/core/ingestion/{resolvers → import-resolvers}/csharp.js

@@ -3,11 +3,13 @@
  * Handles using-directive resolution via .csproj root namespace stripping.
  */
 import { suffixResolve } from './utils.js';
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { resolveStandard } from './standard.js';
 /**
- * Resolve a C# using-directive import path to matching .cs files.
+ * Resolve a C# using-directive import path to matching .cs files (low-level helper).
  * Tries single-file match first, then directory match for namespace imports.
  */
-export function resolveCSharpImport(importPath, csharpConfigs, normalizedFileList, allFileList, index) {
+export function resolveCSharpImportInternal(importPath, csharpConfigs, normalizedFileList, allFileList, index) {
     const namespacePath = importPath.replace(/\./g, '/');
     const results = [];
     for (const config of csharpConfigs) {
@@ -107,3 +109,19 @@ export function resolveCSharpNamespaceDir(importPath, csharpConfigs) {
     }
     return null;
 }
+/** C#: namespace-based resolution via .csproj configs, with suffix-match fallback. */
+export function resolveCSharpImport(rawImportPath, filePath, ctx) {
+    const csharpConfigs = ctx.configs.csharpConfigs;
+    if (csharpConfigs.length > 0) {
+        const resolvedFiles = resolveCSharpImportInternal(rawImportPath, csharpConfigs, ctx.normalizedFileList, ctx.allFileList, ctx.index);
+        if (resolvedFiles.length > 1) {
+            const dirSuffix = resolveCSharpNamespaceDir(rawImportPath, csharpConfigs);
+            if (dirSuffix) {
+                return { kind: 'package', files: resolvedFiles, dirSuffix };
+            }
+        }
+        if (resolvedFiles.length > 0)
+            return { kind: 'files', files: resolvedFiles };
+    }
+    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.CSharp);
+}

package/dist/core/ingestion/import-resolvers/dart.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Dart import resolution.
+ * Handles package: imports (local packages) and relative imports.
+ * SDK imports (dart:*) and external packages are skipped.
+ */
+import type { ImportResult, ResolveCtx } from './types.js';
+export declare function resolveDartImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;

package/dist/core/ingestion/import-resolvers/dart.js

@@ -0,0 +1,44 @@
+/**
+ * Dart import resolution.
+ * Handles package: imports (local packages) and relative imports.
+ * SDK imports (dart:*) and external packages are skipped.
+ */
+import { resolveStandard } from './standard.js';
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+export function resolveDartImport(rawImportPath, filePath, ctx) {
+    // Strip surrounding quotes from configurable_uri capture
+    const stripped = rawImportPath.replace(/^['"]|['"]$/g, '');
+    // Skip dart: SDK imports (dart:async, dart:io, etc.)
+    if (stripped.startsWith('dart:'))
+        return null;
+    // Local package: imports → resolve to lib/<path>
+    if (stripped.startsWith('package:')) {
+        const slashIdx = stripped.indexOf('/');
+        if (slashIdx === -1)
+            return null;
+        const relPath = stripped.slice(slashIdx + 1);
+        const candidates = [`lib/${relPath}`, relPath];
+        const files = [];
+        for (const candidate of candidates) {
+            for (const fp of ctx.allFileList) {
+                if (fp.endsWith('/' + candidate) || fp === candidate) {
+                    files.push(fp);
+                    break;
+                }
+            }
+            if (files.length > 0)
+                break;
+        }
+        if (files.length > 0)
+            return { kind: 'files', files };
+        return null;
+    }
+    // Relative imports — use standard resolution.
+    // Dart relative imports don't require a leading "./" (e.g. `import 'models.dart'`).
+    // The standard resolver only recognises paths starting with "." as relative, so
+    // prepend "./" when the path doesn't already start with "." to ensure correct
+    // same-directory resolution (without this, "models.dart" would be mangled by the
+    // generic dot-to-slash conversion intended for Java-style package imports).
+    const relPath = stripped.startsWith('.') ? stripped : './' + stripped;
+    return resolveStandard(relPath, filePath, ctx, SupportedLanguages.Dart);
+}

package/dist/core/ingestion/{resolvers → import-resolvers}/go.d.ts

@@ -2,11 +2,8 @@
  * 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;
-}
+import type { ImportResult, ResolveCtx } from './types.js';
+import type { GoModuleConfig } from '../language-config.js';
 /**
  * Extract the package directory suffix from a Go import path.
  * Returns the suffix string (e.g., "/internal/auth/") or null if invalid.
@@ -17,3 +14,5 @@ export declare function resolveGoPackageDir(importPath: string, goModule: GoModu
  * Returns an array of file paths.
  */
 export declare function resolveGoPackage(importPath: string, goModule: GoModuleConfig, normalizedFileList: string[], allFileList: string[]): string[];
+/** Go: package-level imports via go.mod module path. */
+export declare function resolveGoImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;

package/dist/core/ingestion/{resolvers → import-resolvers}/go.js

@@ -2,6 +2,8 @@
  * Go package import resolution.
  * Handles Go module path-based package imports.
  */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { resolveStandard } from './standard.js';
 /**
  * Extract the package directory suffix from a Go import path.
  * Returns the suffix string (e.g., "/internal/auth/") or null if invalid.
@@ -40,3 +42,18 @@ export function resolveGoPackage(importPath, goModule, normalizedFileList, allFi
     }
     return matches;
 }
+/** Go: package-level imports via go.mod module path. */
+export function resolveGoImport(rawImportPath, filePath, ctx) {
+    const goModule = ctx.configs.goModule;
+    if (goModule && rawImportPath.startsWith(goModule.modulePath)) {
+        const pkgSuffix = resolveGoPackageDir(rawImportPath, goModule);
+        if (pkgSuffix) {
+            const pkgFiles = resolveGoPackage(rawImportPath, goModule, ctx.normalizedFileList, ctx.allFileList);
+            if (pkgFiles.length > 0) {
+                return { kind: 'package', files: pkgFiles, dirSuffix: pkgSuffix };
+            }
+        }
+        // Fall through if no files found (package might be external)
+    }
+    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Go);
+}