gitnexus 1.4.8 → 1.4.9

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

@@ -1,14 +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 { 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 { loadImportConfigs } from './language-config.js';
-import { buildSuffixIndex } from './resolvers/index.js';
-import { callRouters } from './call-routing.js';
-import { importResolvers, namedBindingExtractors, preprocessImportPath } from './import-resolution.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.
@@ -21,6 +44,7 @@ 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, '/'));
@@ -29,7 +53,25 @@ export function buildImportResolutionContext(allPaths) {
     return { allFilePaths, allFileList, normalizedFileList, index, resolveCache: new Map() };
 }
 // Config loaders extracted to ./language-config.ts (Phase 2 refactor)
-// Resolver dispatch tables are in ./import-resolution.ts — imported above
+// Resolver types are in ./import-resolvers/types.ts; named binding types in ./named-bindings/types.ts
+// ============================================================================
+// Import path preprocessing
+// ============================================================================
+/**
+ * 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).
+ */
+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);
+    }
+    return cleaned;
+}
 /** Create IMPORTS edge helpers that share a resolved-count tracker. */
 function createImportEdgeHelpers(graph, importMap) {
     let totalImportsResolved = 0;
@@ -176,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)
@@ -228,12 +271,12 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
                     }
                     return;
                 }
-                const rawImportPath = preprocessImportPath(sourceNode.text, captureMap['import'], language);
+                const rawImportPath = preprocessImportPath(sourceNode.text, captureMap['import'], provider);
                 if (!rawImportPath)
                     return;
                 totalImportsFound++;
-                const result = importResolvers[language](rawImportPath, file.path, resolveCtx);
-                const extractor = namedBindingExtractors[language];
+                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);
             }
@@ -241,11 +284,10 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
             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 = importResolvers[language](routed.importPath, file.path, resolveCtx);
+                        const result = provider.importResolver(routed.importPath, file.path, resolveCtx);
                         applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge);
                     }
                 }
