gitnexus 1.4.7 → 1.4.9

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

@@ -3,13 +3,15 @@
  * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
  */
 import type { SuffixIndex } 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[];
 /**
  * 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;
+export declare const appendKotlinWildcard: (importPath: string, importNode: SyntaxNode) => string;
 /**
  * Resolve a JVM wildcard import (com.example.*) to all matching files.
  * Works for both Java (.java) and Kotlin (.kt, .kts).
@@ -21,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/import-resolvers/jvm.js

@@ -0,0 +1,159 @@
+/**
+ * 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'];
+/**
+ * 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 + '/';
+        const packagePrefix = packagePath + '/';
+        return candidates.filter(f => {
+            const normalized = f.replace(/\\/g, '/');
+            // Match both nested (src/models/User.kt) and root-level (models/User.kt) packages
+            let afterPkg;
+            const idx = normalized.lastIndexOf(packageSuffix);
+            if (idx >= 0) {
+                afterPkg = normalized.substring(idx + packageSuffix.length);
+            }
+            else if (normalized.startsWith(packagePrefix)) {
+                afterPkg = normalized.substring(packagePrefix.length);
+            }
+            else {
+                return false;
+            }
+            return !afterPkg.includes('/');
+        });
+    }
+    // Fallback: linear scan
+    const packageSuffix = '/' + packagePath + '/';
+    const packagePrefix = packagePath + '/';
+    const matches = [];
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        const normalized = normalizedFileList[i];
+        if (!extensions.some(ext => normalized.endsWith(ext)))
+            continue;
+        // Match both nested (src/models/User.kt) and root-level (models/User.kt) packages
+        let afterPackage = null;
+        if (normalized.includes(packageSuffix)) {
+            afterPackage = normalized.substring(normalized.lastIndexOf(packageSuffix) + packageSuffix.length);
+        }
+        else if (normalized.startsWith(packagePrefix)) {
+            afterPackage = normalized.substring(packagePrefix.length);
+        }
+        if (afterPackage !== null && !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;
+}
+/** 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/import-resolvers/php.d.ts

@@ -0,0 +1,25 @@
+/**
+ * PHP PSR-4 import resolution.
+ * Handles use-statement resolution via composer.json autoload mappings.
+ */
+import type { SuffixIndex } from './utils.js';
+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 (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
+ * segment is the symbol name, not a class name, so it may not map directly to
+ * a file. When PSR-4 class-style resolution fails, we fall back to scanning
+ * .php files in the namespace directory.
+ *
+ * NOTE: The function-import fallback returns the first matching .php file in the
+ * namespace directory. When multiple files exist in the same namespace directory,
+ * resolution is non-deterministic (depends on Set/index iteration order). This is
+ * a known limitation — PHP function imports cannot be resolved to a specific file
+ * without parsing all candidate files.
+ */
+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/import-resolvers/php.js

@@ -0,0 +1,80 @@
+/**
+ * PHP PSR-4 import resolution.
+ * Handles use-statement resolution via composer.json autoload mappings.
+ */
+import { suffixResolve } from './utils.js';
+/** Get or compute the sorted PSR-4 entries (cached after first call). */
+function getSortedPsr4(config) {
+    if (!config.psr4Sorted) {
+        const sorted = [...config.psr4.entries()].sort((a, b) => b[0].length - a[0].length);
+        config.psr4Sorted = sorted;
+    }
+    return config.psr4Sorted;
+}
+/**
+ * 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
+ * segment is the symbol name, not a class name, so it may not map directly to
+ * a file. When PSR-4 class-style resolution fails, we fall back to scanning
+ * .php files in the namespace directory.
+ *
+ * NOTE: The function-import fallback returns the first matching .php file in the
+ * namespace directory. When multiple files exist in the same namespace directory,
+ * resolution is non-deterministic (depends on Set/index iteration order). This is
+ * a known limitation — PHP function imports cannot be resolved to a specific file
+ * without parsing all candidate files.
+ */
+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)
+    if (normalized.includes('..'))
+        return null;
+    if (composerConfig) {
+        const sorted = getSortedPsr4(composerConfig);
+        for (const [nsPrefix, dirPrefix] of sorted) {
+            const nsPrefixSlash = nsPrefix.replace(/\\/g, '/');
+            if (normalized.startsWith(nsPrefixSlash + '/') || normalized === nsPrefixSlash) {
+                const remainder = normalized.slice(nsPrefixSlash.length).replace(/^\//, '');
+                // 1. Try class-style PSR-4: full path → file (e.g. App\Models\User → app/Models/User.php)
+                const filePath = dirPrefix + (remainder ? '/' + remainder : '') + '.php';
+                if (allFiles.has(filePath))
+                    return filePath;
+                if (index) {
+                    const result = index.getInsensitive(filePath);
+                    if (result)
+                        return result;
+                }
+                // 2. Function/constant fallback: strip last segment (symbol name), scan namespace directory.
+                //    e.g. App\Models\getUser → directory app/Models/, find first .php file in that dir.
+                const lastSlash = remainder.lastIndexOf('/');
+                const nsDir = lastSlash >= 0
+                    ? dirPrefix + '/' + remainder.slice(0, lastSlash)
+                    : dirPrefix;
+                // Prefer SuffixIndex directory lookup (O(log n + matches)) over linear scan
+                if (index) {
+                    const candidates = index.getFilesInDir(nsDir, '.php');
+                    if (candidates.length > 0)
+                        return candidates[0];
+                }
+                // Fallback: linear scan (only when SuffixIndex unavailable)
+                const nsDirPrefix = nsDir.endsWith('/') ? nsDir : nsDir + '/';
+                for (const f of allFiles) {
+                    if (f.startsWith(nsDirPrefix) && f.endsWith('.php') && !f.slice(nsDirPrefix.length).includes('/')) {
+                        return f;
+                    }
+                }
+            }
+        }
+    }
+    // Fallback: suffix matching (works without composer.json)
+    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;

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

@@ -2,11 +2,13 @@
  * Rust module import resolution.
  * Handles crate::, super::, self:: prefix paths and :: separators.
  */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { resolveStandard } from './standard.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 function resolveRustImport(currentFile, importPath, allFiles) {
+export function resolveRustImportInternal(currentFile, importPath, allFiles) {
     let rustPath;
     if (importPath.startsWith('crate::')) {
         // crate:: resolves from src/ directory (standard Rust layout)
@@ -71,3 +73,40 @@ export function tryRustModulePath(modulePath, allFiles) {
     }
     return null;
 }
+/** Rust: expand grouped imports: use {crate::a, crate::b} and use crate::models::{User, Repo}. */
+export function resolveRustImport(rawImportPath, filePath, ctx) {
+    // Top-level grouped: use {crate::a, crate::b}
+    if (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 = resolveRustImportInternal(filePath, part, ctx.allFilePaths);
+            if (r)
+                resolved.push(r);
+        }
+        return resolved.length > 0 ? { kind: 'files', files: resolved } : null;
+    }
+    // Scoped grouped: use crate::models::{User, Repo}
+    const braceIdx = rawImportPath.indexOf('::{');
+    if (braceIdx !== -1 && rawImportPath.endsWith('}')) {
+        const pathPrefix = rawImportPath.substring(0, braceIdx);
+        const braceContent = rawImportPath.substring(braceIdx + 3, rawImportPath.length - 1);
+        const items = braceContent.split(',').map(s => s.trim()).filter(Boolean);
+        const resolved = [];
+        for (const item of items) {
+            // Handle `use crate::models::{User, Repo as R}` — strip alias for resolution
+            const itemName = item.includes(' as ') ? item.split(' as ')[0].trim() : item;
+            const r = resolveRustImportInternal(filePath, `${pathPrefix}::${itemName}`, ctx.allFilePaths);
+            if (r)
+                resolved.push(r);
+        }
+        if (resolved.length > 0)
+            return { kind: 'files', files: resolved };
+        // Fallback: resolve the prefix path itself (e.g. crate::models -> models.rs)
+        const prefixResult = resolveRustImportInternal(filePath, pathPrefix, ctx.allFilePaths);
+        if (prefixResult)
+            return { kind: 'files', files: [prefixResult] };
+    }
+    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Rust);
+}

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

