gitnexus 1.4.0 → 1.4.1

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

@@ -1,29 +1,16 @@
+import fs from 'fs/promises';
+import path from 'path';
 import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
+import { getLanguageFromFilename, yieldToEventLoop } from './utils.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
-import { extractNamedBindings } from './named-binding-extraction.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, } from './resolvers/index.js';
 const isDev = process.env.NODE_ENV === 'development';
 export const createImportMap = () => new Map();
-export const createPackageMap = () => new Map();
-export const createNamedImportMap = () => new Map();
-/**
- * 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.
- */
-export function isFileInPackageDir(filePath, dirSuffix) {
-    // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/"
-    const normalized = '/' + filePath.replace(/\\/g, '/');
-    if (!normalized.includes(dirSuffix))
-        return false;
-    const afterDir = normalized.substring(normalized.indexOf(dirSuffix) + dirSuffix.length);
-    return !afterDir.includes('/');
-}
+/** Max entries in the resolve cache. Beyond this, the cache is cleared to bound memory.
+ *  100K entries ≈ 15MB — covers the most common import patterns. */
+const RESOLVE_CACHE_CAP = 100_000;
 export function buildImportResolutionContext(allPaths) {
     const allFileList = allPaths;
     const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/'));
@@ -32,142 +19,550 @@ export function buildImportResolutionContext(allPaths) {
     return { allFilePaths, allFileList, normalizedFileList, suffixIndex, resolveCache: new Map() };
 }
 /**
- * Shared language dispatch for import resolution.
- * Used by both processImports and processImportsFromExtracted.
+ * Parse tsconfig.json to extract path aliases.
+ * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order.
  */
-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 };
+async function loadTsconfigPaths(repoRoot) {
+    const candidates = ['tsconfig.json', 'tsconfig.app.json', 'tsconfig.base.json'];
+    for (const filename of candidates) {
+        try {
+            const tsconfigPath = path.join(repoRoot, filename);
+            const raw = await fs.readFile(tsconfigPath, 'utf-8');
+            // Strip JSON comments (// and /* */ style) for robustness
+            const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+            const tsconfig = JSON.parse(stripped);
+            const compilerOptions = tsconfig.compilerOptions;
+            if (!compilerOptions?.paths)
+                continue;
+            const baseUrl = compilerOptions.baseUrl || '.';
+            const aliases = new Map();
+            for (const [pattern, targets] of Object.entries(compilerOptions.paths)) {
+                if (!Array.isArray(targets) || targets.length === 0)
+                    continue;
+                const target = targets[0];
+                // Convert glob patterns: "@/*" -> "@/", "src/*" -> "src/"
+                const aliasPrefix = pattern.endsWith('/*') ? pattern.slice(0, -1) : pattern;
+                const targetPrefix = target.endsWith('/*') ? target.slice(0, -1) : target;
+                aliases.set(aliasPrefix, targetPrefix);
+            }
+            if (aliases.size > 0) {
+                if (isDev) {
+                    console.log(`📦 Loaded ${aliases.size} path aliases from ${filename}`);
+                }
+                return { aliases, baseUrl };
             }
-            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);
+        catch {
+            // File doesn't exist or isn't valid JSON - try next
+        }
+    }
+    return null;
+}
+/**
+ * Parse go.mod to extract module path.
+ */
+async function loadGoModulePath(repoRoot) {
+    try {
+        const goModPath = path.join(repoRoot, 'go.mod');
+        const content = await fs.readFile(goModPath, 'utf-8');
+        const match = content.match(/^module\s+(\S+)/m);
+        if (match) {
+            if (isDev) {
+                console.log(`📦 Loaded Go module path: ${match[1]}`);
             }
-            if (memberResolved)
-                return { kind: 'files', files: [memberResolved] };
-            // Fall through to standard resolution
+            return { modulePath: match[1] };
+        }
+    }
+    catch {
+        // No go.mod
+    }
+    return null;
+}
+async function loadComposerConfig(repoRoot) {
+    try {
+        const composerPath = path.join(repoRoot, 'composer.json');
+        const raw = await fs.readFile(composerPath, 'utf-8');
+        const composer = JSON.parse(raw);
+        const psr4Raw = composer.autoload?.['psr-4'] ?? {};
+        const psr4Dev = composer['autoload-dev']?.['psr-4'] ?? {};
+        const merged = { ...psr4Raw, ...psr4Dev };
+        const psr4 = new Map();
+        for (const [ns, dir] of Object.entries(merged)) {
+            const nsNorm = ns.replace(/\\+$/, '');
+            const dirNorm = dir.replace(/\\/g, '/').replace(/\/+$/, '');
+            psr4.set(nsNorm, dirNorm);
+        }
+        if (isDev) {
+            console.log(`📦 Loaded ${psr4.size} PSR-4 mappings from composer.json`);
         }
+        return { psr4 };
+    }
+    catch {
+        return null;
     }
-    // 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 };
+}
+async function loadSwiftPackageConfig(repoRoot) {
+    // Swift imports are module-name based (e.g., `import SiuperModel`)
+    // SPM convention: Sources/<TargetName>/ or Package/Sources/<TargetName>/
+    // We scan for these directories to build a target map
+    const targets = new Map();
+    const sourceDirs = ['Sources', 'Package/Sources', 'src'];
+    for (const sourceDir of sourceDirs) {
+        try {
+            const fullPath = path.join(repoRoot, sourceDir);
+            const entries = await fs.readdir(fullPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    targets.set(entry.name, sourceDir + '/' + entry.name);
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+    }
+    if (targets.size > 0) {
+        if (isDev) {
+            console.log(`📦 Loaded ${targets.size} Swift package targets`);
+        }
+        return { targets };
+    }
+    return null;
+}
+// ============================================================================
+// IMPORT PATH RESOLUTION
+// ============================================================================
+/** All file extensions to try during resolution */
+const EXTENSIONS = [
+    '',
+    // TypeScript/JavaScript
+    '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts', '/index.jsx', '/index.js',
+    // Python
+    '.py', '/__init__.py',
+    // Java
+    '.java',
+    // Kotlin
+    '.kt', '.kts',
+    // C/C++
+    '.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hxx', '.hh',
+    // C#
+    '.cs',
+    // Go
+    '.go',
+    // Rust
+    '.rs', '/mod.rs',
+    // PHP
+    '.php', '.phtml',
+    // Swift
+    '.swift',
+];
+/**
+ * Try to match a path (with extensions) against the known file set.
+ * Returns the matched file path or null.
+ */
+function tryResolveWithExtensions(basePath, allFiles) {
+    for (const ext of EXTENSIONS) {
+        const candidate = basePath + ext;
+        if (allFiles.has(candidate))
+            return candidate;
+    }
+    return null;
+}
+function buildSuffixIndex(normalizedFileList, allFileList) {
+    // Map: normalized suffix -> original file path
+    const exactMap = new Map();
+    // Map: lowercase suffix -> original file path
+    const lowerMap = new Map();
+    // Map: directory suffix -> list of file paths in that directory
+    const dirMap = new Map();
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        const normalized = normalizedFileList[i];
+        const original = allFileList[i];
+        const parts = normalized.split('/');
+        // Index all suffixes: "a/b/c.java" -> ["c.java", "b/c.java", "a/b/c.java"]
+        for (let j = parts.length - 1; j >= 0; j--) {
+            const suffix = parts.slice(j).join('/');
+            // Only store first match (longest path wins for ambiguous suffixes)
+            if (!exactMap.has(suffix)) {
+                exactMap.set(suffix, original);
+            }
+            const lower = suffix.toLowerCase();
+            if (!lowerMap.has(lower)) {
+                lowerMap.set(lower, original);
             }
         }
-        // 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 };
+        // Index directory membership
+        const lastSlash = normalized.lastIndexOf('/');
+        if (lastSlash >= 0) {
+            // Build all directory suffixes
+            const dirParts = parts.slice(0, -1);
+            const fileName = parts[parts.length - 1];
+            const ext = fileName.substring(fileName.lastIndexOf('.'));
+            for (let j = dirParts.length - 1; j >= 0; j--) {
+                const dirSuffix = dirParts.slice(j).join('/');
+                const key = `${dirSuffix}:${ext}`;
+                let list = dirMap.get(key);
+                if (!list) {
+                    list = [];
+                    dirMap.set(key, list);
+                }
+                list.push(original);
+            }
+        }
+    }
+    return {
+        get: (suffix) => exactMap.get(suffix),
+        getInsensitive: (suffix) => lowerMap.get(suffix.toLowerCase()),
+        getFilesInDir: (dirSuffix, extension) => {
+            return dirMap.get(`${dirSuffix}:${extension}`) || [];
+        },
+    };
+}
+/**
+ * Suffix-based resolution using index. O(1) per lookup instead of O(files).
+ */
+function suffixResolve(pathParts, normalizedFileList, allFileList, index) {
+    if (index) {
+        for (let i = 0; i < pathParts.length; i++) {
+            const suffix = pathParts.slice(i).join('/');
+            for (const ext of EXTENSIONS) {
+                const suffixWithExt = suffix + ext;
+                const result = index.get(suffixWithExt) || index.getInsensitive(suffixWithExt);
+                if (result)
+                    return result;
             }
         }
-        if (resolvedFiles.length > 0)
-            return { kind: 'files', files: resolvedFiles };
         return null;
     }
-    // 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]);
-                }
+    // Fallback: linear scan (for backward compatibility)
+    for (let i = 0; i < pathParts.length; i++) {
+        const suffix = pathParts.slice(i).join('/');
+        for (const ext of EXTENSIONS) {
+            const suffixWithExt = suffix + ext;
+            const suffixPattern = '/' + suffixWithExt;
+            const matchIdx = normalizedFileList.findIndex(filePath => filePath.endsWith(suffixPattern) || filePath.toLowerCase().endsWith(suffixPattern.toLowerCase()));
+            if (matchIdx !== -1) {
+                return allFileList[matchIdx];
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Resolve an import path to a file path in the repository.
+ *
+ * Language-specific preprocessing is applied before the generic resolution:
+ * - TypeScript/JavaScript: rewrites tsconfig path aliases
+ * - Rust: converts crate::/super::/self:: to relative paths
+ *
+ * Java wildcards and Go package imports are handled separately in processImports
+ * because they resolve to multiple files.
+ */
+const resolveImportPath = (currentFile, importPath, allFiles, allFileList, normalizedFileList, resolveCache, language, tsconfigPaths, index) => {
+    const cacheKey = `${currentFile}::${importPath}`;
+    if (resolveCache.has(cacheKey))
+        return resolveCache.get(cacheKey) ?? null;
+    const cache = (result) => {
+        // Evict oldest 20% when cap is reached instead of clearing all
+        if (resolveCache.size >= RESOLVE_CACHE_CAP) {
+            const evictCount = Math.floor(RESOLVE_CACHE_CAP * 0.2);
+            const iter = resolveCache.keys();
+            for (let i = 0; i < evictCount; i++) {
+                const key = iter.next().value;
+                if (key !== undefined)
+                    resolveCache.delete(key);
+            }
+        }
+        resolveCache.set(cacheKey, result);
+        return result;
+    };
+    // ---- TypeScript/JavaScript: rewrite path aliases ----
+    if ((language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) &&
+        tsconfigPaths &&
+        !importPath.startsWith('.')) {
+        for (const [aliasPrefix, targetPrefix] of tsconfigPaths.aliases) {
+            if (importPath.startsWith(aliasPrefix)) {
+                const remainder = importPath.slice(aliasPrefix.length);
+                // Build the rewritten path relative to baseUrl
+                const rewritten = tsconfigPaths.baseUrl === '.'
+                    ? targetPrefix + remainder
+                    : tsconfigPaths.baseUrl + '/' + targetPrefix + remainder;
+                // Try direct resolution from repo root
+                const resolved = tryResolveWithExtensions(rewritten, allFiles);
+                if (resolved)
+                    return cache(resolved);
+                // Try suffix matching as fallback
+                const parts = rewritten.split('/').filter(Boolean);
+                const suffixResult = suffixResolve(parts, normalizedFileList, allFileList, index);
+                if (suffixResult)
+                    return cache(suffixResult);
             }
-            if (files.length > 0)
-                return { kind: 'files', files };
         }
-        return null; // External framework (Foundation, UIKit, etc.)
-    }
-    // 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);
+    }
+    // ---- Rust: convert module path syntax to file paths ----
+    if (language === SupportedLanguages.Rust) {
+        const rustResult = resolveRustImport(currentFile, importPath, allFiles);
+        if (rustResult)
+            return cache(rustResult);
+        // Fall through to generic resolution if Rust-specific didn't match
+    }
+    // ---- Generic relative import resolution (./ and ../) ----
+    const currentDir = currentFile.split('/').slice(0, -1);
+    const parts = importPath.split('/');
+    for (const part of parts) {
+        if (part === '.')
+            continue;
+        if (part === '..') {
+            currentDir.pop();
+        }
+        else {
+            currentDir.push(part);
+        }
+    }
+    const basePath = currentDir.join('/');
+    if (importPath.startsWith('.')) {
+        const resolved = tryResolveWithExtensions(basePath, allFiles);
+        return cache(resolved);
+    }
+    // ---- Generic package/absolute import resolution (suffix matching) ----
+    // Java wildcards are handled in processImports, not here
+    if (importPath.endsWith('.*')) {
+        return cache(null);
+    }
+    const pathLike = importPath.includes('/')
+        ? importPath
+        : importPath.replace(/\./g, '/');
+    const pathParts = pathLike.split('/').filter(Boolean);
+    const resolved = suffixResolve(pathParts, normalizedFileList, allFileList, index);
+    return cache(resolved);
+};
+// ============================================================================
+// RUST MODULE RESOLUTION
+// ============================================================================
+/**
+ * Resolve Rust use-path to a file.
+ * Handles crate::, super::, self:: prefixes and :: path separators.
+ */
+function resolveRustImport(currentFile, importPath, allFiles) {
+    let rustPath;
+    if (importPath.startsWith('crate::')) {
+        // crate:: resolves from src/ directory (standard Rust layout)
+        rustPath = importPath.slice(7).replace(/::/g, '/');
+        // Try from src/ (standard layout)
+        const fromSrc = tryRustModulePath('src/' + rustPath, allFiles);
+        if (fromSrc)
+            return fromSrc;
+        // Try from repo root (non-standard)
+        const fromRoot = tryRustModulePath(rustPath, allFiles);
+        if (fromRoot)
+            return fromRoot;
+        return null;
+    }
+    if (importPath.startsWith('super::')) {
+        // super:: = parent directory of current file's module
+        const currentDir = currentFile.split('/').slice(0, -1);
+        currentDir.pop(); // Go up one level for super::
+        rustPath = importPath.slice(7).replace(/::/g, '/');
+        const fullPath = [...currentDir, rustPath].join('/');
+        return tryRustModulePath(fullPath, allFiles);
+    }
+    if (importPath.startsWith('self::')) {
+        // self:: = current module's directory
+        const currentDir = currentFile.split('/').slice(0, -1);
+        rustPath = importPath.slice(6).replace(/::/g, '/');
+        const fullPath = [...currentDir, rustPath].join('/');
+        return tryRustModulePath(fullPath, allFiles);
+    }
+    // Bare path without prefix (e.g., from a use in a nested module)
+    // Convert :: to / and try suffix matching
+    if (importPath.includes('::')) {
+        rustPath = importPath.replace(/::/g, '/');
+        return tryRustModulePath(rustPath, allFiles);
+    }
+    return null;
+}
+/**
+ * Try to resolve a Rust module path to a file.
+ * Tries: path.rs, path/mod.rs, and with the last segment stripped
+ * (last segment might be a symbol name, not a module).
+ */
+function tryRustModulePath(modulePath, allFiles) {
+    // Try direct: path.rs
+    if (allFiles.has(modulePath + '.rs'))
+        return modulePath + '.rs';
+    // Try directory: path/mod.rs
+    if (allFiles.has(modulePath + '/mod.rs'))
+        return modulePath + '/mod.rs';
+    // Try path/lib.rs (for crate root)
+    if (allFiles.has(modulePath + '/lib.rs'))
+        return modulePath + '/lib.rs';
+    // The last segment might be a symbol (function, struct, etc.), not a module.
+    // Strip it and try again.
+    const lastSlash = modulePath.lastIndexOf('/');
+    if (lastSlash > 0) {
+        const parentPath = modulePath.substring(0, lastSlash);
+        if (allFiles.has(parentPath + '.rs'))
+            return parentPath + '.rs';
+        if (allFiles.has(parentPath + '/mod.rs'))
+            return parentPath + '/mod.rs';
+    }
+    return null;
+}
+/**
+ * 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.
+ */
+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;
+};
+// ============================================================================
+// JVM MULTI-FILE RESOLUTION (Java + Kotlin)
+// ============================================================================
+/** Kotlin file extensions for JVM resolver reuse */
+const KOTLIN_EXTENSIONS = ['.kt', '.kts'];
+/**
+ * Resolve a JVM wildcard import (com.example.*) to all matching files.
+ * Works for both Java (.java) and Kotlin (.kt, .kts).
+ */
+function resolveJvmWildcard(importPath, normalizedFileList, allFileList, extensions, index) {
+    // "com.example.util.*" -> "com/example/util"
+    const packagePath = importPath.slice(0, -2).replace(/\./g, '/');
+    if (index) {
+        const candidates = extensions.flatMap(ext => index.getFilesInDir(packagePath, ext));
+        // Filter to only direct children (no subdirectories)
+        const packageSuffix = '/' + packagePath + '/';
+        return candidates.filter(f => {
+            const normalized = f.replace(/\\/g, '/');
+            const idx = normalized.indexOf(packageSuffix);
+            if (idx < 0)
+                return false;
+            const afterPkg = normalized.substring(idx + packageSuffix.length);
+            return !afterPkg.includes('/');
+        });
+    }
+    // Fallback: linear scan
+    const packageSuffix = '/' + packagePath + '/';
+    const matches = [];
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        const normalized = normalizedFileList[i];
+        if (normalized.includes(packageSuffix) &&
+            extensions.some(ext => normalized.endsWith(ext))) {
+            const afterPackage = normalized.substring(normalized.indexOf(packageSuffix) + packageSuffix.length);
+            if (!afterPackage.includes('/')) {
+                matches.push(allFileList[i]);
+            }
         }
-        return 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 matches;
 }
 /**
- * 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.
+ * 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"
  */
-function applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, namedBindings, namedImportMap) {
-    if (!result)
-        return;
-    if (result.kind === 'package' && packageMap) {
-        // Store directory suffix in PackageMap (skip ImportMap expansion)
-        for (const resolvedFile of result.files) {
-            addImportGraphEdge(filePath, resolvedFile);
+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];
+                    }
+                }
+            }
         }
