gitnexus 1.6.2-rc.13 → 1.6.2-rc.15

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.13",
+  "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;
-};