@codragraph/cli 1.6.2

package/dist/core/ingestion/import-resolvers/configs/jvm.js

@@ -0,0 +1,68 @@
+/**
+ * Java / Kotlin import resolution configs.
+ * JVM-specific wildcard/member strategy, then standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+import { resolveJvmWildcard, resolveJvmMemberImport, KOTLIN_EXTENSIONS } from '../jvm.js';
+/** Java JVM resolution strategy — wildcard and member import resolution. */
+export const javaJvmStrategy = (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 null;
+};
+/**
+ * Kotlin JVM resolution strategy — wildcard/member with Java-interop + top-level function imports.
+ */
+export const kotlinJvmStrategy = (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 null;
+};
+export const javaImportConfig = {
+    language: SupportedLanguages.Java,
+    strategies: [javaJvmStrategy, createStandardStrategy(SupportedLanguages.Java)],
+};
+export const kotlinImportConfig = {
+    language: SupportedLanguages.Kotlin,
+    strategies: [kotlinJvmStrategy, createStandardStrategy(SupportedLanguages.Kotlin)],
+};

package/dist/core/ingestion/import-resolvers/configs/php.d.ts

@@ -0,0 +1,8 @@
+/**
+ * PHP import resolution config.
+ * PSR-4 strategy via composer.json — no standard fallback (PSR-4 includes its own suffix matching).
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** PHP PSR-4 resolution strategy via composer.json autoload mappings. */
+export declare const phpPsr4Strategy: ImportResolverStrategy;
+export declare const phpImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/php.js

@@ -0,0 +1,15 @@
+/**
+ * PHP import resolution config.
+ * PSR-4 strategy via composer.json — no standard fallback (PSR-4 includes its own suffix matching).
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { resolvePhpImportInternal } from '../php.js';
+/** PHP PSR-4 resolution strategy via composer.json autoload mappings. */
+export const phpPsr4Strategy = (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;
+};
+export const phpImportConfig = {
+    language: SupportedLanguages.PHP,
+    strategies: [phpPsr4Strategy],
+};

package/dist/core/ingestion/import-resolvers/configs/python.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Python import resolution config.
+ * PEP 328 relative + proximity-based strategy, then standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/**
+ * Python import resolution strategy — PEP 328 relative + proximity-based bare imports.
+ * Returns null to continue chain for non-relative imports.
+ * Absorbs unresolved relative imports (returns empty result to stop the chain).
+ */
+export declare const pythonImportStrategy: ImportResolverStrategy;
+export declare const pythonImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/python.js

@@ -0,0 +1,41 @@
+/**
+ * Python import resolution config.
+ * PEP 328 relative + proximity-based strategy, then standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+import { resolvePythonImportInternal } from '../python.js';
+/**
+ * Python import resolution strategy — PEP 328 relative + proximity-based bare imports.
+ * Returns null to continue chain for non-relative imports.
+ * Absorbs unresolved relative imports (returns empty result to stop the chain).
+ */
+export const pythonImportStrategy = (rawImportPath, filePath, ctx) => {
+    const resolved = resolvePythonImportInternal(filePath, rawImportPath, ctx.allFilePaths);
+    if (resolved) {
+        ctx.resolveCache.set(`${filePath}::${rawImportPath}`, resolved);
+        return { kind: 'files', files: [resolved] };
+    }
+    // PEP 328: unresolved relative imports should not fall through to suffix matching
+    if (rawImportPath.startsWith('.'))
+        return { kind: 'files', files: [] };
+    // External dotted imports like `django.apps` should not fall through to generic
+    // suffix matching when the repo has unrelated local files such as `accounts/apps.py`.
+    // Keep suffix fallback only when the leading segment appears somewhere in-repo,
+    // which preserves existing internal absolute-import behavior like `accounts.models`.
+    const pathLike = rawImportPath.replace(/\./g, '/');
+    if (pathLike.includes('/')) {
+        const [leadingSegment] = pathLike.split('/').filter(Boolean);
+        const hasRepoCandidate = !!leadingSegment &&
+            (ctx.index.get(`${leadingSegment}.py`) !== undefined ||
+                ctx.index.get(`${leadingSegment}/__init__.py`) !== undefined ||
+                ctx.index.getFilesInDir(leadingSegment, '.py').length > 0);
+        if (!hasRepoCandidate)
+            return { kind: 'files', files: [] };
+    }
+    return null;
+};
+export const pythonImportConfig = {
+    language: SupportedLanguages.Python,
+    strategies: [pythonImportStrategy, createStandardStrategy(SupportedLanguages.Python)],
+};

