gitnexus 1.6.2-rc.2 → 1.6.2-rc.21

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

@@ -1,4 +1,4 @@
-import { CLASS_TYPES, CALL_TARGET_TYPES } from './model/symbol-table.js';
+import { CLASS_TYPES, CALL_TARGET_TYPES, lookupMethodByOwnerWithMRO } from './model/index.js';
 import Parser from 'tree-sitter';
 import { TIER_CONFIDENCE } from './model/resolution-context.js';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
@@ -15,8 +15,6 @@ import { getTreeSitterBufferSize } from './constants.js';
 import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js';
 import { extractTemplateComponents } from './vue-sfc-extractor.js';
 import { extractReturnTypeName, stripNullable } from './type-extractors/shared.js';
-import { extractParsedCallSite } from './call-sites/extract-language-call-site.js';
-import { lookupMethodByOwnerWithMRO } from './model/resolve.js';
 /**
  * Type labels treated as class-like **method-dispatch receivers** by the call
  * resolver — the set walked by the MRO / heritage path for member and static
@@ -733,52 +731,56 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
             if (!captureMap['call'])
                 return;
             const callNode = captureMap['call'];
-            const languageSeed = extractParsedCallSite(language, callNode);
-            if (languageSeed) {
-                if (provider.isBuiltInName(languageSeed.calledName))
-                    return;
-                const sourceId = findEnclosingFunction(callNode, file.path, ctx, provider) ||
-                    generateId('File', file.path);
-                const receiverName = languageSeed.callForm === 'member' ? languageSeed.receiverName : undefined;
-                let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
-                if (receiverName !== undefined &&
-                    receiverTypeName === undefined &&
-                    languageSeed.callForm === 'member' &&
-                    (language === 'java' || language === 'csharp' || language === 'kotlin')) {
-                    const c0 = receiverName.charCodeAt(0);
-                    if (c0 >= 65 && c0 <= 90)
-                        receiverTypeName = receiverName;
-                }
-                const resolved = resolveCallTarget({
-                    calledName: languageSeed.calledName,
-                    callForm: languageSeed.callForm,
-                    ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
-                    ...(receiverName !== undefined ? { receiverName } : {}),
-                }, file.path, ctx, undefined, widenCache, undefined, heritageMap);
-                if (!resolved)
-                    return;
-                graph.addRelationship({
-                    id: generateId('CALLS', `${sourceId}:${languageSeed.calledName}->${resolved.nodeId}`),
-                    sourceId,
-                    targetId: resolved.nodeId,
-                    type: 'CALLS',
-                    confidence: resolved.confidence,
-                    reason: resolved.reason,
-                });
-                if (heritageMap && languageSeed.callForm === 'member' && receiverTypeName) {
-                    const implTargets = findInterfaceDispatchTargets(languageSeed.calledName, receiverTypeName, file.path, ctx, heritageMap, resolved.nodeId);
-                    for (const impl of implTargets) {
-                        graph.addRelationship({
-                            id: generateId('CALLS', `${sourceId}:${languageSeed.calledName}->${impl.nodeId}`),
-                            sourceId,
-                            targetId: impl.nodeId,
-                            type: 'CALLS',
-                            confidence: impl.confidence,
-                            reason: impl.reason,
-                        });
+            const callExtractor = provider.callExtractor;
+            // ── Language-specific call site (e.g. Java :: method references) ──
+            if (callExtractor) {
+                const langCallSite = callExtractor.extract(callNode, undefined);
+                if (langCallSite) {
+                    if (provider.isBuiltInName(langCallSite.calledName))
+                        return;
+                    const sourceId = findEnclosingFunction(callNode, file.path, ctx, provider) ||
+                        generateId('File', file.path);
+                    const receiverName = langCallSite.callForm === 'member' ? langCallSite.receiverName : undefined;
+                    let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
+                    if (langCallSite.typeAsReceiverHeuristic &&
+                        receiverName !== undefined &&
+                        receiverTypeName === undefined &&
+                        langCallSite.callForm === 'member') {
+                        const c0 = receiverName.charCodeAt(0);
+                        if (c0 >= 65 && c0 <= 90)
+                            receiverTypeName = receiverName;
                     }
+                    const resolved = resolveCallTarget({
+                        calledName: langCallSite.calledName,
+                        callForm: langCallSite.callForm,
+                        ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
+                        ...(receiverName !== undefined ? { receiverName } : {}),
+                    }, file.path, ctx, undefined, widenCache, undefined, heritageMap);
+                    if (!resolved)
+                        return;
+                    graph.addRelationship({
+                        id: generateId('CALLS', `${sourceId}:${langCallSite.calledName}->${resolved.nodeId}`),
+                        sourceId,
+                        targetId: resolved.nodeId,
+                        type: 'CALLS',
+                        confidence: resolved.confidence,
+                        reason: resolved.reason,
+                    });
+                    if (heritageMap && langCallSite.callForm === 'member' && receiverTypeName) {
+                        const implTargets = findInterfaceDispatchTargets(langCallSite.calledName, receiverTypeName, file.path, ctx, heritageMap, resolved.nodeId);
+                        for (const impl of implTargets) {
+                            graph.addRelationship({
+                                id: generateId('CALLS', `${sourceId}:${langCallSite.calledName}->${impl.nodeId}`),
+                                sourceId,
+                                targetId: impl.nodeId,
+                                type: 'CALLS',
+                                confidence: impl.confidence,
+                                reason: impl.reason,
+                            });
+                        }
+                    }
+                    return;
                 }
-                return;
             }
             const nameNode = captureMap['call.name'];
             if (!nameNode)

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

@@ -0,0 +1,60 @@
+/**
+ * Types for the language-agnostic call extraction pipeline.
+ *
+ * Mirrors method-types.ts / field-types.ts: defines the domain interfaces
+ * consumed by createCallExtractor() and the per-language configs.
+ */
+import type { SupportedLanguages } from '../../_shared/index.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
+import type { MixedChainStep } from './utils/call-analysis.js';
+/**
+ * Per-node call extraction result.  The parse worker enriches this with
+ * file-level context (filePath, sourceId, TypeEnv lookups, arg types) to
+ * produce the final `ExtractedCall` that enters the resolution pipeline.
+ */
+export interface ExtractedCallSite {
+    calledName: string;
+    callForm?: 'free' | 'member' | 'constructor';
+    receiverName?: string;
+    argCount?: number;
+    /** Unified mixed chain for complex receivers (field + call chains). */
+    receiverMixedChain?: MixedChainStep[];
+    /** When true, the type-as-receiver heuristic applies: if receiverName
+     *  starts with an uppercase letter and has no TypeEnv binding, treat it
+     *  as a type name (e.g. Java `User::getName`). */
+    typeAsReceiverHeuristic?: boolean;
+}
+export interface CallExtractor {
+    readonly language: SupportedLanguages;
+    /**
+     * Extract a call site from captured AST nodes.
+     *
+     * @param callNode     The @call capture (call_expression, method_invocation, …)
+     * @param callNameNode The @call.name capture (identifier inside the call).
+     *                     May be undefined when the call shape has no name capture
+     *                     (e.g. Java method_reference via `::`).
+     * @returns Extracted call site, or null when no call can be derived.
+     */
+    extract(callNode: SyntaxNode, callNameNode: SyntaxNode | undefined): ExtractedCallSite | null;
+}
+export interface CallExtractionConfig {
+    language: SupportedLanguages;
+    /**
+     * Language-specific call site extraction.  Called **before** the generic
+     * path.  If it returns non-null, the generic `inferCallForm` /
+     * `extractReceiverName` path is skipped entirely.
+     *
+     * Use this for call shapes that don't follow the standard `@call` /
+     * `@call.name` pattern (e.g. Java `method_reference` via `::`).
+     */
+    extractLanguageCallSite?: (callNode: SyntaxNode) => ExtractedCallSite | null;
+    /**
+     * Whether the type-as-receiver heuristic applies for this language.
+     * When true and the receiver name starts with an uppercase letter,
+     * the receiver is treated as a type name when no TypeEnv binding exists.
+     *
+     * Applies to JVM and C# languages where `Type.method()` and `Type::method`
+     * are common patterns.
+     */
+    typeAsReceiverHeuristic?: boolean;
+}

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

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