@@ -5,13 +5,8 @@
  */
 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;
-}
+import type { ImportResult, ImportResolverFn, ResolveCtx } from './types.js';
+import type { TsconfigPaths } from '../language-config.js';
 /** 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;
@@ -26,3 +21,16 @@ export declare const RESOLVE_CACHE_CAP = 100000;
  * 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;
+/**
+ * Standard single-file resolution (TS/JS/C/C++ and fallback for other languages).
+ * Handles relative imports, tsconfig path aliases, and suffix matching.
+ */
+export declare function resolveStandard(rawImportPath: string, filePath: string, ctx: ResolveCtx, language: SupportedLanguages): ImportResult;
+/** JavaScript: standard single-file resolution. */
+export declare const resolveJavascriptImport: ImportResolverFn;
+/** TypeScript: standard single-file resolution. */
+export declare const resolveTypescriptImport: ImportResolverFn;
+/** C: standard single-file resolution for #include directives. */
+export declare const resolveCImport: ImportResolverFn;
+/** C++: standard single-file resolution for #include directives. */
+export declare const resolveCppImport: ImportResolverFn;

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

@@ -4,7 +4,7 @@
  * Used as the fallback when language-specific resolvers don't match.
  */
 import { tryResolveWithExtensions, suffixResolve } from './utils.js';