@@ -253,6 +295,7 @@ 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.`);
@@ -296,11 +339,13 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
         }
         for (const imp of fileImports) {
             totalImportsFound++;
-            const result = importResolvers[imp.language](imp.rawImportPath, filePath, resolveCtx);
+            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): ${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);
+}

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

@@ -3,7 +3,8 @@
  * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
  */
 import type { SuffixIndex } from './utils.js';
-import type { SyntaxNode } from '../utils.js';
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+import type { ImportResult, ResolveCtx } from './types.js';
 /** Kotlin file extensions for JVM resolver reuse */
 export declare const KOTLIN_EXTENSIONS: readonly string[];
 /**
@@ -22,3 +23,10 @@ export declare function resolveJvmWildcard(importPath: string, normalizedFileLis
  * 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;
+/** Java: JVM wildcard -> member import -> standard fallthrough */
+export declare function resolveJavaImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;
+/**
+ * Kotlin: JVM wildcard/member with Java-interop fallback -> top-level function imports -> standard.
+ * Kotlin can import from .kt/.kts files OR from .java files (Java interop).
+ */
+export declare function resolveKotlinImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;

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

@@ -2,6 +2,8 @@
  * JVM import resolution (Java + Kotlin).
  * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
  */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { resolveStandard } from './standard.js';
 /** Kotlin file extensions for JVM resolver reuse */
 export const KOTLIN_EXTENSIONS = ['.kt', '.kts'];
 /**
@@ -101,3 +103,57 @@ export function resolveJvmMemberImport(importPath, normalizedFileList, allFileLi
     }
     return null;
 }
+/** Java: JVM wildcard -> member import -> standard fallthrough */
+export function resolveJavaImport(rawImportPath, filePath, ctx) {
+    if (rawImportPath.endsWith('.*')) {
+        const matchedFiles = resolveJvmWildcard(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
+        if (matchedFiles.length > 0)
+            return { kind: 'files', files: matchedFiles };
+    }
+    else {
+        const memberResolved = resolveJvmMemberImport(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
+        if (memberResolved)
+            return { kind: 'files', files: [memberResolved] };
+    }
+    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Java);
+}
+/**
+ * Kotlin: JVM wildcard/member with Java-interop fallback -> top-level function imports -> standard.
+ * Kotlin can import from .kt/.kts files OR from .java files (Java interop).
+ */
+export function resolveKotlinImport(rawImportPath, filePath, ctx) {
+    if (rawImportPath.endsWith('.*')) {
+        const matchedFiles = resolveJvmWildcard(rawImportPath, ctx.normalizedFileList, ctx.allFileList, KOTLIN_EXTENSIONS, ctx.index);
+        if (matchedFiles.length === 0) {
+            const javaMatches = resolveJvmWildcard(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
+            if (javaMatches.length > 0)
+                return { kind: 'files', files: javaMatches };
+        }
+        if (matchedFiles.length > 0)
+            return { kind: 'files', files: matchedFiles };
+    }
+    else {
+        let memberResolved = resolveJvmMemberImport(rawImportPath, ctx.normalizedFileList, ctx.allFileList, KOTLIN_EXTENSIONS, ctx.index);
+        if (!memberResolved) {
+            memberResolved = resolveJvmMemberImport(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
+        }
+        if (memberResolved)
+            return { kind: 'files', files: [memberResolved] };
+        // Kotlin: top-level function imports (e.g. import models.getUser) have only 2 segments,
+        // which resolveJvmMemberImport skips (requires >=3). Fall back to package-directory scan
+        // for lowercase last segments (function/property imports). Uppercase last segments
+        // (class imports like models.User) fall through to standard suffix resolution.
+        const segments = rawImportPath.split('.');
+        const lastSeg = segments[segments.length - 1];
+        if (segments.length >= 2 && lastSeg[0] && lastSeg[0] === lastSeg[0].toLowerCase()) {
+            const pkgWildcard = segments.slice(0, -1).join('.') + '.*';
+            let dirFiles = resolveJvmWildcard(pkgWildcard, ctx.normalizedFileList, ctx.allFileList, KOTLIN_EXTENSIONS, ctx.index);
+            if (dirFiles.length === 0) {
+                dirFiles = resolveJvmWildcard(pkgWildcard, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
+            }
+            if (dirFiles.length > 0)
+                return { kind: 'files', files: dirFiles };
+        }
+    }
+    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Kotlin);
+}

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

@@ -3,16 +3,10 @@
  * 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>;
-    /** PSR-4 entries sorted by namespace length descending (longest match wins).
-     *  Cached once at config load time to avoid re-sorting on every import. */
-    psr4Sorted?: readonly [string, string][];
-}
+import type { ImportResult, ResolveCtx } from './types.js';
+import type { ComposerConfig } from '../language-config.js';
 /**
- * Resolve a PHP use-statement import path using PSR-4 mappings.
+ * Resolve a PHP use-statement import path using PSR-4 mappings (low-level helper).
  * e.g. "App\Http\Controllers\UserController" -> "app/Http/Controllers/UserController.php"
  *
  * For function/constant imports (use function App\Models\getUser), the last
@@ -26,4 +20,6 @@ export interface ComposerConfig {
  * a known limitation — PHP function imports cannot be resolved to a specific file
  * without parsing all candidate files.
  */
-export declare function resolvePhpImport(importPath: string, composerConfig: ComposerConfig | null, allFiles: Set<string>, normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;
+export declare function resolvePhpImportInternal(importPath: string, composerConfig: ComposerConfig | null, allFiles: Set<string>, normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;
+/** PHP: namespace-based resolution via composer.json PSR-4. */
+export declare function resolvePhpImport(rawImportPath: string, _filePath: string, ctx: ResolveCtx): ImportResult;

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

@@ -12,7 +12,7 @@ function getSortedPsr4(config) {
     return config.psr4Sorted;
 }
 /**
- * Resolve a PHP use-statement import path using PSR-4 mappings.
+ * Resolve a PHP use-statement import path using PSR-4 mappings (low-level helper).
  * e.g. "App\Http\Controllers\UserController" -> "app/Http/Controllers/UserController.php"
  *
  * For function/constant imports (use function App\Models\getUser), the last
@@ -26,7 +26,7 @@ function getSortedPsr4(config) {
  * a known limitation — PHP function imports cannot be resolved to a specific file
  * without parsing all candidate files.
  */
-export function resolvePhpImport(importPath, composerConfig, allFiles, normalizedFileList, allFileList, index) {
+export function resolvePhpImportInternal(importPath, composerConfig, allFiles, normalizedFileList, allFileList, index) {
     // Normalize: replace backslashes with forward slashes
     const normalized = importPath.replace(/\\/g, '/');
     // Reject path traversal attempts (defense-in-depth — walker whitelist also prevents this)
@@ -73,3 +73,8 @@ export function resolvePhpImport(importPath, composerConfig, allFiles, normalize
     const pathParts = normalized.split('/').filter(Boolean);
     return suffixResolve(pathParts, normalizedFileList, allFileList, index);
 }
+/** PHP: namespace-based resolution via composer.json PSR-4. */
+export function resolvePhpImport(rawImportPath, _filePath, ctx) {
+    const resolved = resolvePhpImportInternal(rawImportPath, ctx.configs.composerConfig, ctx.allFilePaths, ctx.normalizedFileList, ctx.allFileList, ctx.index);
+    return resolved ? { kind: 'files', files: [resolved] } : null;
+}

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

@@ -2,8 +2,9 @@
  * Python import resolution — PEP 328 relative imports and proximity-based bare imports.
  * Import system spec: PEP 302 (original), PEP 451 (current).
  */
+import type { ImportResult, ResolveCtx } from './types.js';
 /**
- * Resolve a Python import to a file path.
+ * Resolve a Python import to a file path (low-level helper).
  *
  * 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.
@@ -12,8 +13,13 @@
  *    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.
+ *    Note: implicit namespace packages (Python 3.3+, 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;
+export declare function resolvePythonImportInternal(currentFile: string, importPath: string, allFiles: Set<string>): string | null;
+/**
+ * Python: relative imports (PEP 328) + proximity-based bare imports.
+ * Falls through to standard suffix resolution when proximity finds no match.
+ */
+export declare function resolvePythonImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;

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

@@ -3,8 +3,10 @@
  * Import system spec: PEP 302 (original), PEP 451 (current).
  */
 import { tryResolveWithExtensions } from './utils.js';
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { resolveStandard } from './standard.js';
 /**
- * Resolve a Python import to a file path.
+ * Resolve a Python import to a file path (low-level helper).
  *
  * 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.
@@ -13,11 +15,11 @@ import { tryResolveWithExtensions } from './utils.js';
  *    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.
+ *    Note: implicit namespace packages (Python 3.3+, directory without __init__.py) are not handled.
  *
  * Returns null to let the caller fall through to suffixResolve.
  */
-export function resolvePythonImport(currentFile, importPath, allFiles) {
+export function resolvePythonImportInternal(currentFile, importPath, allFiles) {
     // Relative import — PEP 328 (https://peps.python.org/pep-0328/)
     if (importPath.startsWith('.')) {
         const dotMatch = importPath.match(/^(\.+)(.*)/);
@@ -48,5 +50,35 @@ export function resolvePythonImport(currentFile, importPath, allFiles) {
         return `${importerDir}/${pathLike}/__init__.py`;
     if (allFiles.has(`${importerDir}/${pathLike}.py`))
         return `${importerDir}/${pathLike}.py`;
+    // Ancestor directory walk — Python resolves bare imports against sys.path entries,
+    // which typically includes the project root and package directories. Walk up from the
+    // importer's directory to find the module in an ancestor, preferring the closest match.
+    // This prevents cross-language misresolution (e.g., Python `from middleware import X`
+    // resolving to a TypeScript middleware.ts via suffix matching). Issue #417.
+    const dirParts = importerDir.split('/');
+    for (let i = dirParts.length - 1; i >= 0; i--) {
+        const ancestorDir = dirParts.slice(0, i).join('/');
+        const prefix = ancestorDir ? `${ancestorDir}/` : '';
+        if (allFiles.has(`${prefix}${pathLike}/__init__.py`))
+            return `${prefix}${pathLike}/__init__.py`;
+        if (allFiles.has(`${prefix}${pathLike}.py`))
+            return `${prefix}${pathLike}.py`;
+    }
     return null;
 }
+/**
+ * Python: relative imports (PEP 328) + proximity-based bare imports.
+ * Falls through to standard suffix resolution when proximity finds no match.
+ */
+export function resolvePythonImport(rawImportPath, filePath, ctx) {
+    const resolved = resolvePythonImportInternal(filePath, rawImportPath, ctx.allFilePaths);
+    if (resolved) {
+        // Store in resolveCache so other files importing the same module skip the
+        // ancestor walk. The cache key matches resolveStandard's convention.
+        ctx.resolveCache.set(`${filePath}::${rawImportPath}`, resolved);
+        return { kind: 'files', files: [resolved] };
+    }
+    if (rawImportPath.startsWith('.'))
+        return null; // relative but unresolved -- don't suffix-match
+    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Python);
+}

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

@@ -3,10 +3,13 @@
  * Handles path resolution for Ruby's require and require_relative calls.
  */
 import type { SuffixIndex } from './utils.js';
+import type { ImportResult, ResolveCtx } from './types.js';
 /**
- * Resolve a Ruby require/require_relative path to a matching .rb file.
+ * Resolve a Ruby require/require_relative path to a matching .rb file (low-level helper).
  *
  * 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;
+export declare function resolveRubyImportInternal(importPath: string, normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;
+/** Ruby: require / require_relative. */
+export declare function resolveRubyImport(rawImportPath: string, _filePath: string, ctx: ResolveCtx): ImportResult;

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

@@ -4,12 +4,17 @@
  */
 import { suffixResolve } from './utils.js';
 /**
- * Resolve a Ruby require/require_relative path to a matching .rb file.
+ * Resolve a Ruby require/require_relative path to a matching .rb file (low-level helper).
  *
  * 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) {
+export function resolveRubyImportInternal(importPath, normalizedFileList, allFileList, index) {
     const pathParts = importPath.replace(/^\.\//, '').split('/').filter(Boolean);
     return suffixResolve(pathParts, normalizedFileList, allFileList, index);
 }
+/** Ruby: require / require_relative. */
+export function resolveRubyImport(rawImportPath, _filePath, ctx) {
+    const resolved = resolveRubyImportInternal(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ctx.index);
+    return resolved ? { kind: 'files', files: [resolved] } : null;
+}

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

@@ -2,14 +2,17 @@
  * Rust module import resolution.
  * Handles crate::, super::, self:: prefix paths and :: separators.
  */
+import type { ImportResult, ResolveCtx } from './types.js';
 /**
- * Resolve Rust use-path to a file.
+ * Resolve Rust use-path to a file (low-level helper).
  * Handles crate::, super::, self:: prefixes and :: path separators.
  */
-export declare function resolveRustImport(currentFile: string, importPath: string, allFiles: Set<string>): string | null;
+export declare function resolveRustImportInternal(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;
+/** Rust: expand grouped imports: use {crate::a, crate::b} and use crate::models::{User, Repo}. */
+export declare function resolveRustImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;