gitnexus 1.4.0 → 1.4.1

package/dist/core/ingestion/named-binding-extraction.js

@@ -1,363 +0,0 @@
-import { SupportedLanguages } from '../../config/supported-languages.js';
-/**
- * Walk a named-binding re-export chain through NamedImportMap.
- *
- * When file A imports { User } from B, and B re-exports { User } from C,
- * the NamedImportMap for A points to B, but B has no User definition.
- * This function follows the chain: A→B→C until a definition is found.
- *
- * Returns the definitions found at the end of the chain, or null if the
- * chain breaks (missing binding, circular reference, or depth exceeded).
- * Max depth 5 to prevent infinite loops.
- *
- * @param allDefs Pre-computed `symbolTable.lookupFuzzy(name)` result — must be the
- *               complete unfiltered result. Passing a file-filtered subset will cause
- *               silent misses at depth=0 for non-aliased bindings.
- */
-export function walkBindingChain(name, currentFilePath, symbolTable, namedImportMap, allDefs) {
-    let lookupFile = currentFilePath;
-    let lookupName = name;
-    const visited = new Set();
-    for (let depth = 0; depth < 5; depth++) {
-        const bindings = namedImportMap.get(lookupFile);
-        if (!bindings)
-            return null;
-        const binding = bindings.get(lookupName);
-        if (!binding)
-            return null;
-        const key = `${binding.sourcePath}:${binding.exportedName}`;
-        if (visited.has(key))
-            return null; // circular
-        visited.add(key);
-        const targetName = binding.exportedName;
-        const resolvedDefs = targetName !== lookupName || depth > 0
-            ? symbolTable.lookupFuzzy(targetName).filter(def => def.filePath === binding.sourcePath)
-            : allDefs.filter(def => def.filePath === binding.sourcePath);
-        if (resolvedDefs.length > 0)
-            return resolvedDefs;
-        // No definition in source file → follow re-export chain
-        lookupFile = binding.sourcePath;
-        lookupName = targetName;
-    }
-    return null;
-}
-/**
- * Extract named bindings from an import AST node.
- * Returns undefined if the import is not a named import (e.g., import * or default).
- *
- * TS: import { User, Repo as R } from './models'
- *   → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
- *
- * Python: from models import User, Repo as R
- *   → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
- */
-export function extractNamedBindings(importNode, language) {
-    if (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) {
-        return extractTsNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.Python) {
-        return extractPythonNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.Kotlin) {
-        return extractKotlinNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.Rust) {
-        return extractRustNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.PHP) {
-        return extractPhpNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.CSharp) {
-        return extractCsharpNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.Java) {
-        return extractJavaNamedBindings(importNode);
-    }
-    return undefined;
-}
-export function extractTsNamedBindings(importNode) {
-    // import_statement > import_clause > named_imports > import_specifier*
-    const importClause = findChild(importNode, 'import_clause');
-    if (importClause) {
-        const namedImports = findChild(importClause, 'named_imports');
-        if (!namedImports)
-            return undefined; // default import, namespace import, or side-effect
-        const bindings = [];
-        for (let i = 0; i < namedImports.namedChildCount; i++) {
-            const specifier = namedImports.namedChild(i);
-            if (specifier?.type !== 'import_specifier')
-                continue;
-            const identifiers = [];
-            for (let j = 0; j < specifier.namedChildCount; j++) {
-                const child = specifier.namedChild(j);
-                if (child?.type === 'identifier')
-                    identifiers.push(child.text);
-            }
-            if (identifiers.length === 1) {
-                bindings.push({ local: identifiers[0], exported: identifiers[0] });
-            }
-            else if (identifiers.length === 2) {
-                // import { Foo as Bar } → exported='Foo', local='Bar'
-                bindings.push({ local: identifiers[1], exported: identifiers[0] });
-            }
-        }
-        return bindings.length > 0 ? bindings : undefined;
-    }
-    // Re-export: export { X } from './y' → export_statement > export_clause > export_specifier
-    const exportClause = findChild(importNode, 'export_clause');
-    if (exportClause) {
-        const bindings = [];
-        for (let i = 0; i < exportClause.namedChildCount; i++) {
-            const specifier = exportClause.namedChild(i);
-            if (specifier?.type !== 'export_specifier')
-                continue;
-            const identifiers = [];
-            for (let j = 0; j < specifier.namedChildCount; j++) {
-                const child = specifier.namedChild(j);
-                if (child?.type === 'identifier')
-                    identifiers.push(child.text);
-            }
-            if (identifiers.length === 1) {
-                // export { User } from './base' → re-exports User as User
-                bindings.push({ local: identifiers[0], exported: identifiers[0] });
-            }
-            else if (identifiers.length === 2) {
-                // export { Repo as Repository } from './models' → name=Repo, alias=Repository
-                // For re-exports, the first id is the source name, second is what's exported
-                // When another file imports { Repository }, they get Repo from the source
-                bindings.push({ local: identifiers[1], exported: identifiers[0] });
-            }
-        }
-        return bindings.length > 0 ? bindings : undefined;
-    }
-    return undefined;
-}
-export function extractPythonNamedBindings(importNode) {
-    // Only from import_from_statement, not plain import_statement
-    if (importNode.type !== 'import_from_statement')
-        return undefined;
-    const bindings = [];
-    for (let i = 0; i < importNode.namedChildCount; i++) {
-        const child = importNode.namedChild(i);
-        if (!child)
-            continue;
-        if (child.type === 'dotted_name') {
-            // Skip the module_name (first dotted_name is the source module)
-            const fieldName = importNode.childForFieldName?.('module_name');
-            if (fieldName && child.startIndex === fieldName.startIndex)
-                continue;
-            // This is an imported name: from x import User
-            const name = child.text;
-            if (name)
-                bindings.push({ local: name, exported: name });
-        }
-        if (child.type === 'aliased_import') {
-            // from x import Repo as R
-            const dottedName = findChild(child, 'dotted_name');
-            const aliasIdent = findChild(child, 'identifier');
-            if (dottedName && aliasIdent) {
-                bindings.push({ local: aliasIdent.text, exported: dottedName.text });
-            }
-        }
-    }
-    return bindings.length > 0 ? bindings : undefined;
-}
-export function extractKotlinNamedBindings(importNode) {
-    // import_header > identifier + import_alias > simple_identifier
-    if (importNode.type !== 'import_header')
-        return undefined;
-    const fullIdent = findChild(importNode, 'identifier');
-    if (!fullIdent)
-        return undefined;
-    const fullText = fullIdent.text;
-    const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
-    const importAlias = findChild(importNode, 'import_alias');
-    if (importAlias) {
-        // Aliased: import com.example.User as U
-        const aliasIdent = findChild(importAlias, 'simple_identifier');
-        if (!aliasIdent)
-            return undefined;
-        return [{ local: aliasIdent.text, exported: exportedName }];
-    }
-    // Non-aliased: import com.example.User → local="User", exported="User"
-    // Skip wildcard imports (ending in *)
-    if (fullText.endsWith('.*') || fullText.endsWith('*'))
-        return undefined;
-    // Skip lowercase last segments — those are member/function imports (e.g.,
-    // import util.OneArg.writeAudit), not class imports. Multiple member imports
-    // with the same function name would collide in NamedImportMap, breaking
-    // arity-based disambiguation.
-    if (exportedName[0] && exportedName[0] === exportedName[0].toLowerCase())
-        return undefined;
-    return [{ local: exportedName, exported: exportedName }];
-}
-export function extractRustNamedBindings(importNode) {
-    // use_declaration may contain use_as_clause at any depth
-    if (importNode.type !== 'use_declaration')
-        return undefined;
-    const bindings = [];
-    collectRustBindings(importNode, bindings);
-    return bindings.length > 0 ? bindings : undefined;
-}
-function collectRustBindings(node, bindings) {
-    if (node.type === 'use_as_clause') {
-        // First identifier = exported name, second identifier = local alias
-        const idents = [];
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'identifier')
-                idents.push(child.text);
-            // For scoped_identifier, extract the last segment
-            if (child?.type === 'scoped_identifier') {
-                const nameNode = child.childForFieldName?.('name');
-                if (nameNode)
-                    idents.push(nameNode.text);
-            }
-        }
-        if (idents.length === 2) {
-            bindings.push({ local: idents[1], exported: idents[0] });
-        }
-        return;
-    }
-    // Terminal identifier in a use_list: use crate::models::{User, Repo}
-    if (node.type === 'identifier' && node.parent?.type === 'use_list') {
-        bindings.push({ local: node.text, exported: node.text });
-        return;
-    }
-    // Skip scoped_identifier that serves as path prefix in scoped_use_list
-    // e.g. use crate::models::{User, Repo} — the path node "crate::models" is not an importable symbol
-    if (node.type === 'scoped_identifier' && node.parent?.type === 'scoped_use_list') {
-        return; // path prefix — the use_list sibling handles the actual symbols
-    }
-    // Terminal scoped_identifier: use crate::models::User;
-    // Only extract if this is a leaf (no deeper use_list/use_as_clause/scoped_use_list)
-    if (node.type === 'scoped_identifier') {
-        let hasDeeper = false;
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'use_list' || child?.type === 'use_as_clause' || child?.type === 'scoped_use_list') {
-                hasDeeper = true;
-                break;
-            }
-        }
-        if (!hasDeeper) {
-            const nameNode = node.childForFieldName?.('name');
-            if (nameNode) {
-                bindings.push({ local: nameNode.text, exported: nameNode.text });
-            }
-            return;
-        }
-    }
-    // Recurse into children
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child)
-            collectRustBindings(child, bindings);
-    }
-}
-export function extractPhpNamedBindings(importNode) {
-    // namespace_use_declaration > namespace_use_clause* (flat)
-    // namespace_use_declaration > namespace_use_group > namespace_use_clause* (grouped)
-    if (importNode.type !== 'namespace_use_declaration')
-        return undefined;
-    const bindings = [];
-    // Collect all clauses — from direct children AND from namespace_use_group
-    const clauses = [];
-    for (let i = 0; i < importNode.namedChildCount; i++) {
-        const child = importNode.namedChild(i);
-        if (child?.type === 'namespace_use_clause') {
-            clauses.push(child);
-        }
-        else if (child?.type === 'namespace_use_group') {
-            for (let j = 0; j < child.namedChildCount; j++) {
-                const groupChild = child.namedChild(j);
-                if (groupChild?.type === 'namespace_use_clause')
-                    clauses.push(groupChild);
-            }
-        }
-    }
-    for (const clause of clauses) {
-        // Flat imports: qualified_name + name (alias)
-        let qualifiedName = null;
-        const names = [];
-        for (let j = 0; j < clause.namedChildCount; j++) {
-            const child = clause.namedChild(j);
-            if (child?.type === 'qualified_name')
-                qualifiedName = child;
-            else if (child?.type === 'name')
-                names.push(child);
-        }
-        if (qualifiedName && names.length > 0) {
-            // Flat aliased import: use App\Models\Repo as R;
-            const fullText = qualifiedName.text;
-            const exportedName = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
-            bindings.push({ local: names[0].text, exported: exportedName });
-        }
-        else if (qualifiedName && names.length === 0) {
-            // Flat non-aliased import: use App\Models\User;
-            const fullText = qualifiedName.text;
-            const lastSegment = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
-            bindings.push({ local: lastSegment, exported: lastSegment });
-        }
-        else if (!qualifiedName && names.length >= 2) {
-            // Grouped aliased import: {Repo as R} — first name = exported, second = alias
-            bindings.push({ local: names[1].text, exported: names[0].text });
-        }
-        else if (!qualifiedName && names.length === 1) {
-            // Grouped non-aliased import: {User} in use App\Models\{User, Repo as R}
-            bindings.push({ local: names[0].text, exported: names[0].text });
-        }
-    }
-    return bindings.length > 0 ? bindings : undefined;
-}
-export function extractCsharpNamedBindings(importNode) {
-    // using_directive with identifier (alias) + qualified_name (target)
-    if (importNode.type !== 'using_directive')
-        return undefined;
-    let aliasIdent = null;
-    let qualifiedName = null;
-    for (let i = 0; i < importNode.namedChildCount; i++) {
-        const child = importNode.namedChild(i);
-        if (child?.type === 'identifier' && !aliasIdent)
-            aliasIdent = child;
-        else if (child?.type === 'qualified_name')
-            qualifiedName = child;
-    }
-    if (!aliasIdent || !qualifiedName)
-        return undefined;
-    const fullText = qualifiedName.text;
-    const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
-    return [{ local: aliasIdent.text, exported: exportedName }];
-}
-export function extractJavaNamedBindings(importNode) {
-    // import_declaration > scoped_identifier "com.example.models.User"
-    // Wildcard imports (.*) don't produce named bindings
-    if (importNode.type !== 'import_declaration')
-        return undefined;
-    // Check for asterisk (wildcard import) — skip those
-    for (let i = 0; i < importNode.childCount; i++) {
-        const child = importNode.child(i);
-        if (child?.type === 'asterisk')
-            return undefined;
-    }
-    const scopedId = findChild(importNode, 'scoped_identifier');
-    if (!scopedId)
-        return undefined;
-    const fullText = scopedId.text;
-    const lastDot = fullText.lastIndexOf('.');
-    if (lastDot === -1)
-        return undefined;
-    const className = fullText.slice(lastDot + 1);
-    // Skip lowercase names — those are package imports, not class imports
-    if (className[0] && className[0] === className[0].toLowerCase())
-        return undefined;
-    return [{ local: className, exported: className }];
-}
-function findChild(node, type) {
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child?.type === type)
-            return child;
-    }
-    return null;
-}

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

