gitnexus 1.6.2-rc.14 → 1.6.2-rc.15

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

@@ -0,0 +1,3 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const cCallConfig: CallExtractionConfig;
+export declare const cppCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,8 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/c-cpp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const cCallConfig = {
+    language: SupportedLanguages.C,
+};
+export const cppCallConfig = {
+    language: SupportedLanguages.CPlusPlus,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const csharpCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,6 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/csharp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const csharpCallConfig = {
+    language: SupportedLanguages.CSharp,
+    typeAsReceiverHeuristic: true,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const dartCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/dart.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const dartCallConfig = {
+    language: SupportedLanguages.Dart,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const goCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/go.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const goCallConfig = {
+    language: SupportedLanguages.Go,
+};

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

@@ -0,0 +1,3 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const javaCallConfig: CallExtractionConfig;
+export declare const kotlinCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,51 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/jvm.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+// ---------------------------------------------------------------------------
+// Java method_reference (::) parsing — absorbs call-sites/java.ts
+// ---------------------------------------------------------------------------
+/**
+ * Parse Java `method_reference` nodes (`expr::method`, `Type::new`,
+ * `this::m`, `super::m`).
+ */
+function parseJavaMethodReference(callNode) {
+    if (callNode.type !== 'method_reference')
+        return null;
+    const recv = callNode.namedChild(0);
+    if (!recv)
+        return null;
+    // Type::new  →  constructor call
+    for (const c of callNode.children) {
+        if (c.type === 'new') {
+            if (recv.type !== 'identifier')
+                return null;
+            return { calledName: recv.text, callForm: 'constructor' };
+        }
+    }
+    // expr::method  →  member call with receiver
+    const rhs = callNode.child(callNode.childCount - 1);
+    if (!rhs || rhs.type !== 'identifier')
+        return null;
+    const methodName = rhs.text;
+    if (recv.type === 'identifier') {
+        return { calledName: methodName, callForm: 'member', receiverName: recv.text };
+    }
+    if (recv.type === 'this') {
+        return { calledName: methodName, callForm: 'member', receiverName: 'this' };
+    }
+    if (recv.type === 'super') {
+        return { calledName: methodName, callForm: 'member', receiverName: 'super' };
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Configs
+// ---------------------------------------------------------------------------
+export const javaCallConfig = {
+    language: SupportedLanguages.Java,
+    extractLanguageCallSite: parseJavaMethodReference,
+    typeAsReceiverHeuristic: true,
+};
+export const kotlinCallConfig = {
+    language: SupportedLanguages.Kotlin,
+    typeAsReceiverHeuristic: true,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const phpCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/php.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const phpCallConfig = {
+    language: SupportedLanguages.PHP,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const pythonCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/python.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const pythonCallConfig = {
+    language: SupportedLanguages.Python,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const rubyCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/ruby.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const rubyCallConfig = {
+    language: SupportedLanguages.Ruby,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const rustCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/rust.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const rustCallConfig = {
+    language: SupportedLanguages.Rust,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const swiftCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/swift.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const swiftCallConfig = {
+    language: SupportedLanguages.Swift,
+};

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

@@ -0,0 +1,3 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const typescriptCallConfig: CallExtractionConfig;
+export declare const javascriptCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,8 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/typescript-javascript.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const typescriptCallConfig = {
+    language: SupportedLanguages.TypeScript,
+};
+export const javascriptCallConfig = {
+    language: SupportedLanguages.JavaScript,
+};

package/dist/core/ingestion/call-extractors/generic.d.ts

@@ -0,0 +1,5 @@
+import type { CallExtractor, CallExtractionConfig } from '../call-types.js';
+/**
+ * Create a CallExtractor from a declarative config.
+ */
+export declare function createCallExtractor(config: CallExtractionConfig): CallExtractor;

package/dist/core/ingestion/call-extractors/generic.js

@@ -0,0 +1,59 @@
+// gitnexus/src/core/ingestion/call-extractors/generic.ts
+import { inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, countCallArguments, } from '../utils/call-analysis.js';
+/**
+ * Create a CallExtractor from a declarative config.
+ */
+export function createCallExtractor(config) {
+    return {
+        language: config.language,
+        extract(callNode, callNameNode) {
+            // ── Path 1: Language-specific call site ──────────────────────────
+            // Non-standard call shapes (e.g. Java `::` method references) are
+            // handled entirely by the config hook.  When it returns a result,
+            // the generic path is skipped — no argCount, no mixed chain.
+            //
+            // Note: `extractLanguageCallSite` is called on every `extract()`
+            // invocation — both `extract(callNode, undefined)` (parse-worker
+            // Path 1) and `extract(callNode, callNameNode)` (Path 2).
+            // Language hooks must therefore be idempotent and cheap (e.g. a
+            // single node-type check).
+            if (config.extractLanguageCallSite) {
+                const seed = config.extractLanguageCallSite(callNode);
+                if (seed) {
+                    return {
+                        ...seed,
+                        ...(config.typeAsReceiverHeuristic ? { typeAsReceiverHeuristic: true } : {}),
+                    };
+                }
+            }
+            // ── Path 2: Generic extraction via @call.name ────────────────────
+            if (!callNameNode)
+                return null;
+            const calledName = callNameNode.text;
+            const callForm = inferCallForm(callNode, callNameNode);
+            let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
+            let receiverMixedChain;
+            // When the receiver is a complex expression (call chain, field chain,
+            // or mixed), extractReceiverName returns undefined.  Walk the receiver
+            // node to build a unified mixed chain for deferred resolution.
+            if (callForm === 'member' && receiverName === undefined) {
+                const receiverNode = extractReceiverNode(callNameNode);
+                if (receiverNode) {
+                    const extracted = extractMixedChain(receiverNode);
+                    if (extracted && extracted.chain.length > 0) {
+                        receiverMixedChain = extracted.chain;
+                        receiverName = extracted.baseReceiverName;
+                    }
+                }
+            }
+            return {
+                calledName,
+                ...(callForm !== undefined ? { callForm } : {}),
+                ...(receiverName !== undefined ? { receiverName } : {}),
+                argCount: countCallArguments(callNode),
+                ...(receiverMixedChain !== undefined ? { receiverMixedChain } : {}),
+                ...(config.typeAsReceiverHeuristic ? { typeAsReceiverHeuristic: true } : {}),
+            };
+        },
+    };
+}

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

@@ -15,7 +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
@@ -733,52 +732,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/language-provider.d.ts

@@ -11,6 +11,7 @@
 import type { SupportedLanguages, MroStrategy } from '../../_shared/index.js';
 import type { LanguageTypeConfig } from './type-extractors/types.js';
 import type { CallRouter } from './call-routing.js';
+import type { CallExtractor } from './call-types.js';
 import type { ClassExtractor } from './class-types.js';
 import type { ExportChecker } from './export-detection.js';
 import type { FieldExtractor } from './field-extractor.js';
@@ -119,6 +120,12 @@ interface LanguageProviderConfig {
     /** MRO strategy for multiple inheritance resolution.
      *  Default: 'first-wins'. */
     readonly mroStrategy?: MroStrategy;
+    /** Call extractor for extracting call site information (calledName, callForm,
+     *  receiverName, argCount, mixed chains) from @call / @call.name captures.
+     *  Produced by createCallExtractor() with a per-language CallExtractionConfig.
+     *  Default: undefined — if unset, no calls are extracted for this language.
+     *  All tree-sitter providers MUST supply this. */
+    readonly callExtractor?: CallExtractor;
     /** Field extractor for extracting field/property definitions from class/struct
      *  declarations. Produces FieldInfo[] with name, type, visibility, static,
      *  readonly metadata. Default: undefined (no field extraction). */

package/dist/core/ingestion/languages/c-cpp.js

@@ -30,6 +30,8 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { cConfig as cFieldConfig, cppConfig as cppFieldConfig, } from '../field-extractors/configs/c-cpp.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { cMethodConfig, cppMethodConfig } from '../method-extractors/configs/c-cpp.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { cCallConfig, cppCallConfig } from '../call-extractors/configs/c-cpp.js';
 const C_BUILT_INS = new Set([
     'printf',
     'fprintf',
@@ -288,6 +290,7 @@ export const cProvider = defineLanguage({
     exportChecker: cCppExportChecker,
     importResolver: resolveCImport,
     importSemantics: 'wildcard-transitive',
+    callExtractor: createCallExtractor(cCallConfig),
     fieldExtractor: createFieldExtractor(cFieldConfig),
     methodExtractor: createMethodExtractor({
         ...cMethodConfig,
@@ -306,6 +309,7 @@ export const cppProvider = defineLanguage({
     importResolver: resolveCppImport,
     importSemantics: 'wildcard-transitive',
     mroStrategy: 'leftmost-base',
+    callExtractor: createCallExtractor(cppCallConfig),
     fieldExtractor: createFieldExtractor(cppFieldConfig),
     methodExtractor: createMethodExtractor({
         ...cppMethodConfig,

package/dist/core/ingestion/languages/csharp.js

@@ -14,6 +14,8 @@ import { csharpExportChecker } from '../export-detection.js';
 import { resolveCSharpImport } from '../import-resolvers/csharp.js';
 import { extractCSharpNamedBindings } from '../named-bindings/csharp.js';
 import { CSHARP_QUERIES } from '../tree-sitter-queries.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { csharpCallConfig } from '../call-extractors/configs/csharp.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { csharpConfig as csharpFieldConfig } from '../field-extractors/configs/csharp.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
@@ -122,6 +124,7 @@ export const csharpProvider = defineLanguage({
     namedBindingExtractor: extractCSharpNamedBindings,
     interfaceNamePattern: /^I[A-Z]/,
     mroStrategy: 'implements-split',
+    callExtractor: createCallExtractor(csharpCallConfig),
     fieldExtractor: createFieldExtractor(csharpFieldConfig),
     methodExtractor: createMethodExtractor(csharpMethodConfig),
     classExtractor: createClassExtractor(csharpClassConfig),

package/dist/core/ingestion/languages/dart.js

@@ -22,6 +22,8 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { dartConfig as dartFieldConfig } from '../field-extractors/configs/dart.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { dartMethodConfig } from '../method-extractors/configs/dart.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { dartCallConfig } from '../call-extractors/configs/dart.js';
 /**
  * Resolve the enclosing function from a `function_body` node by looking at its
  * previous sibling.  In Dart's tree-sitter grammar, function_signature and
@@ -85,6 +87,7 @@ export const dartProvider = defineLanguage({
     exportChecker: dartExportChecker,
     importResolver: resolveDartImport,
     importSemantics: 'wildcard-leaf',
+    callExtractor: createCallExtractor(dartCallConfig),
     fieldExtractor: createFieldExtractor(dartFieldConfig),
     methodExtractor: createMethodExtractor(dartMethodConfig),
     classExtractor: createClassExtractor(dartClassConfig),

package/dist/core/ingestion/languages/go.js

@@ -20,6 +20,8 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { goConfig as goFieldConfig } from '../field-extractors/configs/go.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { goMethodConfig } from '../method-extractors/configs/go.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { goCallConfig } from '../call-extractors/configs/go.js';
 export const goProvider = defineLanguage({
     id: SupportedLanguages.Go,
     extensions: ['.go'],
@@ -28,6 +30,7 @@ export const goProvider = defineLanguage({
     exportChecker: goExportChecker,
     importResolver: resolveGoImport,
     importSemantics: 'wildcard-leaf',
+    callExtractor: createCallExtractor(goCallConfig),
     fieldExtractor: createFieldExtractor(goFieldConfig),
     methodExtractor: createMethodExtractor(goMethodConfig),
     classExtractor: createClassExtractor(goClassConfig),

package/dist/core/ingestion/languages/java.js

@@ -15,6 +15,8 @@ import { javaExportChecker } from '../export-detection.js';
 import { resolveJavaImport } from '../import-resolvers/jvm.js';
 import { extractJavaNamedBindings } from '../named-bindings/java.js';
 import { JAVA_QUERIES } from '../tree-sitter-queries.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { javaCallConfig } from '../call-extractors/configs/jvm.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { javaConfig } from '../field-extractors/configs/jvm.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
@@ -29,6 +31,7 @@ export const javaProvider = defineLanguage({
     namedBindingExtractor: extractJavaNamedBindings,
     interfaceNamePattern: /^I[A-Z]/,
     mroStrategy: 'implements-split',
+    callExtractor: createCallExtractor(javaCallConfig),
     fieldExtractor: createFieldExtractor(javaConfig),
     methodExtractor: createMethodExtractor(javaMethodConfig),
     classExtractor: createClassExtractor(javaClassConfig),

package/dist/core/ingestion/languages/kotlin.js

@@ -16,6 +16,8 @@ import { resolveKotlinImport } from '../import-resolvers/jvm.js';
 import { extractKotlinNamedBindings } from '../named-bindings/kotlin.js';
 import { appendKotlinWildcard } from '../import-resolvers/jvm.js';
 import { KOTLIN_QUERIES } from '../tree-sitter-queries.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { kotlinCallConfig } from '../call-extractors/configs/jvm.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { kotlinConfig } from '../field-extractors/configs/jvm.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
@@ -100,6 +102,7 @@ export const kotlinProvider = defineLanguage({
     namedBindingExtractor: extractKotlinNamedBindings,
     importPathPreprocessor: appendKotlinWildcard,
     mroStrategy: 'implements-split',
+    callExtractor: createCallExtractor(kotlinCallConfig),
     fieldExtractor: createFieldExtractor(kotlinConfig),
     methodExtractor: createMethodExtractor(kotlinMethodConfig),
     classExtractor: createClassExtractor(kotlinClassConfig),

package/dist/core/ingestion/languages/php.js

@@ -19,6 +19,8 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { phpConfig as phpFieldConfig } from '../field-extractors/configs/php.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { phpMethodConfig } from '../method-extractors/configs/php.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { phpCallConfig } from '../call-extractors/configs/php.js';
 const BUILT_INS = new Set([
     'echo',
     'isset',
@@ -222,6 +224,7 @@ export const phpProvider = defineLanguage({
     exportChecker: phpExportChecker,
     importResolver: resolvePhpImport,
     namedBindingExtractor: extractPhpNamedBindings,
+    callExtractor: createCallExtractor(phpCallConfig),
     fieldExtractor: createFieldExtractor(phpFieldConfig),
     methodExtractor: createMethodExtractor(phpMethodConfig),
     classExtractor: createClassExtractor(phpClassConfig),

package/dist/core/ingestion/languages/python.js

@@ -22,6 +22,8 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { pythonConfig as pythonFieldConfig } from '../field-extractors/configs/python.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { pythonMethodConfig } from '../method-extractors/configs/python.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { pythonCallConfig } from '../call-extractors/configs/python.js';
 const BUILT_INS = new Set([
     'print',
     'len',
@@ -61,6 +63,7 @@ export const pythonProvider = defineLanguage({
     namedBindingExtractor: extractPythonNamedBindings,
     importSemantics: 'namespace',
     mroStrategy: 'c3',
+    callExtractor: createCallExtractor(pythonCallConfig),
     fieldExtractor: createFieldExtractor(pythonFieldConfig),
     methodExtractor: createMethodExtractor(pythonMethodConfig),
     classExtractor: createClassExtractor(pythonClassConfig),

package/dist/core/ingestion/languages/ruby.js

@@ -19,6 +19,8 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { rubyConfig as rubyFieldConfig } from '../field-extractors/configs/ruby.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { rubyMethodConfig } from '../method-extractors/configs/ruby.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { rubyCallConfig } from '../call-extractors/configs/ruby.js';
 /** Ruby method/singleton_method: extract name from 'name' field, label as Method. */
 const rubyExtractFunctionName = (node) => {
     if (node.type !== 'method' && node.type !== 'singleton_method')
@@ -101,6 +103,7 @@ export const rubyProvider = defineLanguage({
     importResolver: resolveRubyImport,
     callRouter: routeRubyCall,
     importSemantics: 'wildcard-leaf',
+    callExtractor: createCallExtractor(rubyCallConfig),
     resolveEnclosingOwner(node) {
         // Ruby singleton_class (class << self) should resolve to the enclosing
         // class or module for owner/container resolution (HAS_METHOD edges, class IDs).

package/dist/core/ingestion/languages/rust.js

@@ -22,6 +22,8 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { rustConfig as rustFieldConfig } from '../field-extractors/configs/rust.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { rustMethodConfig } from '../method-extractors/configs/rust.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { rustCallConfig } from '../call-extractors/configs/rust.js';
 /** Rust impl_item: find the function_item child and extract its name as a Method. */
 const rustExtractFunctionName = (node) => {
     if (node.type !== 'impl_item')
@@ -113,6 +115,7 @@ export const rustProvider = defineLanguage({
     importResolver: resolveRustImport,
     namedBindingExtractor: extractRustNamedBindings,
     mroStrategy: 'qualified-syntax',
+    callExtractor: createCallExtractor(rustCallConfig),
     fieldExtractor: createFieldExtractor(rustFieldConfig),
     methodExtractor: createMethodExtractor({
         ...rustMethodConfig,

package/dist/core/ingestion/languages/swift.js

@@ -21,6 +21,8 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { swiftConfig as swiftFieldConfig } from '../field-extractors/configs/swift.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { swiftMethodConfig } from '../method-extractors/configs/swift.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { swiftCallConfig } from '../call-extractors/configs/swift.js';
 /**
  * Group Swift files by SPM target for implicit module visibility.
  * If SwiftPackageConfig is available, use target -> directory mappings.
@@ -224,6 +226,7 @@ export const swiftProvider = defineLanguage({
     importResolver: resolveSwiftImport,
     importSemantics: 'wildcard-leaf',
     heritageDefaultEdge: 'IMPLEMENTS',
+    callExtractor: createCallExtractor(swiftCallConfig),
     fieldExtractor: createFieldExtractor(swiftFieldConfig),
     methodExtractor: createMethodExtractor({
         ...swiftMethodConfig,

package/dist/core/ingestion/languages/typescript.js

@@ -20,6 +20,8 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { javascriptConfig } from '../field-extractors/configs/typescript-javascript.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { typescriptMethodConfig, javascriptMethodConfig, } from '../method-extractors/configs/typescript-javascript.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { typescriptCallConfig, javascriptCallConfig, } from '../call-extractors/configs/typescript-javascript.js';
 /**
  * TypeScript/JavaScript: arrow_function and function_expression get their name
  * from the parent variable_declarator (e.g. `const foo = () => {}`).
@@ -146,6 +148,7 @@ export const typescriptProvider = defineLanguage({
     exportChecker: tsExportChecker,
     importResolver: resolveTypescriptImport,
     namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(typescriptCallConfig),
     fieldExtractor: typescriptFieldExtractor,
     methodExtractor: createMethodExtractor({
         ...typescriptMethodConfig,
@@ -162,6 +165,7 @@ export const javascriptProvider = defineLanguage({
     exportChecker: tsExportChecker,
     importResolver: resolveJavascriptImport,
     namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(javascriptCallConfig),
     fieldExtractor: createFieldExtractor(javascriptConfig),
     methodExtractor: createMethodExtractor({
         ...javascriptMethodConfig,

package/dist/core/ingestion/languages/vue.js

@@ -21,6 +21,8 @@ import { extractTsNamedBindings } from '../named-bindings/typescript.js';
 import { TYPESCRIPT_QUERIES } from '../tree-sitter-queries.js';
 import { typescriptFieldExtractor } from '../field-extractors/typescript.js';
 import { BUILT_INS as TS_BUILT_INS } from './typescript.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { typescriptCallConfig } from '../call-extractors/configs/typescript-javascript.js';
 const VUE_SPECIFIC_BUILT_INS = [
     'ref',
     'reactive',
@@ -62,6 +64,7 @@ export const vueProvider = defineLanguage({
     exportChecker: tsExportChecker,
     importResolver: resolveVueImport,
     namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(typescriptCallConfig),
     fieldExtractor: typescriptFieldExtractor,
     classExtractor: vueClassExtractor,
     builtInNames: VUE_BUILT_INS,

package/dist/core/ingestion/workers/parse-worker.js

@@ -36,8 +36,7 @@ try {
 catch { }
 import { getLanguageFromFilename } from '../../../_shared/index.js';
 import { FUNCTION_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCaptures, findDescendant, extractStringContent, genericFuncName, inferFunctionLabel, CLASS_CONTAINER_TYPES, } from '../utils/ast-helpers.js';
-import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, extractCallArgTypes, } from '../utils/call-analysis.js';
-import { extractParsedCallSite } from '../call-sites/extract-language-call-site.js';
+import { extractCallArgTypes } from '../utils/call-analysis.js';
 import { buildTypeEnv } from '../type-env.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
 import { generateId } from '../../../lib/utils.js';
@@ -1248,98 +1247,125 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             }
             // Extract call sites
             if (captureMap['call']) {
-                const callNode0 = captureMap['call'];
-                const languageSeed = extractParsedCallSite(language, callNode0);
-                if (languageSeed) {
-                    if (!provider.isBuiltInName(languageSeed.calledName)) {
-                        const sourceId = findEnclosingFunctionId(callNode0, file.path, provider) ||
-                            generateId('File', file.path);
-                        const receiverName = languageSeed.callForm === 'member' ? languageSeed.receiverName : undefined;
-                        let receiverTypeName = receiverName
-                            ? typeEnv.lookup(receiverName, callNode0)
-                            : undefined;
-                        // Type-as-receiver (e.g. Java `User::getName`): no TypeEnv binding for the class name
-                        if (receiverName !== undefined &&
-                            receiverTypeName === undefined &&
-                            languageSeed.callForm === 'member' &&
-                            (language === SupportedLanguages.Java ||
-                                language === SupportedLanguages.CSharp ||
-                                language === SupportedLanguages.Kotlin)) {
-                            const c0 = receiverName.charCodeAt(0);
-                            if (c0 >= 65 && c0 <= 90)
-                                receiverTypeName = receiverName;
-                        }
-                        result.calls.push({
-                            filePath: file.path,
-                            calledName: languageSeed.calledName,
-                            sourceId,
-                            callForm: languageSeed.callForm,
-                            ...(receiverName !== undefined ? { receiverName } : {}),
-                            ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
-                        });
-                    }
-                    continue;
-                }
+                const callNode = captureMap['call'];
                 const callNameNode = captureMap['call.name'];
-                if (callNameNode) {
-                    const calledName = callNameNode.text;
-                    // Dispatch: route language-specific calls (heritage, properties, imports)
-                    const routed = callRouter?.(calledName, captureMap['call']);
-                    if (routed) {
-                        if (routed.kind === 'skip')
-                            continue;
-                        if (routed.kind === 'import') {
-                            result.imports.push({
+                const callExtractor = provider.callExtractor;
+                if (callExtractor) {
+                    // ── Path 1: Language-specific call site (bypasses routing) ────
+                    // Try language-specific extraction (e.g. Java `::` method references)
+                    // without callNameNode.  If successful, skip routing and the generic
+                    // path entirely.
+                    const langCallSite = callExtractor.extract(callNode, undefined);
+                    if (langCallSite) {
+                        if (!provider.isBuiltInName(langCallSite.calledName)) {
+                            const sourceId = findEnclosingFunctionId(callNode, file.path, provider) ||
+                                generateId('File', file.path);
+                            const receiverName = langCallSite.callForm === 'member' ? langCallSite.receiverName : undefined;
+                            let receiverTypeName = receiverName
+                                ? typeEnv.lookup(receiverName, callNode)
+                                : undefined;
+                            // Type-as-receiver heuristic (e.g. Java `User::getName`)
+                            if (langCallSite.typeAsReceiverHeuristic &&
+                                receiverName !== undefined &&
+                                receiverTypeName === undefined &&
+                                langCallSite.callForm === 'member') {
+                                const c0 = receiverName.charCodeAt(0);
+                                if (c0 >= 65 && c0 <= 90)
+                                    receiverTypeName = receiverName;
+                            }
+                            result.calls.push({
                                 filePath: file.path,
-                                rawImportPath: routed.importPath,
-                                language,
+                                calledName: langCallSite.calledName,
+                                sourceId,
+                                callForm: langCallSite.callForm,
+                                ...(receiverName !== undefined ? { receiverName } : {}),
+                                ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
                             });
-                            continue;
                         }
-                        if (routed.kind === 'heritage') {
-                            for (const item of routed.items) {
-                                result.heritage.push({
+                        continue;
+                    }
+                    // ── Path 2: Generic extraction via @call.name ────────────────
+                    if (callNameNode) {
+                        const calledName = callNameNode.text;
+                        // Dispatch: route language-specific calls (heritage, properties, imports)
+                        const routed = callRouter?.(calledName, captureMap['call']);
+                        if (routed) {
+                            if (routed.kind === 'skip')
+                                continue;
+                            if (routed.kind === 'import') {
+                                result.imports.push({
                                     filePath: file.path,
-                                    className: item.enclosingClass,
-                                    parentName: item.mixinName,
-                                    kind: item.heritageKind,
+                                    rawImportPath: routed.importPath,
+                                    language,
                                 });
+                                continue;
                             }
-                            continue;
-                        }
-                        if (routed.kind === 'properties') {
-                            const propEnclosingInfo = cachedFindEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner);
-                            const propEnclosingClassId = propEnclosingInfo?.classId ?? null;
-                            // Enrich routed properties with FieldExtractor metadata
-                            let routedFieldMap;
-                            if (provider.fieldExtractor && typeEnv) {
-                                const classNode = findEnclosingClassNode(captureMap['call']);
-                                if (classNode) {
-                                    routedFieldMap = getFieldInfo(classNode, provider, {
-                                        typeEnv,
-                                        symbolTable: NOOP_SYMBOL_TABLE,
+                            if (routed.kind === 'heritage') {
+                                for (const item of routed.items) {
+                                    result.heritage.push({
                                         filePath: file.path,
-                                        language,
+                                        className: item.enclosingClass,
+                                        parentName: item.mixinName,
+                                        kind: item.heritageKind,
                                     });
                                 }
+                                continue;
                             }
-                            for (const item of routed.items) {
-                                const routedFieldInfo = routedFieldMap?.get(item.propName);
-                                const propQualifiedName = propEnclosingInfo
-                                    ? `${propEnclosingInfo.className}.${item.propName}`
-                                    : item.propName;
-                                const nodeId = generateId('Property', `${file.path}:${propQualifiedName}`);
-                                result.nodes.push({
-                                    id: nodeId,
-                                    label: 'Property',
-                                    properties: {
-                                        name: item.propName,
+                            if (routed.kind === 'properties') {
+                                const propEnclosingInfo = cachedFindEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner);
+                                const propEnclosingClassId = propEnclosingInfo?.classId ?? null;
+                                // Enrich routed properties with FieldExtractor metadata
+                                let routedFieldMap;
+                                if (provider.fieldExtractor && typeEnv) {
+                                    const classNode = findEnclosingClassNode(captureMap['call']);
+                                    if (classNode) {
+                                        routedFieldMap = getFieldInfo(classNode, provider, {
+                                            typeEnv,
+                                            symbolTable: NOOP_SYMBOL_TABLE,
+                                            filePath: file.path,
+                                            language,
+                                        });
+                                    }
+                                }
+                                for (const item of routed.items) {
+                                    const routedFieldInfo = routedFieldMap?.get(item.propName);
+                                    const propQualifiedName = propEnclosingInfo
+                                        ? `${propEnclosingInfo.className}.${item.propName}`
+                                        : item.propName;
+                                    const nodeId = generateId('Property', `${file.path}:${propQualifiedName}`);
+                                    result.nodes.push({
+                                        id: nodeId,
+                                        label: 'Property',
+                                        properties: {
+                                            name: item.propName,
+                                            filePath: file.path,
+                                            startLine: item.startLine,
+                                            endLine: item.endLine,
+                                            language,
+                                            isExported: true,
+                                            description: item.accessorType,
+                                            ...(item.declaredType
+                                                ? { declaredType: item.declaredType }
+                                                : routedFieldInfo?.type
+                                                    ? { declaredType: routedFieldInfo.type }
+                                                    : {}),
+                                            ...(routedFieldInfo?.visibility !== undefined
+                                                ? { visibility: routedFieldInfo.visibility }
+                                                : {}),
+                                            ...(routedFieldInfo?.isStatic !== undefined
+                                                ? { isStatic: routedFieldInfo.isStatic }
+                                                : {}),
+                                            ...(routedFieldInfo?.isReadonly !== undefined
+                                                ? { isReadonly: routedFieldInfo.isReadonly }
+                                                : {}),
+                                        },
+                                    });
+                                    result.symbols.push({
                                         filePath: file.path,
-                                        startLine: item.startLine,
-                                        endLine: item.endLine,
-                                        language,
-                                        isExported: true,
-                                        description: item.accessorType,
+                                        name: item.propName,
+                                        nodeId,
+                                        type: 'Property',
+                                        ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
                                         ...(item.declaredType
                                             ? { declaredType: item.declaredType }
                                             : routedFieldInfo?.type
@@ -1354,101 +1380,71 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                         ...(routedFieldInfo?.isReadonly !== undefined
                                             ? { isReadonly: routedFieldInfo.isReadonly }
                                             : {}),
-                                    },
-                                });
-                                result.symbols.push({
-                                    filePath: file.path,
-                                    name: item.propName,
-                                    nodeId,
-                                    type: 'Property',
-                                    ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
-                                    ...(item.declaredType
-                                        ? { declaredType: item.declaredType }
-                                        : routedFieldInfo?.type
-                                            ? { declaredType: routedFieldInfo.type }
-                                            : {}),
-                                    ...(routedFieldInfo?.visibility !== undefined
-                                        ? { visibility: routedFieldInfo.visibility }
-                                        : {}),
-                                    ...(routedFieldInfo?.isStatic !== undefined
-                                        ? { isStatic: routedFieldInfo.isStatic }
-                                        : {}),
-                                    ...(routedFieldInfo?.isReadonly !== undefined
-                                        ? { isReadonly: routedFieldInfo.isReadonly }
-                                        : {}),
-                                });
-                                const fileId = generateId('File', file.path);
-                                const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
-                                result.relationships.push({
-                                    id: relId,
-                                    sourceId: fileId,
-                                    targetId: nodeId,
-                                    type: 'DEFINES',
-                                    confidence: 1.0,
-                                    reason: '',
-                                });
-                                if (propEnclosingClassId) {
+                                    });
+                                    const fileId = generateId('File', file.path);
+                                    const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
                                     result.relationships.push({
-                                        id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
-                                        sourceId: propEnclosingClassId,
+                                        id: relId,
+                                        sourceId: fileId,
                                         targetId: nodeId,
-                                        type: 'HAS_PROPERTY',
+                                        type: 'DEFINES',
                                         confidence: 1.0,
                                         reason: '',
                                     });
+                                    if (propEnclosingClassId) {
+                                        result.relationships.push({
+                                            id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
+                                            sourceId: propEnclosingClassId,
+                                            targetId: nodeId,
+                                            type: 'HAS_PROPERTY',
+                                            confidence: 1.0,
+                                            reason: '',
+                                        });
+                                    }
                                 }
+                                continue;
                             }
-                            continue;
+                            // kind === 'call' — fall through to normal call processing below
                         }
-                        // kind === 'call' — fall through to normal call processing below
-                    }
-                    if (!provider.isBuiltInName(calledName)) {
-                        const callNode = captureMap['call'];
-                        const sourceId = findEnclosingFunctionId(callNode, file.path, provider) ||
-                            generateId('File', file.path);
-                        const callForm = inferCallForm(callNode, callNameNode);
-                        let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
-                        let receiverTypeName = receiverName
-                            ? typeEnv.lookup(receiverName, callNode)
-                            : undefined;
-                        let receiverMixedChain;
-                        // When the receiver is a complex expression (call chain, field chain, or mixed),
-                        // extractReceiverName returns undefined. Walk the receiver node to build a unified
-                        // mixed chain for deferred resolution in processCallsFromExtracted.
-                        if (callForm === 'member' && receiverName === undefined && !receiverTypeName) {
-                            const receiverNode = extractReceiverNode(callNameNode);
-                            if (receiverNode) {
-                                const extracted = extractMixedChain(receiverNode);
-                                if (extracted && extracted.chain.length > 0) {
-                                    receiverMixedChain = extracted.chain;
-                                    receiverName = extracted.baseReceiverName;
-                                    // Try the type environment immediately for the base receiver
-                                    // (covers explicitly-typed locals and annotated parameters).
-                                    if (receiverName) {
-                                        receiverTypeName = typeEnv.lookup(receiverName, callNode);
-                                    }
+                        if (!provider.isBuiltInName(calledName)) {
+                            const callSite = callExtractor.extract(callNode, callNameNode);
+                            if (callSite) {
+                                const sourceId = findEnclosingFunctionId(callNode, file.path, provider) ||
+                                    generateId('File', file.path);
+                                let receiverTypeName = callSite.receiverName
+                                    ? typeEnv.lookup(callSite.receiverName, callNode)
+                                    : undefined;
+                                // Type-as-receiver heuristic
+                                if (callSite.typeAsReceiverHeuristic &&
+                                    callSite.receiverName !== undefined &&
+                                    receiverTypeName === undefined &&
+                                    callSite.callForm === 'member') {
+                                    const c0 = callSite.receiverName.charCodeAt(0);
+                                    if (c0 >= 65 && c0 <= 90)
+                                        receiverTypeName = callSite.receiverName;
                                 }
+                                const inferLiteralType = provider.typeConfig?.inferLiteralType;
+                                // Skip when no arg list / zero args: nothing to infer for overload typing
+                                const argTypes = inferLiteralType && callSite.argCount !== undefined && callSite.argCount > 0
+                                    ? extractCallArgTypes(callNode, inferLiteralType, (varName, cn) => typeEnv.lookup(varName, cn))
+                                    : undefined;
+                                result.calls.push({
+                                    filePath: file.path,
+                                    calledName: callSite.calledName,
+                                    sourceId,
+                                    ...(callSite.argCount !== undefined ? { argCount: callSite.argCount } : {}),
+                                    ...(callSite.callForm !== undefined ? { callForm: callSite.callForm } : {}),
+                                    ...(callSite.receiverName !== undefined
+                                        ? { receiverName: callSite.receiverName }
+                                        : {}),
+                                    ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
+                                    ...(callSite.receiverMixedChain !== undefined
+                                        ? { receiverMixedChain: callSite.receiverMixedChain }
+                                        : {}),
+                                    ...(argTypes !== undefined ? { argTypes } : {}),
+                                });
                             }
                         }
-                        const inferLiteralType = provider.typeConfig?.inferLiteralType;
-                        const argCountForOverloadHints = countCallArguments(callNode);
-                        // Skip when no arg list / zero args: nothing to infer for overload typing; saves AST walks + payload size.
-                        const argTypes = inferLiteralType &&
-                            argCountForOverloadHints !== undefined &&
-                            argCountForOverloadHints > 0
-                            ? extractCallArgTypes(callNode, inferLiteralType, (varName, cn) => typeEnv.lookup(varName, cn))
-                            : undefined;
-                        result.calls.push({
-                            filePath: file.path,
-                            calledName,
-                            sourceId,
-                            argCount: countCallArguments(callNode),
-                            ...(callForm !== undefined ? { callForm } : {}),
-                            ...(receiverName !== undefined ? { receiverName } : {}),
-                            ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
-                            ...(receiverMixedChain !== undefined ? { receiverMixedChain } : {}),
-                            ...(argTypes !== undefined ? { argTypes } : {}),
-                        });
                     }
                 }
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.2-rc.14",
+  "version": "1.6.2-rc.15",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",

package/dist/core/ingestion/call-sites/extract-language-call-site.d.ts

@@ -1,10 +0,0 @@
-/** Non-generic @call shapes → { calledName, callForm, receiverName? } (used from call-processor / parse-worker). */
-import { SupportedLanguages } from '../../../config/supported-languages.js';
-import type { SyntaxNode } from '../utils/ast-helpers.js';
-export type ParsedCallSite = {
-    calledName: string;
-    callForm: 'free' | 'member' | 'constructor';
-    receiverName?: string;
-};
-/** Non-null → seed replaces @call.name; null → use @call.name + inferCallForm / extractReceiverName. */
-export declare function extractParsedCallSite(language: SupportedLanguages, callNode: SyntaxNode): ParsedCallSite | null;

package/dist/core/ingestion/call-sites/extract-language-call-site.js

@@ -1,22 +0,0 @@
-/** Non-generic @call shapes → { calledName, callForm, receiverName? } (used from call-processor / parse-worker). */
-import { SupportedLanguages } from '../../../config/supported-languages.js';
-import { parseJavaMethodReference } from './java.js';
-/** Non-null → seed replaces @call.name; null → use @call.name + inferCallForm / extractReceiverName. */
-export function extractParsedCallSite(language, callNode) {
-    switch (language) {
-        case SupportedLanguages.Java:
-            if (callNode.type === 'method_reference') {
-                const parsed = parseJavaMethodReference(callNode);
-                if (!parsed)
-                    return null;
-                return {
-                    calledName: parsed.calledName,
-                    callForm: parsed.callForm,
-                    ...(parsed.receiverName !== undefined ? { receiverName: parsed.receiverName } : {}),
-                };
-            }
-            return null;
-        default:
-            return null;
-    }
-}

package/dist/core/ingestion/call-sites/java.d.ts

@@ -1,9 +0,0 @@
-/** Java `method_reference` (`::`) nodes (tree-sitter-java). `super::` still lacks TypeEnv receiver typing. */
-import type { SyntaxNode } from '../utils/ast-helpers.js';
-export type ParsedJavaMethodReference = {
-    calledName: string;
-    callForm: 'member' | 'constructor';
-    receiverName?: string;
-};
-/** Parse `expr::method`, `Type::new`, `this::m`, `super::m`. */
-export declare const parseJavaMethodReference: (callNode: SyntaxNode) => ParsedJavaMethodReference | null;

package/dist/core/ingestion/call-sites/java.js

@@ -1,30 +0,0 @@
-/** Java `method_reference` (`::`) nodes (tree-sitter-java). `super::` still lacks TypeEnv receiver typing. */
-/** Parse `expr::method`, `Type::new`, `this::m`, `super::m`. */
-export const parseJavaMethodReference = (callNode) => {
-    if (callNode.type !== 'method_reference')
-        return null;
-    const recv = callNode.namedChild(0);
-    if (!recv)
-        return null;
-    for (const c of callNode.children) {
-        if (c.type === 'new') {
-            if (recv.type !== 'identifier')
-                return null;
-            return { calledName: recv.text, callForm: 'constructor' };
-        }
-    }
-    const rhs = callNode.child(callNode.childCount - 1);
-    if (!rhs || rhs.type !== 'identifier')
-        return null;
-    const methodName = rhs.text;
-    if (recv.type === 'identifier') {
-        return { calledName: methodName, callForm: 'member', receiverName: recv.text };
-    }
-    if (recv.type === 'this') {
-        return { calledName: methodName, callForm: 'member', receiverName: 'this' };
-    }
-    if (recv.type === 'super') {
-        return { calledName: methodName, callForm: 'member', receiverName: 'super' };
-    }
-    return null;
-};