package/dist/core/ingestion/import-resolvers/configs/ruby.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ruby import resolution config.
+ * Require/require_relative suffix matching — no standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** Ruby require/require_relative resolution strategy. */
+export declare const rubyRequireStrategy: ImportResolverStrategy;
+export declare const rubyImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/ruby.js

@@ -0,0 +1,16 @@
+/**
+ * Ruby import resolution config.
+ * Require/require_relative suffix matching — no standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { suffixResolve } from '../utils.js';
+/** Ruby require/require_relative resolution strategy. */
+export const rubyRequireStrategy = (rawImportPath, _filePath, ctx) => {
+    const pathParts = rawImportPath.replace(/^\.\//, '').split('/').filter(Boolean);
+    const resolved = suffixResolve(pathParts, ctx.normalizedFileList, ctx.allFileList, ctx.index);
+    return resolved ? { kind: 'files', files: [resolved] } : null;
+};
+export const rubyImportConfig = {
+    language: SupportedLanguages.Ruby,
+    strategies: [rubyRequireStrategy],
+};

package/dist/core/ingestion/import-resolvers/configs/rust.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Rust import resolution config.
+ * Rust module strategy (grouped imports, crate/super/self paths), then standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** Rust module resolution strategy — handles grouped imports and crate/super/self paths. */
+export declare const rustModuleStrategy: ImportResolverStrategy;
+export declare const rustImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/rust.js

@@ -0,0 +1,54 @@
+/**
+ * Rust import resolution config.
+ * Rust module strategy (grouped imports, crate/super/self paths), then standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+import { resolveRustImportInternal } from '../rust.js';
+/** Rust module resolution strategy — handles grouped imports and crate/super/self paths. */
+export const rustModuleStrategy = (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 null;
+};
+export const rustImportConfig = {
+    language: SupportedLanguages.Rust,
+    strategies: [rustModuleStrategy, createStandardStrategy(SupportedLanguages.Rust)],
+};

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

@@ -0,0 +1,8 @@
+/**
+ * Swift import resolution config.
+ * Package.swift target map strategy — no standard fallback (unresolved = external framework).
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** Swift Package.swift target map resolution strategy. */
+export declare const swiftPackageStrategy: ImportResolverStrategy;
+export declare const swiftImportConfig: ImportResolutionConfig;

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

@@ -0,0 +1,29 @@
+/**
+ * Swift import resolution config.
+ * Package.swift target map strategy — no standard fallback (unresolved = external framework).
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+/** Swift Package.swift target map resolution strategy. */
+export const swiftPackageStrategy = (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.)
+};
+export const swiftImportConfig = {
+    language: SupportedLanguages.Swift,
+    strategies: [swiftPackageStrategy],
+};

package/dist/core/ingestion/import-resolvers/configs/typescript-javascript.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TypeScript / JavaScript / Vue import resolution configs.
+ * All use standard resolution — TS/JS with tsconfig path aliases,
+ * Vue delegates to TypeScript's resolver.
+ */
+import type { ImportResolutionConfig } from '../types.js';
+export declare const typescriptImportConfig: ImportResolutionConfig;
+export declare const javascriptImportConfig: ImportResolutionConfig;
+export declare const vueImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/typescript-javascript.js