package/dist/core/ingestion/class-extractors/configs/c-cpp.d.ts

@@ -0,0 +1,3 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const cClassConfig: ClassExtractionConfig;
+export declare const cppClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/c-cpp.js

@@ -0,0 +1,11 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/c-cpp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const cClassConfig = {
+    language: SupportedLanguages.C,
+    typeDeclarationNodes: ['struct_specifier', 'enum_specifier'],
+};
+export const cppClassConfig = {
+    language: SupportedLanguages.CPlusPlus,
+    typeDeclarationNodes: ['class_specifier', 'struct_specifier', 'enum_specifier'],
+    ancestorScopeNodeTypes: ['namespace_definition', 'class_specifier', 'struct_specifier'],
+};

package/dist/core/ingestion/class-extractors/configs/csharp.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const csharpClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/csharp.js

@@ -0,0 +1,21 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/csharp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const csharpClassConfig = {
+    language: SupportedLanguages.CSharp,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'interface_declaration',
+        'struct_declaration',
+        'enum_declaration',
+        'record_declaration',
+    ],
+    fileScopeNodeTypes: ['file_scoped_namespace_declaration'],
+    ancestorScopeNodeTypes: [
+        'namespace_declaration',
+        'class_declaration',
+        'interface_declaration',
+        'struct_declaration',
+        'enum_declaration',
+        'record_declaration',
+    ],
+};