@@ -1,22 +0,0 @@
-/**
- * C# namespace import resolution.
- * Handles using-directive resolution via .csproj root namespace stripping.
- */
-import type { SuffixIndex } from './utils.js';
-/** C# project config parsed from .csproj files */
-export interface CSharpProjectConfig {
-    /** Root namespace from <RootNamespace> or assembly name (default: project directory name) */
-    rootNamespace: string;
-    /** Directory containing the .csproj file */
-    projectDir: string;
-}
-/**
- * Resolve a C# using-directive import path to matching .cs files.
- * Tries single-file match first, then directory match for namespace imports.
- */
-export declare function resolveCSharpImport(importPath: string, csharpConfigs: CSharpProjectConfig[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string[];
-/**
- * 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/resolvers/csharp.js

@@ -1,109 +0,0 @@
-/**
- * C# namespace import resolution.
- * Handles using-directive resolution via .csproj root namespace stripping.
- */
-import { suffixResolve } from './utils.js';
-/**
- * Resolve a C# using-directive import path to matching .cs files.
- * Tries single-file match first, then directory match for namespace imports.
- */
-export function resolveCSharpImport(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/resolvers/go.d.ts

@@ -1,19 +0,0 @@
-/**
- * Go package import resolution.
- * Handles Go module path-based package imports.
- */
-/** Go module config parsed from go.mod */
-export interface GoModuleConfig {
-    /** Module path (e.g., "github.com/user/repo") */
-    modulePath: string;
-}
-/**
- * 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/resolvers/go.js

@@ -1,42 +0,0 @@
-/**
- * Go package import resolution.
- * Handles Go module path-based package imports.
- */
-/**
- * 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/resolvers/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * Language-specific import resolvers.
- * Extracted from import-processor.ts for maintainability.
- */
-export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve } from './utils.js';
-export type { SuffixIndex } from './utils.js';
-export { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport } from './jvm.js';
-export { resolveGoPackageDir, resolveGoPackage } from './go.js';
-export type { GoModuleConfig } from './go.js';
-export { resolveCSharpImport, resolveCSharpNamespaceDir } from './csharp.js';
-export type { CSharpProjectConfig } from './csharp.js';
-export { resolvePhpImport } from './php.js';
-export type { ComposerConfig } from './php.js';
-export { resolveRustImport, tryRustModulePath } from './rust.js';
-export { resolveImportPath, RESOLVE_CACHE_CAP } from './standard.js';
-export type { TsconfigPaths } from './standard.js';

package/dist/core/ingestion/resolvers/index.js

@@ -1,11 +0,0 @@
-/**
- * Language-specific import resolvers.
- * Extracted from import-processor.ts for maintainability.
- */
-export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve } from './utils.js';
-export { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport } from './jvm.js';
-export { resolveGoPackageDir, resolveGoPackage } from './go.js';
-export { resolveCSharpImport, resolveCSharpNamespaceDir } from './csharp.js';
-export { resolvePhpImport } from './php.js';
-export { resolveRustImport, tryRustModulePath } from './rust.js';
-export { resolveImportPath, RESOLVE_CACHE_CAP } from './standard.js';

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

@@ -1,23 +0,0 @@
-/**
- * JVM import resolution (Java + Kotlin).
- * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
- */
-import type { SuffixIndex } from './utils.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;
-/**
- * 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;