@@ -0,0 +1,23 @@
+/**
+ * TypeScript / JavaScript / Vue import resolution configs.
+ * All use standard resolution — TS/JS with tsconfig path aliases,
+ * Vue delegates to TypeScript's resolver.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+export const typescriptImportConfig = {
+    language: SupportedLanguages.TypeScript,
+    strategies: [createStandardStrategy(SupportedLanguages.TypeScript)],
+};
+export const javascriptImportConfig = {
+    language: SupportedLanguages.JavaScript,
+    strategies: [createStandardStrategy(SupportedLanguages.JavaScript)],
+};
+// Vue SFCs are preprocessed into TypeScript upstream of import resolution,
+// so the resolver intentionally runs as TypeScript. `language: Vue` here is
+// documentation-only metadata (see `ImportResolutionConfig.language` JSDoc
+// and ARCHITECTURE.md §Vue); it is not consumed by `createImportResolver`.
+export const vueImportConfig = {
+    language: SupportedLanguages.Vue,
+    strategies: [createStandardStrategy(SupportedLanguages.TypeScript)],
+};

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

@@ -0,0 +1,18 @@
+/**
+ * C# namespace import resolution — internal helpers.
+ *
+ * Strategy lives in configs/csharp.ts.
+ * This file contains shared helpers for namespace-based resolution.
+ */
+import type { SuffixIndex } from './utils.js';
+import type { CSharpProjectConfig } from '../language-config.js';
+/**
+ * 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 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;

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * Go package import resolution — internal helpers.
+ *
+ * Strategy lives in configs/go.ts.
+ * This file contains the shared helpers used by the strategy.
+ */
+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.
+ */
+export declare function resolveGoPackageDir(importPath: string, goModule: GoModuleConfig): string | null;
+/**
+ * Resolve a Go internal package import to all .go files in the package directory.
+ * Returns an array of file paths.
+ */
+export declare function resolveGoPackage(importPath: string, goModule: GoModuleConfig, normalizedFileList: string[], allFileList: string[]): string[];

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

@@ -0,0 +1,46 @@
+/**
+ * Go package import resolution — internal helpers.
+ *
+ * Strategy lives in configs/go.ts.
+ * This file contains the shared helpers used by the strategy.
+ */
+/**
+ * Extract the package directory suffix from a Go import path.
+ * Returns the suffix string (e.g., "/internal/auth/") or null if invalid.
+ */
+export function resolveGoPackageDir(importPath, goModule) {
+    if (!importPath.startsWith(goModule.modulePath))
+        return null;
+    const relativePkg = importPath.slice(goModule.modulePath.length + 1);
+    if (!relativePkg)
+        return null;
+    return '/' + relativePkg + '/';
+}
+/**
+ * Resolve a Go internal package import to all .go files in the package directory.
+ * Returns an array of file paths.
+ */
+export function resolveGoPackage(importPath, goModule, normalizedFileList, allFileList) {
+    if (!importPath.startsWith(goModule.modulePath))
+        return [];
+    // Strip module path to get relative package path
+    const relativePkg = importPath.slice(goModule.modulePath.length + 1); // e.g., "internal/auth"
+    if (!relativePkg)
+        return [];
+    const pkgSuffix = '/' + relativePkg + '/';
+    const matches = [];
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/"
+        const normalized = '/' + normalizedFileList[i];
+        // File must be directly in the package directory (not a subdirectory)
+        if (normalized.includes(pkgSuffix) &&
+            normalized.endsWith('.go') &&
+            !normalized.endsWith('_test.go')) {
+            const afterPkg = normalized.substring(normalized.indexOf(pkgSuffix) + pkgSuffix.length);
+            if (!afterPkg.includes('/')) {
+                matches.push(allFileList[i]);
+            }
+        }
+    }
+    return matches;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * JVM import resolution — internal helpers (Java + Kotlin).
+ *
+ * Strategies live in configs/jvm.ts.
+ * This file contains shared helpers for wildcard/member resolution
+ * and the Kotlin wildcard preprocessor.
+ */
+import type { SuffixIndex } from './utils.js';
+import type { SyntaxNode } from '../utils/ast-helpers.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: SyntaxNode) => string;
+/**
+ * Resolve a JVM wildcard import (com.example.*) to all matching files.
+ * Works for both Java (.java) and Kotlin (.kt, .kts).
+ */
+export declare function resolveJvmWildcard(importPath: string, normalizedFileList: string[], allFileList: string[], extensions: readonly string[], index?: SuffixIndex): string[];
+/**
+ * Try to resolve a JVM member/static import by stripping the member name.
+ * Java: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
+ * Kotlin: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
+ */
+export declare function resolveJvmMemberImport(importPath: string, normalizedFileList: string[], allFileList: string[], extensions: readonly string[], index?: SuffixIndex): string | null;

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

@@ -0,0 +1,106 @@
+/**
+ * JVM import resolution — internal helpers (Java + Kotlin).
+ *
+ * Strategies live in configs/jvm.ts.
+ * This file contains shared helpers for wildcard/member resolution
+ * and the Kotlin wildcard preprocessor.
+ */
+/** 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;
+}