package/dist/core/ingestion/class-extractors/configs/dart.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const dartClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/dart.js

@@ -0,0 +1,7 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/dart.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const dartClassConfig = {
+    language: SupportedLanguages.Dart,
+    typeDeclarationNodes: ['class_definition', 'extension_declaration', 'enum_declaration'],
+    ancestorScopeNodeTypes: ['class_definition', 'extension_declaration', 'enum_declaration'],
+};

package/dist/core/ingestion/class-extractors/configs/go.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const goClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/go.js

@@ -0,0 +1,20 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/go.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const goClassConfig = {
+    language: SupportedLanguages.Go,
+    typeDeclarationNodes: ['type_declaration'],
+    fileScopeNodeTypes: ['package_clause'],
+    extractName(node) {
+        const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
+        return typeSpec?.childForFieldName('name')?.text;
+    },
+    extractType(node) {
+        const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
+        const typeNode = typeSpec?.childForFieldName('type');
+        if (typeNode?.type === 'struct_type')
+            return 'Struct';
+        if (typeNode?.type === 'interface_type')
+            return 'Interface';
+        return undefined;
+    },
+};

package/dist/core/ingestion/class-extractors/configs/jvm.d.ts

@@ -0,0 +1,3 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const javaClassConfig: ClassExtractionConfig;
+export declare const kotlinClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/jvm.js

@@ -0,0 +1,35 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/jvm.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+// ---------------------------------------------------------------------------
+// Java
+// ---------------------------------------------------------------------------
+export const javaClassConfig = {
+    language: SupportedLanguages.Java,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+    ],
+    fileScopeNodeTypes: ['package_declaration'],
+    ancestorScopeNodeTypes: [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+    ],
+};
+// ---------------------------------------------------------------------------
+// Kotlin
+// ---------------------------------------------------------------------------
+export const kotlinClassConfig = {
+    language: SupportedLanguages.Kotlin,
+    typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
+    fileScopeNodeTypes: ['package_header'],
+    ancestorScopeNodeTypes: ['class_declaration', 'object_declaration', 'companion_object'],
+    extractType(node) {
+        if (node.type !== 'class_declaration')
+            return undefined;
+        return node.children.some((child) => child?.text === 'interface') ? 'Interface' : 'Class';
+    },
+};

