arceus-s 1.6.4

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

@@ -0,0 +1,377 @@
+import Parser from 'tree-sitter';
+import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { getProvider, getProviderForFile, providersWithImplicitWiring } from './languages/index.js';
+import { generateId } from '../../lib/utils.js';
+import { getLanguageFromFilename } from '../../_shared/index.js';
+import { isVerboseIngestionEnabled } from './utils/verbose.js';
+import { yieldToEventLoop } from './utils/event-loop.js';
+import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
+import { getTreeSitterBufferSize } from './constants.js';
+import { loadImportConfigs } from './language-config.js';
+import { buildSuffixIndex } from './import-resolvers/utils.js';
+import { isDev } from './utils/env.js';
+import { isRegistryPrimary } from './registry-primary-flag.js';
+import { logger } from '../logger.js';
+/** Group files by provider (only those with implicit import wiring), then call each wirer
+ *  with its own language's files. O(n) over files, O(1) per provider lookup. */
+function wireImplicitImports(files, importMap, addImportEdge, projectConfig) {
+    if (providersWithImplicitWiring.length === 0)
+        return;
+    const grouped = new Map();
+    for (const file of files) {
+        const provider = getProviderForFile(file);
+        if (!provider?.implicitImportWirer)
+            continue;
+        let list = grouped.get(provider);
+        if (!list) {
+            list = [];
+            grouped.set(provider, list);
+        }
+        list.push(file);
+    }
+    for (const [provider, langFiles] of grouped) {
+        if (langFiles.length > 1) {
+            provider.implicitImportWirer(langFiles, importMap, addImportEdge, projectConfig);
+        }
+    }
+}
+// ImportResolutionContext is defined in ./import-resolvers/types.ts — re-exported here for consumers.
+export function buildImportResolutionContext(allPaths) {
+    const allFileList = allPaths;
+    const normalizedFileList = allFileList.map((p) => p.replace(/\\/g, '/'));
+    const allFilePaths = new Set(allFileList);
+    const index = buildSuffixIndex(normalizedFileList, allFileList);
+    return { allFilePaths, allFileList, normalizedFileList, index, resolveCache: new Map() };
+}
+// Config loaders extracted to ./language-config.ts (Phase 2 refactor)
+// Resolver types are in ./import-resolvers/types.ts; named binding types in ./named-bindings/types.ts
+// ============================================================================
+// Import path preprocessing
+// ============================================================================
+/**
+ * Clean and preprocess a raw import source text into a resolved import path.
+ * Strips quotes/angle brackets (universal) and applies provider-specific
+ * transformations (currently only Kotlin wildcard import detection).
+ */
+export function preprocessImportPath(sourceText, importNode, provider) {
+    const cleaned = sourceText.replace(/['"<>]/g, '');
+    // Defense-in-depth: reject null bytes and control characters (matches Ruby call-routing pattern)
+    if (!cleaned || cleaned.length > 2048 || /[\x00-\x1f]/.test(cleaned))
+        return null;
+    if (provider.importPathPreprocessor) {
+        return provider.importPathPreprocessor(cleaned, importNode);
+    }
+    return cleaned;
+}
+/** Create IMPORTS edge helpers that share a resolved-count tracker. */
+function createImportEdgeHelpers(graph, importMap) {
+    let totalImportsResolved = 0;
+    const addImportGraphEdge = (filePath, resolvedPath) => {
+        const language = getLanguageFromFilename(filePath);
+        if (language !== null && isRegistryPrimary(language))
+            return;
+        const sourceId = generateId('File', filePath);
+        const targetId = generateId('File', resolvedPath);
+        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
+        totalImportsResolved++;
+        graph.addRelationship({
+            id: relId,
+            sourceId,
+            targetId,
+            type: 'IMPORTS',
+            confidence: 1.0,
+            reason: '',
+        });
+    };
+    const addImportEdge = (filePath, resolvedPath) => {
+        addImportGraphEdge(filePath, resolvedPath);
+        if (!importMap.has(filePath))
+            importMap.set(filePath, new Set());
+        importMap.get(filePath).add(resolvedPath);
+    };
+    return { addImportEdge, addImportGraphEdge, getResolvedCount: () => totalImportsResolved };
+}
+/**
+ * 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.
+ * Bindings tagged with `isModuleAlias` are routed to moduleAliasMap instead.
+ */
+function applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, namedBindings, namedImportMap, moduleAliasMap) {
+    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);
+        }
+        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);
+        }
+        // Route module aliases (import X as Y) directly to moduleAliasMap.
+        // These are module-level aliases, not symbol bindings — they don't belong in namedImportMap.
+        if (namedBindings && moduleAliasMap && files.length === 1) {
+            const resolvedFile = files[0];
+            for (const binding of namedBindings) {
+                if (!binding.isModuleAlias)
+                    continue;
+                let aliasMap = moduleAliasMap.get(filePath);
+                if (!aliasMap) {
+                    aliasMap = new Map();
+                    moduleAliasMap.set(filePath, aliasMap);
+                }
+                aliasMap.set(binding.local, resolvedFile);
+            }
+        }
+        // Record named bindings for precise Tier 2a resolution.
+        // If the same local name is imported from multiple files (e.g., Java static imports
+        // of overloaded methods), remove the entry so resolution falls through to Tier 2a
+        // import-scoped which sees all candidates and can apply arity narrowing.
+        if (namedBindings && namedImportMap) {
+            if (!namedImportMap.has(filePath))
+                namedImportMap.set(filePath, new Map());
+            const fileBindings = namedImportMap.get(filePath);
+            if (files.length === 1) {
+                const resolvedFile = files[0];
+                for (const binding of namedBindings) {
+                    if (binding.isModuleAlias)
+                        continue; // already routed to moduleAliasMap
+                    const existing = fileBindings.get(binding.local);
+                    if (existing && existing.sourcePath !== resolvedFile) {
+                        fileBindings.delete(binding.local);
+                    }
+                    else {
+                        fileBindings.set(binding.local, {
+                            sourcePath: resolvedFile,
+                            exportedName: binding.exported,
+                        });
+                    }
+                }
+            }
+            else {
+                // Multi-file resolution (e.g., Rust `use crate::models::{User, Repo}`).
+                // Match each binding to a resolved file by comparing the lowercase binding name
+                // to the file's basename (without extension). If no match, skip the binding.
+                for (const binding of namedBindings) {
+                    if (binding.isModuleAlias)
+                        continue;
+                    const lowerName = binding.exported.toLowerCase();
+                    const matchedFile = files.find((f) => {
+                        const base = f.replace(/\\/g, '/').split('/').pop() ?? '';
+                        const nameWithoutExt = base.substring(0, base.lastIndexOf('.')).toLowerCase();
+                        return nameWithoutExt === lowerName;
+                    });
+                    if (matchedFile) {
+                        const existing = fileBindings.get(binding.local);
+                        if (existing && existing.sourcePath !== matchedFile) {
+                            fileBindings.delete(binding.local);
+                        }
+                        else {
+                            fileBindings.set(binding.local, {
+                                sourcePath: matchedFile,
+                                exportedName: binding.exported,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+// ============================================================================
+// MAIN IMPORT PROCESSOR
+// ============================================================================
+export const processImports = async (graph, files, astCache, ctx, onProgress, repoRoot, allPaths) => {
+    const importMap = ctx.importMap;
+    const packageMap = ctx.packageMap;
+    const namedImportMap = ctx.namedImportMap;
+    const moduleAliasMap = ctx.moduleAliasMap;
+    // 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, '/'));
+    // Build suffix index for O(1) lookups
+    const index = buildSuffixIndex(normalizedFileList, allFileList);
+    // Track import statistics
+    let totalImportsFound = 0;
+    // Load language-specific configs once before the file loop
+    const configs = await loadImportConfigs(repoRoot || '');
+    const resolveCtx = {
+        allFilePaths,
+        allFileList,
+        normalizedFileList,
+        index,
+        resolveCache,
+        configs,
+    };
+    const { addImportEdge, addImportGraphEdge, getResolvedCount } = createImportEdgeHelpers(graph, importMap);
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        onProgress?.(i + 1, files.length);
+        if (i % 20 === 0)
+            await yieldToEventLoop();
+        // 1. Check language support first
+        const language = getLanguageFromFilename(file.path);
+        if (!language)
+            continue;
+        if (!isLanguageAvailable(language)) {
+            if (skippedByLang) {
+                skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1);
+            }
+            continue;
+        }
+        const provider = getProvider(language);
+        const queryStr = provider.treeSitterQueries;
+        if (!queryStr)
+            continue;
+        // 2. ALWAYS load the language before querying (parser is stateful)
+        await loadLanguage(language, file.path);
+        // 3. Get AST (Try Cache First)
+        let tree = astCache.get(file.path);
+        let wasReparsed = false;
+        if (!tree) {
+            const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
+            try {
+                tree = parseSourceSafe(parser, parseContent, undefined, {
+                    bufferSize: getTreeSitterBufferSize(parseContent),
+                });
+            }
+            catch (parseError) {
+                continue;
+            }
+            wasReparsed = true;
+            // Cache re-parsed tree so call/heritage phases get hits
+            astCache.set(file.path, tree);
+        }
+        let query;
+        let matches;
+        try {
+            const lang = parser.getLanguage();
+            query = new Parser.Query(lang, queryStr);
+            matches = query.matches(tree.rootNode);
+        }
+        catch (queryError) {
+            if (isDev) {
+                logger.error({
+                    file: file.path,
+                    language,
+                    err: queryError?.message || queryError,
+                    queryPreview: queryStr.substring(0, 200) + '...',
+                    contentPreview: file.content.substring(0, 300),
+                    astRootType: tree.rootNode?.type,
+                    astHasError: tree.rootNode?.hasError,
+                }, 'tree-sitter query error');
+            }
+            if (wasReparsed)
+                tree.delete?.();
+            continue;
+        }
+        matches.forEach((match) => {
+            const captureMap = {};
+            match.captures.forEach((c) => (captureMap[c.name] = c.node));
+            if (captureMap['import']) {
+                const sourceNode = captureMap['import.source'];
+                if (!sourceNode) {
+                    if (isDev) {
+                        logger.info(`⚠️ Import captured but no source node in ${file.path}`);
+                    }
+                    return;
+                }
+                const rawImportPath = preprocessImportPath(sourceNode.text, captureMap['import'], provider);
+                if (!rawImportPath)
+                    return;
+                totalImportsFound++;
+                const result = provider.importResolver(rawImportPath, file.path, resolveCtx);
+                const extractor = provider.namedBindingExtractor;
+                const bindings = namedImportMap && extractor ? extractor(captureMap['import']) : undefined;
+                applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge, bindings, namedImportMap, moduleAliasMap);
+            }
+            // ---- Language-specific call-as-import routing (Ruby require, etc.) ----
+            if (captureMap['call']) {
+                const callNameNode = captureMap['call.name'];
+                if (callNameNode) {
+                    const routed = provider.callRouter?.(callNameNode.text, captureMap['call']);
+                    if (routed && routed.kind === 'import') {
+                        totalImportsFound++;
+                        const result = provider.importResolver(routed.importPath, file.path, resolveCtx);
+                        applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge);
+                    }
+                }
+            }
+        });
+        // Tree is now owned by the LRU cache — no manual delete needed
+    }
+    wireImplicitImports(allFileList, importMap, addImportEdge, configs);
+    if (skippedByLang && skippedByLang.size > 0) {
+        for (const [lang, count] of skippedByLang.entries()) {
+            logger.warn(`[ingestion] Skipped ${count} ${lang} file(s) in import processing — ${lang} parser not available.`);
+        }
+    }
+    if (isDev) {
+        logger.info(`📊 Import processing complete: ${getResolvedCount()}/${totalImportsFound} imports resolved to graph edges`);
+    }
+};
+// ============================================================================
+// FAST PATH: Resolve pre-extracted imports (no parsing needed)
+// ============================================================================
+export const processImportsFromExtracted = async (graph, files, extractedImports, ctx, onProgress, repoRoot, prebuiltCtx) => {
+    const importMap = ctx.importMap;
+    const packageMap = ctx.packageMap;
+    const namedImportMap = ctx.namedImportMap;
+    const moduleAliasMap = ctx.moduleAliasMap;
+    const importCtx = prebuiltCtx ?? buildImportResolutionContext(files.map((f) => f.path));
+    const { allFilePaths, allFileList, normalizedFileList, index, resolveCache } = importCtx;
+    let totalImportsFound = 0;
+    const configs = await loadImportConfigs(repoRoot || '');
+    const resolveCtx = {
+        allFilePaths,
+        allFileList,
+        normalizedFileList,
+        index,
+        resolveCache,
+        configs,
+    };
+    const { addImportEdge, addImportGraphEdge, getResolvedCount } = createImportEdgeHelpers(graph, importMap);
+    // Group by file for progress reporting (users see file count, not import count)
+    const importsByFile = new Map();
+    for (const imp of extractedImports) {
+        let list = importsByFile.get(imp.filePath);
+        if (!list) {
+            list = [];
+            importsByFile.set(imp.filePath, list);
+        }
+        list.push(imp);
+    }
+    const totalFiles = importsByFile.size;
+    let filesProcessed = 0;
+    for (const [filePath, fileImports] of importsByFile) {
+        filesProcessed++;
+        if (filesProcessed % 100 === 0) {
+            onProgress?.(filesProcessed, totalFiles);
+            await yieldToEventLoop();
+        }
+        for (const imp of fileImports) {
+            totalImportsFound++;
+            const provider = getProvider(imp.language);
+            const result = provider.importResolver(imp.rawImportPath, filePath, resolveCtx);
+            applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, imp.namedBindings, namedImportMap, moduleAliasMap);
+        }
+    }
+    onProgress?.(totalFiles, totalFiles);
+    wireImplicitImports(files.map((f) => f.path), importMap, addImportEdge, configs);
+    if (isDev) {
+        logger.info(`📊 Import processing (fast path): ${getResolvedCount()}/${totalImportsFound} imports resolved to graph edges`);
+    }
+};

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

@@ -0,0 +1,7 @@
+/**
+ * C / C++ import resolution configs.
+ * Both use standard resolution for #include directives.
+ */
+import type { ImportResolutionConfig } from '../types.js';
+export declare const cImportConfig: ImportResolutionConfig;
+export declare const cppImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/c-cpp.js

@@ -0,0 +1,14 @@
+/**
+ * C / C++ import resolution configs.
+ * Both use standard resolution for #include directives.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+export const cImportConfig = {
+    language: SupportedLanguages.C,
+    strategies: [createStandardStrategy(SupportedLanguages.C)],
+};
+export const cppImportConfig = {
+    language: SupportedLanguages.CPlusPlus,
+    strategies: [createStandardStrategy(SupportedLanguages.CPlusPlus)],
+};

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

@@ -0,0 +1,8 @@
+/**
+ * C# import resolution config.
+ * Namespace-based strategy via .csproj configs, then standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** C# namespace-based resolution strategy via .csproj configs. */
+export declare const csharpNamespaceStrategy: ImportResolverStrategy;
+export declare const csharpImportConfig: ImportResolutionConfig;

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

@@ -0,0 +1,27 @@
+/**
+ * C# import resolution config.
+ * Namespace-based strategy via .csproj configs, then standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+import { resolveCSharpImportInternal, resolveCSharpNamespaceDir } from '../csharp.js';
+/** C# namespace-based resolution strategy via .csproj configs. */
+export const csharpNamespaceStrategy = (rawImportPath, _filePath, ctx) => {
+    const csharpConfigs = ctx.configs.csharpConfigs;
+    if (csharpConfigs.length > 0) {
+        const resolvedFiles = resolveCSharpImportInternal(rawImportPath, csharpConfigs, ctx.normalizedFileList, ctx.allFileList, ctx.index);
+        if (resolvedFiles.length > 1) {
+            const dirSuffix = resolveCSharpNamespaceDir(rawImportPath, csharpConfigs);
+            if (dirSuffix) {
+                return { kind: 'package', files: resolvedFiles, dirSuffix };
+            }
+        }
+        if (resolvedFiles.length > 0)
+            return { kind: 'files', files: resolvedFiles };
+    }
+    return null;
+};
+export const csharpImportConfig = {
+    language: SupportedLanguages.CSharp,
+    strategies: [csharpNamespaceStrategy, createStandardStrategy(SupportedLanguages.CSharp)],
+};

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

@@ -0,0 +1,17 @@
+/**
+ * Dart import resolution config.
+ * SDK/package strategy first, then relative import strategy (with ./ prepending).
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/**
+ * Dart SDK and package: import strategy.
+ * Absorbs dart: SDK imports and external packages (returns empty result to stop chain).
+ * Returns null for relative imports to let the next strategy handle them.
+ */
+export declare const dartPackageStrategy: ImportResolverStrategy;
+/**
+ * Dart relative import strategy — prepends "./" for bare relative paths,
+ * then delegates to standard resolution.
+ */
+export declare const dartRelativeStrategy: ImportResolverStrategy;
+export declare const dartImportConfig: ImportResolutionConfig;

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

@@ -0,0 +1,54 @@
+/**
+ * Dart import resolution config.
+ * SDK/package strategy first, then relative import strategy (with ./ prepending).
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { resolveStandard } from '../standard.js';
+/**
+ * Dart SDK and package: import strategy.
+ * Absorbs dart: SDK imports and external packages (returns empty result to stop chain).
+ * Returns null for relative imports to let the next strategy handle them.
+ */
+export const dartPackageStrategy = (rawImportPath, _filePath, ctx) => {
+    // Strip surrounding quotes from configurable_uri capture
+    const stripped = rawImportPath.replace(/^['"]|['"]$/g, '');
+    // Skip dart: SDK imports (dart:async, dart:io, etc.)
+    if (stripped.startsWith('dart:'))
+        return { kind: 'files', files: [] };
+    // Local package: imports → resolve to lib/<path>
+    if (stripped.startsWith('package:')) {
+        const slashIdx = stripped.indexOf('/');
+        if (slashIdx === -1)
+            return { kind: 'files', files: [] };
+        const relPath = stripped.slice(slashIdx + 1);
+        const candidates = [`lib/${relPath}`, relPath];
+        const files = [];
+        for (const candidate of candidates) {
+            for (const fp of ctx.allFileList) {
+                if (fp.endsWith('/' + candidate) || fp === candidate) {
+                    files.push(fp);
+                    break;
+                }
+            }
+            if (files.length > 0)
+                break;
+        }
+        if (files.length > 0)
+            return { kind: 'files', files };
+        return { kind: 'files', files: [] }; // external package
+    }
+    return null;
+};
+/**
+ * Dart relative import strategy — prepends "./" for bare relative paths,
+ * then delegates to standard resolution.
+ */
+export const dartRelativeStrategy = (rawImportPath, filePath, ctx) => {
+    const stripped = rawImportPath.replace(/^['"]|['"]$/g, '');
+    const relPath = stripped.startsWith('.') ? stripped : './' + stripped;
+    return resolveStandard(relPath, filePath, ctx, SupportedLanguages.Dart);
+};
+export const dartImportConfig = {
+    language: SupportedLanguages.Dart,
+    strategies: [dartPackageStrategy, dartRelativeStrategy],
+};

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

@@ -0,0 +1,8 @@
+/**
+ * Go import resolution config.
+ * Go-specific package strategy (go.mod), then standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** Go-specific package resolution strategy — resolves go.mod-based package imports. */
+export declare const goPackageStrategy: ImportResolverStrategy;
+export declare const goImportConfig: ImportResolutionConfig;

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

@@ -0,0 +1,26 @@
+/**
+ * Go import resolution config.
+ * Go-specific package strategy (go.mod), then standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+import { resolveGoPackageDir, resolveGoPackage } from '../go.js';
+/** Go-specific package resolution strategy — resolves go.mod-based package imports. */
+export const goPackageStrategy = (rawImportPath, _filePath, ctx) => {
+    const goModule = ctx.configs.goModule;
+    if (goModule && rawImportPath.startsWith(goModule.modulePath)) {
+        const pkgSuffix = resolveGoPackageDir(rawImportPath, goModule);
+        if (pkgSuffix) {
+            const pkgFiles = resolveGoPackage(rawImportPath, goModule, ctx.normalizedFileList, ctx.allFileList);
+            if (pkgFiles.length > 0) {
+                return { kind: 'package', files: pkgFiles, dirSuffix: pkgSuffix };
+            }
+        }
+        // Fall through if no files found (package might be external)
+    }
+    return null;
+};
+export const goImportConfig = {
+    language: SupportedLanguages.Go,
+    strategies: [goPackageStrategy, createStandardStrategy(SupportedLanguages.Go)],
+};

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

@@ -0,0 +1,13 @@
+/**
+ * Java / Kotlin import resolution configs.
+ * JVM-specific wildcard/member strategy, then standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** Java JVM resolution strategy — wildcard and member import resolution. */
+export declare const javaJvmStrategy: ImportResolverStrategy;
+/**
+ * Kotlin JVM resolution strategy — wildcard/member with Java-interop + top-level function imports.
+ */
+export declare const kotlinJvmStrategy: ImportResolverStrategy;
+export declare const javaImportConfig: ImportResolutionConfig;
+export declare const kotlinImportConfig: ImportResolutionConfig;

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],
+};