gitnexus 1.4.10 → 1.5.0

package/dist/core/ingestion/utils/call-analysis.js

@@ -21,8 +21,8 @@ export const countCallArguments = (callNode) => {
     if (!callNode)
         return undefined;
     // Direct field or direct child (most languages)
-    let argsNode = callNode.childForFieldName('arguments')
-        ?? callNode.children.find((child) => CALL_ARGUMENT_LIST_TYPES.has(child.type));
+    let argsNode = callNode.childForFieldName('arguments') ??
+        callNode.children.find((child) => CALL_ARGUMENT_LIST_TYPES.has(child.type));
     // Kotlin/Swift: call_expression → call_suffix → value_arguments
     // Search one level deeper for languages that wrap arguments in a suffix node
     if (!argsNode) {
@@ -100,7 +100,8 @@ export const inferCallForm = (callNode, nameNode) => {
         return 'member';
     }
     // 3. PHP: the callNode itself distinguishes member vs free calls
-    if (callNode.type === 'member_call_expression' || callNode.type === 'nullsafe_member_call_expression') {
+    if (callNode.type === 'member_call_expression' ||
+        callNode.type === 'nullsafe_member_call_expression') {
         return 'member';
     }
     if (callNode.type === 'scoped_call_expression') {
@@ -153,17 +154,20 @@ export const extractReceiverName = (nameNode) => {
     const callNode = parent.parent ?? parent;
     let receiver = null;
     // Try standard field names used across grammars
-    receiver = parent.childForFieldName('object') // TS/JS member_expression, Python attribute, PHP, Java
-        ?? parent.childForFieldName('value') // Rust field_expression
-        ?? parent.childForFieldName('operand') // Go selector_expression
-        ?? parent.childForFieldName('expression') // C# member_access_expression
-        ?? parent.childForFieldName('argument'); // C++ field_expression
+    receiver =
+        parent.childForFieldName('object') ?? // TS/JS member_expression, Python attribute, PHP, Java
+            parent.childForFieldName('value') ?? // Rust field_expression
+            parent.childForFieldName('operand') ?? // Go selector_expression
+            parent.childForFieldName('expression') ?? // C# member_access_expression
+            parent.childForFieldName('argument'); // C++ field_expression
     // Java method_invocation: 'object' field is on the callNode, not on nameNode's parent
     if (!receiver && callNode.type === 'method_invocation') {
         receiver = callNode.childForFieldName('object');
     }
     // PHP: member_call_expression has 'object' on the call node
-    if (!receiver && (callNode.type === 'member_call_expression' || callNode.type === 'nullsafe_member_call_expression')) {
+    if (!receiver &&
+        (callNode.type === 'member_call_expression' ||
+            callNode.type === 'nullsafe_member_call_expression')) {
         receiver = callNode.childForFieldName('object');
     }
     // Ruby: call node has 'receiver' field
@@ -172,7 +176,8 @@ export const extractReceiverName = (nameNode) => {
     }
     // PHP scoped_call_expression (parent::method(), self::method()):
     // nameNode's direct parent IS the scoped_call_expression (name is a direct child)
-    if (!receiver && (parent.type === 'scoped_call_expression' || callNode.type === 'scoped_call_expression')) {
+    if (!receiver &&
+        (parent.type === 'scoped_call_expression' || callNode.type === 'scoped_call_expression')) {
         const scopedCall = parent.type === 'scoped_call_expression' ? parent : callNode;
         receiver = scopedCall.childForFieldName('scope');
         // relative_scope wraps 'parent'/'self'/'static' — unwrap to get the keyword
@@ -238,21 +243,25 @@ export const extractReceiverNode = (nameNode) => {
         return undefined;
     const callNode = parent.parent ?? parent;
     let receiver = null;
-    receiver = parent.childForFieldName('object')
-        ?? parent.childForFieldName('value')
-        ?? parent.childForFieldName('operand')
-        ?? parent.childForFieldName('expression')
-        ?? parent.childForFieldName('argument');
+    receiver =
+        parent.childForFieldName('object') ??
+            parent.childForFieldName('value') ??
+            parent.childForFieldName('operand') ??
+            parent.childForFieldName('expression') ??
+            parent.childForFieldName('argument');
     if (!receiver && callNode.type === 'method_invocation') {
         receiver = callNode.childForFieldName('object');
     }
-    if (!receiver && (callNode.type === 'member_call_expression' || callNode.type === 'nullsafe_member_call_expression')) {
+    if (!receiver &&
+        (callNode.type === 'member_call_expression' ||
+            callNode.type === 'nullsafe_member_call_expression')) {
         receiver = callNode.childForFieldName('object');
     }
     if (!receiver && parent.type === 'call') {
         receiver = parent.childForFieldName('receiver');
     }
-    if (!receiver && (parent.type === 'scoped_call_expression' || callNode.type === 'scoped_call_expression')) {
+    if (!receiver &&
+        (parent.type === 'scoped_call_expression' || callNode.type === 'scoped_call_expression')) {
         const scopedCall = parent.type === 'scoped_call_expression' ? parent : callNode;
         receiver = scopedCall.childForFieldName('scope');
         if (receiver?.type === 'relative_scope') {
@@ -312,9 +321,9 @@ export function extractCallChain(receiverCallNode) {
     let current = receiverCallNode;
     while (CALL_EXPRESSION_TYPES.has(current.type) && chain.length < MAX_CHAIN_DEPTH) {
         // Extract the method name from this call node.
-        const funcNode = current.childForFieldName?.('function')
-            ?? current.childForFieldName?.('name')
-            ?? current.childForFieldName?.('method'); // Ruby `call` node
+        const funcNode = current.childForFieldName?.('function') ??
+            current.childForFieldName?.('name') ??
+            current.childForFieldName?.('method'); // Ruby `call` node
         let methodName;
         let innerReceiver = null;
         if (funcNode) {
@@ -345,17 +354,20 @@ export function extractCallChain(receiverCallNode) {
         chain.unshift(methodName); // build chain outermost-last
         // Walk into the receiver of this call to continue the chain
         if (!innerReceiver && funcNode) {
-            innerReceiver = funcNode.childForFieldName?.('object')
-                ?? funcNode.childForFieldName?.('value')
-                ?? funcNode.childForFieldName?.('operand')
-                ?? funcNode.childForFieldName?.('expression');
+            innerReceiver =
+                funcNode.childForFieldName?.('object') ??
+                    funcNode.childForFieldName?.('value') ??
+                    funcNode.childForFieldName?.('operand') ??
+                    funcNode.childForFieldName?.('expression');
         }
         // Java method_invocation: object field is on the call node
         if (!innerReceiver && current.type === 'method_invocation') {
             innerReceiver = current.childForFieldName?.('object');
         }
         // PHP member_call_expression
-        if (!innerReceiver && (current.type === 'member_call_expression' || current.type === 'nullsafe_member_call_expression')) {
+        if (!innerReceiver &&
+            (current.type === 'member_call_expression' ||
+                current.type === 'nullsafe_member_call_expression')) {
             innerReceiver = current.childForFieldName?.('object');
         }
         // Ruby `call` node: receiver field is on the call node itself
@@ -396,9 +408,9 @@ export function extractMixedChain(receiverNode) {
     while (chain.length < MAX_CHAIN_DEPTH) {
         if (CALL_EXPRESSION_TYPES.has(current.type)) {
             // ── Call expression: extract method name + inner receiver ────────────
-            const funcNode = current.childForFieldName?.('function')
-                ?? current.childForFieldName?.('name')
-                ?? current.childForFieldName?.('method');
+            const funcNode = current.childForFieldName?.('function') ??
+                current.childForFieldName?.('name') ??
+                current.childForFieldName?.('method');
             let methodName;
             let innerReceiver = null;
             if (funcNode) {
@@ -425,17 +437,20 @@ export function extractMixedChain(receiverNode) {
                 break;
             chain.unshift({ kind: 'call', name: methodName });
             if (!innerReceiver && funcNode) {
-                innerReceiver = funcNode.childForFieldName?.('object')
-                    ?? funcNode.childForFieldName?.('value')
-                    ?? funcNode.childForFieldName?.('operand')
-                    ?? funcNode.childForFieldName?.('argument') // C/C++ field_expression
-                    ?? funcNode.childForFieldName?.('expression')
-                    ?? null;
+                innerReceiver =
+                    funcNode.childForFieldName?.('object') ??
+                        funcNode.childForFieldName?.('value') ??
+                        funcNode.childForFieldName?.('operand') ??
+                        funcNode.childForFieldName?.('argument') ?? // C/C++ field_expression
+                        funcNode.childForFieldName?.('expression') ??
+                        null;
             }
             if (!innerReceiver && current.type === 'method_invocation') {
                 innerReceiver = current.childForFieldName?.('object') ?? null;
             }
-            if (!innerReceiver && (current.type === 'member_call_expression' || current.type === 'nullsafe_member_call_expression')) {
+            if (!innerReceiver &&
+                (current.type === 'member_call_expression' ||
+                    current.type === 'nullsafe_member_call_expression')) {
                 innerReceiver = current.childForFieldName?.('object') ?? null;
             }
             if (!innerReceiver && current.type === 'call') {
@@ -443,7 +458,8 @@ export function extractMixedChain(receiverNode) {
             }
             if (!innerReceiver)
                 break;
-            if (CALL_EXPRESSION_TYPES.has(innerReceiver.type) || FIELD_ACCESS_NODE_TYPES.has(innerReceiver.type)) {
+            if (CALL_EXPRESSION_TYPES.has(innerReceiver.type) ||
+                FIELD_ACCESS_NODE_TYPES.has(innerReceiver.type)) {
                 current = innerReceiver;
             }
             else {
@@ -474,22 +490,24 @@ export function extractMixedChain(receiverNode) {
                 propertyName = current.childForFieldName?.('attribute')?.text;
             }
             else {
-                innerObject = current.childForFieldName?.('object')
-                    ?? current.childForFieldName?.('value')
-                    ?? current.childForFieldName?.('operand')
-                    ?? current.childForFieldName?.('argument') // C/C++ field_expression
-                    ?? current.childForFieldName?.('expression')
-                    ?? null;
-                propertyName = (current.childForFieldName?.('property')
-                    ?? current.childForFieldName?.('field')
-                    ?? current.childForFieldName?.('name'))?.text;
+                innerObject =
+                    current.childForFieldName?.('object') ??
+                        current.childForFieldName?.('value') ??
+                        current.childForFieldName?.('operand') ??
+                        current.childForFieldName?.('argument') ?? // C/C++ field_expression
+                        current.childForFieldName?.('expression') ??
+                        null;
+                propertyName = (current.childForFieldName?.('property') ??
+                    current.childForFieldName?.('field') ??
+                    current.childForFieldName?.('name'))?.text;
             }
             if (!propertyName)
                 break;
             chain.unshift({ kind: 'field', name: propertyName });
             if (!innerObject)
                 break;
-            if (CALL_EXPRESSION_TYPES.has(innerObject.type) || FIELD_ACCESS_NODE_TYPES.has(innerObject.type)) {
+            if (CALL_EXPRESSION_TYPES.has(innerObject.type) ||
+                FIELD_ACCESS_NODE_TYPES.has(innerObject.type)) {
                 current = innerObject;
             }
             else {
@@ -518,10 +536,39 @@ export function extractMixedChain(receiverNode) {
         }
         else {
             // Simple identifier — this is the base receiver
-            return chain.length > 0
-                ? { chain, baseReceiverName: current.text || undefined }
-                : undefined;
+            return chain.length > 0 ? { chain, baseReceiverName: current.text || undefined } : undefined;
         }
     }
     return chain.length > 0 ? { chain, baseReceiverName: undefined } : undefined;
 }
+/** Arg types per call position (literals + optional TypeEnv for ids); undefined if unusable */
+export const extractCallArgTypes = (callNode, inferLiteralType, typeEnvLookup) => {
+    let argList = callNode.childForFieldName?.('arguments') ??
+        callNode.children.find((c) => c.type === 'arguments' || c.type === 'argument_list' || c.type === 'value_arguments');
+    if (!argList) {
+        const callSuffix = callNode.children.find((c) => c.type === 'call_suffix');
+        if (callSuffix) {
+            argList = callSuffix.children.find((c) => c.type === 'value_arguments');
+        }
+    }
+    if (!argList)
+        return undefined;
+    const argTypes = [];
+    for (const arg of argList.namedChildren) {
+        if (arg.type === 'comment')
+            continue;
+        const valueNode = arg.childForFieldName?.('value') ??
+            arg.childForFieldName?.('expression') ??
+            (arg.type === 'argument' || arg.type === 'value_argument'
+                ? (arg.firstNamedChild ?? arg)
+                : arg);
+        let inferred = inferLiteralType(valueNode);
+        if (!inferred && typeEnvLookup && valueNode.type === 'identifier') {
+            inferred = typeEnvLookup(valueNode.text, callNode);
+        }
+        argTypes.push(inferred);
+    }
+    if (argTypes.every((t) => t === undefined))
+        return undefined;
+    return argTypes;
+};

package/dist/core/ingestion/utils/event-loop.js

@@ -2,4 +2,4 @@
  * Yield control to the event loop so spinners/progress can render.
  * Call periodically in hot loops to prevent UI freezes.
  */
-export const yieldToEventLoop = () => new Promise(resolve => setImmediate(resolve));
+export const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -1,8 +1,8 @@
-import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 import { type MixedChainStep } from '../utils/call-analysis.js';
 import type { ConstructorBinding } from '../type-env.js';
 import type { NamedBinding } from '../named-bindings/types.js';
-import type { NodeLabel } from '../../graph/types.js';
+import type { NodeLabel } from 'gitnexus-shared';
 interface ParsedNode {
     id: string;
     label: string;
@@ -47,6 +47,9 @@ interface ParsedSymbol {
     visibility?: string;
     isStatic?: boolean;
     isReadonly?: boolean;
+    isAbstract?: boolean;
+    isFinal?: boolean;
+    annotations?: string[];
 }
 export interface ExtractedImport {
     filePath: string;
@@ -60,6 +63,7 @@ export interface ExtractedCall {
     calledName: string;
     /** generateId of enclosing function, or generateId('File', filePath) for top-level */
     sourceId: string;
+    /** From call AST; omitted for some seeds (e.g. Java `::`) so arity filter is skipped */
     argCount?: number;
     /** Discriminates free function calls from member/constructor calls */
     callForm?: 'free' | 'member' | 'constructor';
@@ -76,6 +80,7 @@ export interface ExtractedCall {
      * Length is capped at MAX_CHAIN_DEPTH (3).
      */
     receiverMixedChain?: MixedChainStep[];
+    argTypes?: (string | undefined)[];
 }
 export interface ExtractedAssignment {
     filePath: string;