package/dist/core/ingestion/class-extractors/configs/php.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const phpClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/php.js

@@ -0,0 +1,7 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/php.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const phpClassConfig = {
+    language: SupportedLanguages.PHP,
+    typeDeclarationNodes: ['class_declaration', 'interface_declaration', 'enum_declaration'],
+    ancestorScopeNodeTypes: ['namespace_definition'],
+};

package/dist/core/ingestion/class-extractors/configs/python.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const pythonClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/python.js

@@ -0,0 +1,7 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/python.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const pythonClassConfig = {
+    language: SupportedLanguages.Python,
+    typeDeclarationNodes: ['class_definition'],
+    ancestorScopeNodeTypes: ['class_definition'],
+};

package/dist/core/ingestion/class-extractors/configs/ruby.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const rubyClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/ruby.js

@@ -0,0 +1,7 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/ruby.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const rubyClassConfig = {
+    language: SupportedLanguages.Ruby,
+    typeDeclarationNodes: ['class'],
+    ancestorScopeNodeTypes: ['module', 'class'],
+};

package/dist/core/ingestion/class-extractors/configs/rust.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const rustClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/rust.js

@@ -0,0 +1,7 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/rust.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const rustClassConfig = {
+    language: SupportedLanguages.Rust,
+    typeDeclarationNodes: ['struct_item', 'enum_item'],
+    ancestorScopeNodeTypes: ['mod_item', 'struct_item', 'enum_item'],
+};

package/dist/core/ingestion/class-extractors/configs/swift.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const swiftClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/swift.js

@@ -0,0 +1,18 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/swift.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const swiftClassConfig = {
+    language: SupportedLanguages.Swift,
+    typeDeclarationNodes: ['class_declaration', 'protocol_declaration'],
+    ancestorScopeNodeTypes: ['class_declaration', 'protocol_declaration'],
+    extractType(node) {
+        if (node.type === 'protocol_declaration')
+            return 'Interface';
+        if (node.type !== 'class_declaration')
+            return undefined;
+        if (node.children.some((child) => child?.text === 'struct'))
+            return 'Struct';
+        if (node.children.some((child) => child?.text === 'enum'))
+            return 'Enum';
+        return 'Class';
+    },
+};

package/dist/core/ingestion/class-extractors/configs/typescript-javascript.d.ts

@@ -0,0 +1,4 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const typescriptClassConfig: ClassExtractionConfig;
+export declare const javascriptClassConfig: ClassExtractionConfig;
+export declare const vueClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/typescript-javascript.js

@@ -0,0 +1,28 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/typescript-javascript.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+const shared = {
+    typeDeclarationNodes: [
+        'class_declaration',
+        'abstract_class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+    ],
+    ancestorScopeNodeTypes: [
+        'class_declaration',
+        'abstract_class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+    ],
+};
+export const typescriptClassConfig = {
+    ...shared,
+    language: SupportedLanguages.TypeScript,
+};
+export const javascriptClassConfig = {
+    ...shared,
+    language: SupportedLanguages.JavaScript,
+};
+export const vueClassConfig = {
+    ...shared,
+    language: SupportedLanguages.Vue,
+};

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

@@ -1,5 +1,5 @@
 import type { TypeEnvironment } from './type-env.js';
-import type { SymbolTableReader } from './model/symbol-table.js';
+import type { SymbolTableReader } from './model/index.js';
 import { SupportedLanguages } from '../../_shared/index.js';
 /**
  * Visibility levels used across all supported languages.

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;