-        if (!packageMap.has(filePath))
-            packageMap.set(filePath, new Set());
-        packageMap.get(filePath).add(result.dirSuffix);
-    }
-    else {
-        // 'files' kind, or 'package' without PackageMap — use ImportMap directly
-        const files = result.files;
-        for (const resolvedFile of files) {
-            addImportEdge(filePath, resolvedFile);
+    }
+    return null;
+}
+// ============================================================================
+// GO PACKAGE RESOLUTION
+// ============================================================================
+/**
+ * Resolve a Go internal package import to all .go files in the package directory.
+ * Returns an array of file paths.
+ */
+function resolveGoPackage(importPath, goModule, normalizedFileList, allFileList) {
+    if (!importPath.startsWith(goModule.modulePath))
+        return [];
+    // Strip module path to get relative package path
+    const relativePkg = importPath.slice(goModule.modulePath.length + 1); // e.g., "internal/auth"
+    if (!relativePkg)
+        return [];
+    const pkgSuffix = '/' + relativePkg + '/';
+    const matches = [];
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        const normalized = normalizedFileList[i];
+        // File must be directly in the package directory (not a subdirectory)
+        if (normalized.includes(pkgSuffix) && normalized.endsWith('.go') && !normalized.endsWith('_test.go')) {
+            const afterPkg = normalized.substring(normalized.indexOf(pkgSuffix) + pkgSuffix.length);
+            if (!afterPkg.includes('/')) {
+                matches.push(allFileList[i]);
+            }
         }
-        // Record named bindings for precise Tier 2a resolution
-        if (namedBindings && namedImportMap && files.length === 1) {
-            const resolvedFile = files[0];
-            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 });
+    }
+    return matches;
+}
+// ============================================================================
+// PHP PSR-4 IMPORT RESOLUTION
+// ============================================================================
+/**
+ * Resolve a PHP use-statement import path using PSR-4 mappings.
+ * e.g. "App\Http\Controllers\UserController" -> "app/Http/Controllers/UserController.php"
+ */
+function resolvePhpImport(importPath, composerConfig, allFiles, normalizedFileList, allFileList, index) {
+    // Normalize: replace backslashes with forward slashes
+    const normalized = importPath.replace(/\\/g, '/');
+    // Try PSR-4 resolution if composer.json was found
+    if (composerConfig) {
+        // Sort namespaces by length descending (longest match wins)
+        const sorted = [...composerConfig.psr4.entries()].sort((a, b) => b[0].length - a[0].length);
+        for (const [nsPrefix, dirPrefix] of sorted) {
+            const nsPrefixSlash = nsPrefix.replace(/\\/g, '/');
+            if (normalized.startsWith(nsPrefixSlash + '/') || normalized === nsPrefixSlash) {
+                const remainder = normalized.slice(nsPrefixSlash.length).replace(/^\//, '');
+                const filePath = dirPrefix + (remainder ? '/' + remainder : '') + '.php';
+                if (allFiles.has(filePath))
+                    return filePath;
+                if (index) {
+                    const result = index.getInsensitive(filePath);
+                    if (result)
+                        return result;
+                }
             }
         }
     }
+    // Fallback: suffix matching (works without composer.json)
+    const pathParts = normalized.split('/').filter(Boolean);
+    return suffixResolve(pathParts, normalizedFileList, allFileList, index);
 }
 // ============================================================================
 // MAIN IMPORT PROCESSOR
 // ============================================================================
-export const processImports = async (graph, files, astCache, importMap, onProgress, repoRoot, allPaths, packageMap, namedImportMap) => {
+export const processImports = async (graph, files, astCache, importMap, onProgress, repoRoot, allPaths) => {
     // 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);
     const parser = await loadParser();
-    const logSkipped = isVerboseIngestionEnabled();
-    const skippedByLang = logSkipped ? new Map() : null;
     const resolveCache = new Map();
     // Pre-compute normalized file list once (forward slashes)
     const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/'));
@@ -178,16 +573,12 @@ export const processImports = async (graph, files, astCache, importMap, onProgre
     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 ctx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache };
-    // Helper: add an IMPORTS edge to the graph only (no ImportMap update)
-    const addImportGraphEdge = (filePath, resolvedPath) => {
+    const tsconfigPaths = await loadTsconfigPaths(effectiveRoot);
+    const goModule = await loadGoModulePath(effectiveRoot);
+    const composerConfig = await loadComposerConfig(effectiveRoot);
+    const swiftPackageConfig = await loadSwiftPackageConfig(effectiveRoot);
+    // Helper: add an IMPORTS edge + update import map
+    const addImportEdge = (filePath, resolvedPath) => {
         const sourceId = generateId('File', filePath);
         const targetId = generateId('File', resolvedPath);
         const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
@@ -200,10 +591,6 @@ export const processImports = async (graph, files, astCache, importMap, onProgre
             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());
         }
@@ -218,12 +605,6 @@ export const processImports = async (graph, files, astCache, importMap, onProgre
         const language = getLanguageFromFilename(file.path);
         if (!language)
             continue;
-        if (!isLanguageAvailable(language)) {
-            if (skippedByLang) {
-                skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1);
-            }
-            continue;
-        }
         const queryStr = LANGUAGE_QUERIES[language];
         if (!queryStr)
             continue;
@@ -234,7 +615,7 @@ export const processImports = async (graph, files, astCache, importMap, onProgre
         let wasReparsed = false;
         if (!tree) {
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
             }
             catch (parseError) {
                 continue;
@@ -281,18 +662,83 @@ export const processImports = async (graph, files, astCache, importMap, onProgre
                     ? appendKotlinWildcard(sourceNode.text.replace(/['"<>]/g, ''), captureMap['import'])
                     : sourceNode.text.replace(/['"<>]/g, '');
                 totalImportsFound++;
-                const result = resolveLanguageImport(file.path, rawImportPath, language, configs, ctx);
-                const bindings = namedImportMap ? extractNamedBindings(captureMap['import'], language) : undefined;
-                applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge, bindings, namedImportMap);
+                // ---- 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);
+                        // Kotlin can import Java files in mixed codebases — try .java as fallback
+                        if (matchedFiles.length === 0 && language === SupportedLanguages.Kotlin) {
+                            const javaMatches = resolveJvmWildcard(rawImportPath, normalizedFileList, allFileList, ['.java'], index);
+                            for (const matchedFile of javaMatches) {
+                                addImportEdge(file.path, matchedFile);
+                            }
+                            if (javaMatches.length > 0)
+                                return;
+                        }
+                        for (const matchedFile of matchedFiles) {
+                            addImportEdge(file.path, matchedFile);
+                        }
+                        return; // skip single-file resolution
+                    }
+                    // Try member/static import resolution (strip member name)
+                    let memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, exts, index);
+                    // Kotlin can import Java files in mixed codebases — try .java as fallback
+                    if (!memberResolved && language === SupportedLanguages.Kotlin) {
+                        memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, ['.java'], index);
+                    }
+                    if (memberResolved) {
+                        addImportEdge(file.path, memberResolved);
+                        return;
+                    }
+                    // Fall through to normal resolution for regular imports
+                }
+                // ---- Go: handle package-level imports ----
+                if (language === SupportedLanguages.Go && goModule && rawImportPath.startsWith(goModule.modulePath)) {
+                    const pkgFiles = resolveGoPackage(rawImportPath, goModule, normalizedFileList, allFileList);
+                    if (pkgFiles.length > 0) {
+                        for (const pkgFile of pkgFiles) {
+                            addImportEdge(file.path, pkgFile);
+                        }
+                        return; // skip single-file resolution
+                    }
+                    // Fall through if no files found (package might be external)
+                }
+                // ---- PHP: handle namespace-based imports (use statements) ----
+                if (language === SupportedLanguages.PHP) {
+                    const resolved = resolvePhpImport(rawImportPath, composerConfig, allFilePaths, normalizedFileList, allFileList, index);
+                    if (resolved) {
+                        addImportEdge(file.path, resolved);
+                    }
+                    return;
+                }
+                // ---- Swift: handle module imports ----
+                if (language === SupportedLanguages.Swift && swiftPackageConfig) {
+                    // Swift imports are module names: `import SiuperModel`
+                    // Resolve to the module's source directory → all .swift files in it
+                    const targetDir = swiftPackageConfig.targets.get(rawImportPath);
+                    if (targetDir) {
+                        // Find all .swift files in this target directory
+                        const dirPrefix = targetDir + '/';
+                        for (const filePath2 of allFileList) {
+                            if (filePath2.startsWith(dirPrefix) && filePath2.endsWith('.swift')) {
+                                addImportEdge(file.path, filePath2);
+                            }
+                        }
+                        return;
+                    }
+                    // External framework (Foundation, UIKit, etc.) — skip
+                    return;
+                }
+                // ---- Standard single-file resolution ----
+                const resolvedPath = resolveImportPath(file.path, rawImportPath, allFilePaths, allFileList, normalizedFileList, resolveCache, language, tsconfigPaths, index);
+                if (resolvedPath) {
+                    addImportEdge(file.path, resolvedPath);
+                }
             }
         });
         // Tree is now owned by the LRU cache — no manual delete needed
     }
-    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`);
     }
@@ -300,22 +746,17 @@ export const processImports = async (graph, files, astCache, importMap, onProgre
 // ============================================================================
 // FAST PATH: Resolve pre-extracted imports (no parsing needed)
 // ============================================================================
-export const processImportsFromExtracted = async (graph, files, extractedImports, importMap, onProgress, repoRoot, prebuiltCtx, packageMap, namedImportMap) => {
+export const processImportsFromExtracted = async (graph, files, extractedImports, importMap, onProgress, repoRoot, prebuiltCtx) => {
     const ctx = prebuiltCtx ?? buildImportResolutionContext(files.map(f => f.path));
     const { allFilePaths, allFileList, normalizedFileList, suffixIndex: index, resolveCache } = ctx;
     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 tsconfigPaths = await loadTsconfigPaths(effectiveRoot);
+    const goModule = await loadGoModulePath(effectiveRoot);
+    const composerConfig = await loadComposerConfig(effectiveRoot);
+    const swiftPackageConfig = await loadSwiftPackageConfig(effectiveRoot);
+    const addImportEdge = (filePath, resolvedPath) => {
         const sourceId = generateId('File', filePath);
         const targetId = generateId('File', resolvedPath);
         const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
@@ -328,9 +769,6 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
             confidence: 1.0,
             reason: '',
         });
-    };
-    const addImportEdge = (filePath, resolvedPath) => {
-        addImportGraphEdge(filePath, resolvedPath);
         if (!importMap.has(filePath)) {
             importMap.set(filePath, new Set());
         }
@@ -348,16 +786,103 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
     }
     const totalFiles = importsByFile.size;
     let filesProcessed = 0;
+    // Pre-build a suffix index for O(1) suffix lookups instead of O(n) linear scans
+    const suffixIndex = new Map();
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        const normalized = normalizedFileList[i];
+        // Index by last path segment (filename) for fast suffix matching
+        const lastSlash = normalized.lastIndexOf('/');
+        const filename = lastSlash >= 0 ? normalized.substring(lastSlash + 1) : normalized;
+        let list = suffixIndex.get(filename);
+        if (!list) {
+            list = [];
+            suffixIndex.set(filename, list);
+        }
+        list.push(allFileList[i]);
+    }
     for (const [filePath, fileImports] of importsByFile) {
         filesProcessed++;
         if (filesProcessed % 100 === 0) {
             onProgress?.(filesProcessed, totalFiles);
             await yieldToEventLoop();
         }
-        for (const imp of fileImports) {
+        for (const { rawImportPath, language } of fileImports) {
             totalImportsFound++;
-            const result = resolveLanguageImport(filePath, imp.rawImportPath, imp.language, configs, resolveCtx);
-            applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, imp.namedBindings, namedImportMap);
+            // Check resolve cache first
+            const cacheKey = `${filePath}::${rawImportPath}`;
+            if (resolveCache.has(cacheKey)) {
+                const cached = resolveCache.get(cacheKey);
+                if (cached)
+                    addImportEdge(filePath, cached);
+                continue;
+            }
+            // 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);
+                    // Kotlin can import Java files in mixed codebases — try .java as fallback
+                    if (matchedFiles.length === 0 && language === SupportedLanguages.Kotlin) {
+                        const javaMatches = resolveJvmWildcard(rawImportPath, normalizedFileList, allFileList, ['.java'], index);
+                        for (const matchedFile of javaMatches) {
+                            addImportEdge(filePath, matchedFile);
+                        }
+                        if (javaMatches.length > 0)
+                            continue;
+                    }
+                    for (const matchedFile of matchedFiles) {
+                        addImportEdge(filePath, matchedFile);
+                    }
+                    continue;
+                }
+                let memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, exts, index);
+                // Kotlin can import Java files in mixed codebases — try .java as fallback
+                if (!memberResolved && language === SupportedLanguages.Kotlin) {
+                    memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, ['.java'], index);
+                }
+                if (memberResolved) {
+                    resolveCache.set(cacheKey, memberResolved);
+                    addImportEdge(filePath, memberResolved);
+                    continue;
+                }
+            }
+            // Go: handle package-level imports
+            if (language === SupportedLanguages.Go && goModule && rawImportPath.startsWith(goModule.modulePath)) {
+                const pkgFiles = resolveGoPackage(rawImportPath, goModule, normalizedFileList, allFileList);
+                if (pkgFiles.length > 0) {
+                    for (const pkgFile of pkgFiles) {
+                        addImportEdge(filePath, pkgFile);
+                    }
+                    continue;
+                }
+            }
+            // PHP: handle namespace-based imports (use statements)
+            if (language === SupportedLanguages.PHP) {
+                const resolved = resolvePhpImport(rawImportPath, composerConfig, allFilePaths, normalizedFileList, allFileList, index);
+                if (resolved) {
+                    resolveCache.set(cacheKey, resolved);
+                    addImportEdge(filePath, resolved);
+                }
+                continue;
+            }
+            // Swift: handle module imports
+            if (language === SupportedLanguages.Swift && swiftPackageConfig) {
+                const targetDir = swiftPackageConfig.targets.get(rawImportPath);
+                if (targetDir) {
+                    const dirPrefix = targetDir + '/';
+                    for (const fp of allFileList) {
+                        if (fp.startsWith(dirPrefix) && fp.endsWith('.swift')) {
+                            addImportEdge(filePath, fp);
+                        }
+                    }
+                }
+                continue;
+            }
+            // Standard resolution (has its own internal cache)
+            const resolvedPath = resolveImportPath(filePath, rawImportPath, allFilePaths, allFileList, normalizedFileList, resolveCache, language, tsconfigPaths, index);
+            if (resolvedPath) {
+                addImportEdge(filePath, resolvedPath);
+            }
         }
     }
     onProgress?.(totalFiles, totalFiles);