gitnexus 1.6.2-rc.9 → 1.6.2

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

@@ -54,6 +54,69 @@ const resolveHeritageId = (name, filePath, ctx, fallbackLabel, fallbackKey) => {
         confidence: TIER_CONFIDENCE['global'],
     };
 };
+/**
+ * Resolve a single HeritageInfo to a graph edge, using the same resolution
+ * logic as processHeritageFromExtracted.  This bridges the heritage extractor
+ * output format to the graph-resolution side.
+ */
+const resolveAndAddHeritageEdge = (graph, item, filePath, language, ctx) => {
+    if (item.kind === 'extends') {
+        const { type: relType, idPrefix } = resolveExtendsType(item.parentName, filePath, ctx, getHeritageStrategyForLanguage(language));
+        const child = resolveHeritageId(item.className, filePath, ctx, 'Class', `${filePath}:${item.className}`);
+        const parent = resolveHeritageId(item.parentName, filePath, ctx, idPrefix);
+        if (child.id && parent.id && child.id !== parent.id) {
+            graph.addRelationship({
+                id: generateId(relType, `${child.id}->${parent.id}`),
+                sourceId: child.id,
+                targetId: parent.id,
+                type: relType,
+                confidence: Math.sqrt(child.confidence * parent.confidence),
+                reason: '',
+            });
+        }
+    }
+    else if (item.kind === 'implements') {
+        const cls = resolveHeritageId(item.className, filePath, ctx, 'Class', `${filePath}:${item.className}`);
+        const iface = resolveHeritageId(item.parentName, filePath, ctx, 'Interface');
+        if (cls.id && iface.id) {
+            graph.addRelationship({
+                id: generateId('IMPLEMENTS', `${cls.id}->${iface.id}`),
+                sourceId: cls.id,
+                targetId: iface.id,
+                type: 'IMPLEMENTS',
+                confidence: Math.sqrt(cls.confidence * iface.confidence),
+                reason: '',
+            });
+        }
+    }
+    else if (item.kind === 'trait-impl' ||
+        item.kind === 'include' ||
+        item.kind === 'extend' ||
+        item.kind === 'prepend') {
+        // Fallback label for an unresolved child name. Rust `trait-impl` children
+        // are structs; Ruby mixin children are classes or modules (Trait). For
+        // Ruby mixin kinds the common case resolves through the type registry
+        // post-plan-001, so the fallback only fires for true-unresolved references
+        // (e.g. mixin inside a singleton_class). `Class` is strictly better than
+        // `Struct` there because it matches the label the structure phase would
+        // emit for a Ruby `class` — the dominant shape. Ruby modules that fail
+        // to resolve still lose their `Trait` label in the synthesized id, but
+        // they fail to resolve rarely and the tradeoff is documented.
+        const childFallbackLabel = item.kind === 'trait-impl' ? 'Struct' : 'Class';
+        const strct = resolveHeritageId(item.className, filePath, ctx, childFallbackLabel, `${filePath}:${item.className}`);
+        const trait = resolveHeritageId(item.parentName, filePath, ctx, 'Trait');
+        if (strct.id && trait.id) {
+            graph.addRelationship({
+                id: generateId('IMPLEMENTS', `${strct.id}->${trait.id}:${item.kind}`),
+                sourceId: strct.id,
+                targetId: trait.id,
+                type: 'IMPLEMENTS',
+                confidence: Math.sqrt(strct.confidence * trait.confidence),
+                reason: item.kind,
+            });
+        }
+    }
+};
 export const processHeritage = async (graph, files, astCache, ctx, onProgress) => {
     const parser = await loadParser();
     const logSkipped = isVerboseIngestionEnabled();
@@ -98,78 +161,31 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
         let query;
         let matches;
         try {
-            const language = parser.getLanguage();
-            query = new Parser.Query(language, queryStr);
+            const treeSitterLang = parser.getLanguage();
+            query = new Parser.Query(treeSitterLang, queryStr);
             matches = query.matches(tree.rootNode);
         }
         catch (queryError) {
             console.warn(`Heritage query error for ${file.path}:`, queryError);
             continue;
         }
-        // 4. Process heritage matches
+        // 4. Process heritage matches via provider heritage extractor
+        const heritageExtractor = provider.heritageExtractor;
         matches.forEach((match) => {
             const captureMap = {};
             match.captures.forEach((c) => {
                 captureMap[c.name] = c.node;
             });
-            // EXTENDS or IMPLEMENTS: resolve via symbol table for languages where
-            // the tree-sitter query can't distinguish classes from interfaces (C#, Java)
-            if (captureMap['heritage.class'] && captureMap['heritage.extends']) {
-                // Go struct embedding: skip named fields (only anonymous fields are embedded)
-                const extendsNode = captureMap['heritage.extends'];
-                const fieldDecl = extendsNode.parent;
-                if (fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName('name')) {
-                    return; // Named field, not struct embedding
-                }
-                const className = captureMap['heritage.class'].text;
-                const parentClassName = captureMap['heritage.extends'].text;
-                const { type: relType, idPrefix } = resolveExtendsType(parentClassName, file.path, ctx, getHeritageStrategyForLanguage(language));
-                const child = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`);
-                const parent = resolveHeritageId(parentClassName, file.path, ctx, idPrefix);
-                if (child.id && parent.id && child.id !== parent.id) {
-                    graph.addRelationship({
-                        id: generateId(relType, `${child.id}->${parent.id}`),
-                        sourceId: child.id,
-                        targetId: parent.id,
-                        type: relType,
-                        confidence: Math.sqrt(child.confidence * parent.confidence),
-                        reason: '',
-                    });
-                }
-            }
-            // IMPLEMENTS: Class implements Interface (TypeScript only)
-            if (captureMap['heritage.class'] && captureMap['heritage.implements']) {
-                const className = captureMap['heritage.class'].text;
-                const interfaceName = captureMap['heritage.implements'].text;
-                const cls = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`);
-                const iface = resolveHeritageId(interfaceName, file.path, ctx, 'Interface');
-                if (cls.id && iface.id) {
-                    graph.addRelationship({
-                        id: generateId('IMPLEMENTS', `${cls.id}->${iface.id}`),
-                        sourceId: cls.id,
-                        targetId: iface.id,
-                        type: 'IMPLEMENTS',
-                        confidence: Math.sqrt(cls.confidence * iface.confidence),
-                        reason: '',
-                    });
-                }
-            }
-            // IMPLEMENTS (Rust): impl Trait for Struct
-            if (captureMap['heritage.trait'] && captureMap['heritage.class']) {
-                const structName = captureMap['heritage.class'].text;
-                const traitName = captureMap['heritage.trait'].text;
-                const strct = resolveHeritageId(structName, file.path, ctx, 'Struct', `${file.path}:${structName}`);
-                const trait = resolveHeritageId(traitName, file.path, ctx, 'Trait');
-                if (strct.id && trait.id) {
-                    graph.addRelationship({
-                        id: generateId('IMPLEMENTS', `${strct.id}->${trait.id}`),
-                        sourceId: strct.id,
-                        targetId: trait.id,
-                        type: 'IMPLEMENTS',
-                        confidence: Math.sqrt(strct.confidence * trait.confidence),
-                        reason: 'trait-impl',
-                    });
-                }
+            if (!captureMap['heritage.class'])
+                return;
+            if (!heritageExtractor)
+                return;
+            const heritageItems = heritageExtractor.extract(captureMap, {
+                filePath: file.path,
+                language,
+            });
+            for (const item of heritageItems) {
+                resolveAndAddHeritageEdge(graph, item, file.path, language, ctx);
             }
         });
         // Tree is now owned by the LRU cache — no manual delete needed
@@ -228,7 +244,11 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
             h.kind === 'include' ||
             h.kind === 'extend' ||
             h.kind === 'prepend') {
-            const strct = resolveHeritageId(h.className, h.filePath, ctx, 'Struct', `${h.filePath}:${h.className}`);
+            // See the per-item call above (processHeritageFromExtractedItem) for
+            // rationale: `Class` is the correct fallback for Ruby mixin kinds,
+            // `Struct` stays the Rust `trait-impl` default.
+            const childFallbackLabel = h.kind === 'trait-impl' ? 'Struct' : 'Class';
+            const strct = resolveHeritageId(h.className, h.filePath, ctx, childFallbackLabel, `${h.filePath}:${h.className}`);
             const trait = resolveHeritageId(h.parentName, h.filePath, ctx, 'Trait');
             if (strct.id && trait.id) {
                 graph.addRelationship({
@@ -249,6 +269,15 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
  * {@link ExtractedHeritage} rows without mutating the graph. Used on the
  * sequential pipeline path so `buildHeritageMap(..., ctx)` can run before
  * `processCalls` (worker path defers calls until heritage from all chunks exists).
+ *
+ * This prepass extracts BOTH capture-based heritage (`@heritage.*` — extends /
+ * implements / trait-impl) AND call-based heritage (`@call.name` routed through
+ * `heritageExtractor.extractFromCall` — Ruby `include` / `extend` / `prepend`).
+ * Without the second pass, sequential-mode `sequentialHeritageMap` would not
+ * know about Ruby mixin ancestry before `processCalls` resolves calls against
+ * it, silently dropping mixed-in methods from the graph. This function stays
+ * read-only — `processCalls` still owns emission of heritage graph edges via
+ * its `rubyHeritage` return path.
  */
 export async function extractExtractedHeritageFromFiles(files, astCache) {
     const parser = await loadParser();
@@ -283,40 +312,46 @@ export async function extractExtractedHeritageFromFiles(files, astCache) {
         catch {
             continue;
         }
+        const callBasedEnabled = !!provider.heritageExtractor?.extractFromCall;
         for (const match of matches) {
             const captureMap = {};
             match.captures.forEach((c) => {
                 captureMap[c.name] = c.node;
             });
             if (captureMap['heritage.class']) {
-                if (captureMap['heritage.extends']) {
-                    const extendsNode = captureMap['heritage.extends'];
-                    const fieldDecl = extendsNode.parent;
-                    const isNamedField = fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName('name');
-                    if (!isNamedField) {
+                if (provider.heritageExtractor) {
+                    const heritageItems = provider.heritageExtractor.extract(captureMap, {
+                        filePath: file.path,
+                        language,
+                    });
+                    for (const item of heritageItems) {
                         out.push({
                             filePath: file.path,
-                            className: captureMap['heritage.class'].text,
-                            parentName: captureMap['heritage.extends'].text,
-                            kind: 'extends',
+                            className: item.className,
+                            parentName: item.parentName,
+                            kind: item.kind,
                         });
                     }
                 }
-                if (captureMap['heritage.implements']) {
-                    out.push({
-                        filePath: file.path,
-                        className: captureMap['heritage.class'].text,
-                        parentName: captureMap['heritage.implements'].text,
-                        kind: 'implements',
-                    });
-                }
-                if (captureMap['heritage.trait']) {
-                    out.push({
-                        filePath: file.path,
-                        className: captureMap['heritage.class'].text,
-                        parentName: captureMap['heritage.trait'].text,
-                        kind: 'trait-impl',
-                    });
+                continue;
+            }
+            // Call-based heritage (e.g. Ruby include/extend/prepend). Matches the
+            // routing the worker path performs inline in parse-worker.ts — see the
+            // `provider.heritageExtractor?.extractFromCall` branch there. We only
+            // need call-based records here; other @call captures are consumed by
+            // processCalls later in the sequential loop.
+            if (callBasedEnabled && captureMap['call'] && captureMap['call.name']) {
+                const calledName = captureMap['call.name'].text;
+                const heritageItems = provider.heritageExtractor.extractFromCall(calledName, captureMap['call'], { filePath: file.path, language });
+                if (heritageItems) {
+                    for (const item of heritageItems) {
+                        out.push({
+                            filePath: file.path,
+                            className: item.className,
+                            parentName: item.parentName,
+                            kind: item.kind,
+                        });
+                    }
                 }
             }
         }

package/dist/core/ingestion/heritage-types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Types for the language-agnostic heritage extraction pipeline.
+ *
+ * Follows the same pattern as call-types.ts, variable-types.ts, and
+ * method-types.ts: defines the domain interfaces consumed by
+ * createHeritageExtractor() and the per-language configs.
+ *
+ * Heritage extraction handles extends/implements/trait-impl captures from
+ * tree-sitter queries, plus call-based heritage for languages like Ruby
+ * (include/extend/prepend expressed as method calls).
+ */
+import type { SupportedLanguages } from '../../_shared/index.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
+import type { CaptureMap } from './language-provider.js';
+/**
+ * Per-match heritage extraction result.  The parse worker adds filePath to
+ * produce the final {@link ExtractedHeritage} that enters the resolution
+ * pipeline (heritage-processor.ts / heritage-map.ts).
+ */
+export interface HeritageInfo {
+    className: string;
+    parentName: string;
+    /** 'extends' | 'implements' | 'trait-impl' | 'include' | 'extend' | 'prepend' */
+    kind: string;
+}
+export interface HeritageExtractorContext {
+    filePath: string;
+    language: SupportedLanguages;
+}
+export interface HeritageExtractor {
+    readonly language: SupportedLanguages;
+    /**
+     * Extract heritage records from tree-sitter @heritage.* captures.
+     *
+     * @param captureMap  The capture map from a single tree-sitter match
+     * @param context     File path and language context
+     * @returns Array of heritage records (may be empty if captures don't match)
+     */
+    extract(captureMap: CaptureMap, context: HeritageExtractorContext): HeritageInfo[];
+    /**
+     * Extract heritage from a call node (for languages where heritage is
+     * expressed as method calls, e.g., Ruby include/extend/prepend).
+     *
+     * @param calledName  The method name (e.g. 'include', 'extend', 'prepend')
+     * @param callNode    The tree-sitter call AST node
+     * @param context     File path and language context
+     * @returns Heritage records if the call is heritage-related, or null to
+     *          fall through to the call router / normal call handling.
+     */
+    extractFromCall?(calledName: string, callNode: SyntaxNode, context: HeritageExtractorContext): HeritageInfo[] | null;
+}
+export interface HeritageExtractionConfig {
+    language: SupportedLanguages;
+    /**
+     * Called for heritage.extends captures.  Return true to skip this extends
+     * capture.  Used by Go to skip named struct fields that match the
+     * field_declaration pattern but are not anonymous embeddings.
+     *
+     * Default: never skip (all extends captures are valid).
+     */
+    shouldSkipExtends?: (extendsNode: SyntaxNode) => boolean;
+    /**
+     * Call-based heritage extraction for languages where heritage is expressed
+     * as method calls (e.g., Ruby include/extend/prepend).
+     *
+     * callNames: set of method names that trigger heritage extraction.
+     * extract:   extract heritage items from the call node + method name.
+     */
+    callBasedHeritage?: {
+        readonly callNames: ReadonlySet<string>;
+        extract(calledName: string, callNode: SyntaxNode, filePath: string): HeritageInfo[];
+    };
+}

package/dist/core/ingestion/heritage-types.js

@@ -0,0 +1,2 @@
+// gitnexus/src/core/ingestion/heritage-types.ts
+export {};

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/{dart.js → configs/dart.js}

@@ -1,21 +1,25 @@
 /**
- * Dart import resolution.
- * Handles package: imports (local packages) and relative imports.
- * SDK imports (dart:*) and external packages are skipped.
+ * Dart import resolution config.
+ * SDK/package strategy first, then relative import strategy (with ./ prepending).
  */
-import { resolveStandard } from './standard.js';
-import { SupportedLanguages } from '../../../_shared/index.js';
-export function resolveDartImport(rawImportPath, filePath, ctx) {
+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 null;
+        return { kind: 'files', files: [] };
     // Local package: imports → resolve to lib/<path>
     if (stripped.startsWith('package:')) {
         const slashIdx = stripped.indexOf('/');
         if (slashIdx === -1)
-            return null;
+            return { kind: 'files', files: [] };
         const relPath = stripped.slice(slashIdx + 1);
         const candidates = [`lib/${relPath}`, relPath];
         const files = [];
@@ -31,14 +35,20 @@ export function resolveDartImport(rawImportPath, filePath, ctx) {
         }
         if (files.length > 0)
             return { kind: 'files', files };
-        return null;
+        return { kind: 'files', files: [] }; // external package
     }
-    // Relative imports — use standard resolution.
-    // Dart relative imports don't require a leading "./" (e.g. `import 'models.dart'`).
-    // The standard resolver only recognises paths starting with "." as relative, so
-    // prepend "./" when the path doesn't already start with "." to ensure correct
-    // same-directory resolution (without this, "models.dart" would be mangled by the
-    // generic dot-to-slash conversion intended for Java-style package imports).
+    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],
+};

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;