-import { resolveRustImport } from './rust.js';
+import { resolveRustImportInternal } from './rust.js';
 import { SupportedLanguages } from '../../../config/supported-languages.js';
 /** Max entries in the resolve cache. Beyond this, entries are evicted.
  *  100K entries ≈ 15MB — covers the most common import patterns. */
@@ -78,13 +78,13 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
             const inner = importPath.slice(1, -1);
             const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
             for (const part of parts) {
-                const partResult = resolveRustImport(currentFile, part, allFiles);
+                const partResult = resolveRustImportInternal(currentFile, part, allFiles);
                 if (partResult)
                     return cache(partResult);
             }
             return cache(null);
         }
-        const rustResult = resolveRustImport(currentFile, rustImportPath, allFiles);
+        const rustResult = resolveRustImportInternal(currentFile, rustImportPath, allFiles);
         if (rustResult)
             return cache(rustResult);
         // Fall through to generic resolution if Rust-specific didn't match
@@ -121,3 +121,22 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
     const resolved = suffixResolve(pathParts, normalizedFileList, allFileList, index);
     return cache(resolved);
 };
+// ============================================================================
+// Per-language dispatch functions (moved from import-resolution.ts)
+// ============================================================================
+/**
+ * Standard single-file resolution (TS/JS/C/C++ and fallback for other languages).
+ * Handles relative imports, tsconfig path aliases, and suffix matching.
+ */
+export function resolveStandard(rawImportPath, filePath, ctx, language) {
+    const resolvedPath = resolveImportPath(filePath, rawImportPath, ctx.allFilePaths, ctx.allFileList, ctx.normalizedFileList, ctx.resolveCache, language, ctx.configs.tsconfigPaths, ctx.index);
+    return resolvedPath ? { kind: 'files', files: [resolvedPath] } : null;
+}
+/** JavaScript: standard single-file resolution. */
+export const resolveJavascriptImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.JavaScript);
+/** TypeScript: standard single-file resolution. */
+export const resolveTypescriptImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.TypeScript);
+/** C: standard single-file resolution for #include directives. */
+export const resolveCImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.C);
+/** C++: standard single-file resolution for #include directives. */
+export const resolveCppImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.CPlusPlus);

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

@@ -0,0 +1,7 @@
+/**
+ * Swift module import resolution.
+ * Handles module imports via Package.swift target map.
+ */
+import type { ImportResult, ResolveCtx } from './types.js';
+/** Swift: module imports via Package.swift target map. */
+export declare function resolveSwiftImport(rawImportPath: string, _filePath: string, ctx: ResolveCtx): ImportResult;

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

@@ -0,0 +1,23 @@
+/**
+ * Swift module import resolution.
+ * Handles module imports via Package.swift target map.
+ */
+/** Swift: module imports via Package.swift target map. */
+export function resolveSwiftImport(rawImportPath, _filePath, ctx) {
+    const swiftPackageConfig = ctx.configs.swiftPackageConfig;
+    if (swiftPackageConfig) {
+        const targetDir = swiftPackageConfig.targets.get(rawImportPath);
+        if (targetDir) {
+            const dirPrefix = targetDir + '/';
+            const files = [];
+            for (let i = 0; i < ctx.normalizedFileList.length; i++) {
+                if (ctx.normalizedFileList[i].startsWith(dirPrefix) && ctx.normalizedFileList[i].endsWith('.swift')) {
+                    files.push(ctx.allFileList[i]);
+                }
+            }
+            if (files.length > 0)
+                return { kind: 'files', files };
+        }
+    }
+    return null; // External framework (Foundation, UIKit, etc.)
+}