gitnexus 1.4.9 → 1.5.0

package/dist/core/ingestion/type-extractors/swift.js

@@ -1,13 +1,11 @@
 import { findChild } from '../utils/ast-helpers.js';
-import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, extractElementTypeFromString, resolveIterableElementType } from './shared.js';
+import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, extractElementTypeFromString, resolveIterableElementType, } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'property_declaration',
     'if_statement',
     'guard_statement',
 ]);
-const FOR_LOOP_NODE_TYPES = new Set([
-    'for_statement',
-]);
+const FOR_LOOP_NODE_TYPES = new Set(['for_statement']);
 /**
  * Unwrap Swift `await_expression` and `try_expression` nodes to find the inner
  * call_expression or other value node. `try` nodes contain a `try_operator` child
@@ -26,10 +24,8 @@ function unwrapSwiftExpression(node) {
 /** Swift: let x: Foo = ... */
 const extractDeclaration = (node, env) => {
     // Swift property_declaration has pattern and type_annotation
-    const pattern = node.childForFieldName('pattern')
-        ?? findChild(node, 'pattern');
-    const typeAnnotation = node.childForFieldName('type')
-        ?? findChild(node, 'type_annotation');
+    const pattern = node.childForFieldName('pattern') ?? findChild(node, 'pattern');
+    const typeAnnotation = node.childForFieldName('type') ?? findChild(node, 'type_annotation');
     if (!pattern || !typeAnnotation)
         return;
     const varName = extractVarName(pattern) ?? pattern.text;
@@ -42,8 +38,7 @@ const extractParameter = (node, env) => {
     let nameNode = null;
     let typeNode = null;
     if (node.type === 'parameter') {
-        nameNode = node.childForFieldName('name')
-            ?? node.childForFieldName('internal_name');
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('internal_name');
         typeNode = node.childForFieldName('type');
     }
     else {
@@ -235,7 +230,12 @@ function extractIfGuardBinding(node, scopeEnv) {
             if (receiver?.type === 'simple_identifier' && suffix?.type === 'navigation_suffix') {
                 const method = suffix.lastNamedChild;
                 if (method?.type === 'simple_identifier') {
-                    return { kind: 'methodCallResult', lhs: varName, receiver: receiver.text, method: method.text };
+                    return {
+                        kind: 'methodCallResult',
+                        lhs: varName,
+                        receiver: receiver.text,
+                        method: method.text,
+                    };
                 }
             }
         }
@@ -281,7 +281,9 @@ const extractPendingAssignment = (node, scopeEnv) => {
         const child = node.namedChild(i);
         if (!child)
             continue;
-        if (child.type === 'pattern' || child.type === 'value_binding_pattern' || child.type === 'type_annotation')
+        if (child.type === 'pattern' ||
+            child.type === 'value_binding_pattern' ||
+            child.type === 'type_annotation')
             continue;
         valueNode = child;
         break;
@@ -358,7 +360,8 @@ const extractForLoopBinding = (node, { scopeEnv, declarationTypeNodes, scope, re
         }
         // After we found the loop var, the next expression-like node is the iterable
         if (loopVarName && !iterableNode) {
-            if (child.type === 'simple_identifier' || child.type === 'call_expression' ||
+            if (child.type === 'simple_identifier' ||
+                child.type === 'call_expression' ||
                 child.type === 'navigation_expression') {
                 iterableNode = child;
                 break;

package/dist/core/ingestion/type-extractors/typescript.js

@@ -1,4 +1,4 @@
-import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, unwrapAwait, extractCalleeName, extractElementTypeFromString, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition } from './shared.js';
+import { extractSimpleTypeName, extractVarName, hasTypeAnnotation, unwrapAwait, extractCalleeName, extractElementTypeFromString, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, } from './shared.js';
 const DECLARATION_NODE_TYPES = new Set([
     'lexical_declaration',
     'variable_declaration',
@@ -12,7 +12,10 @@ const normalizeJsDocType = (raw) => {
     if (type.startsWith('?') || type.startsWith('!'))
         type = type.slice(1);
     // Strip union with null/undefined/void: User|null → User
-    const parts = type.split('|').map(p => p.trim()).filter(p => p !== 'null' && p !== 'undefined' && p !== 'void');
+    const parts = type
+        .split('|')
+        .map((p) => p.trim())
+        .filter((p) => p !== 'null' && p !== 'undefined' && p !== 'void');
     if (parts.length !== 1)
         return undefined; // ambiguous union
     type = parts[0];
@@ -218,13 +221,15 @@ const extractReturnType = (node) => {
     }
     return undefined;
 };
-const FOR_LOOP_NODE_TYPES = new Set([
-    'for_in_statement',
-]);
+const FOR_LOOP_NODE_TYPES = new Set(['for_in_statement']);
 /** TS function/method node types that carry a parameters list. */
 const TS_FUNCTION_NODE_TYPES = new Set([
-    'function_declaration', 'function_expression', 'arrow_function',
-    'method_definition', 'generator_function', 'generator_function_declaration',
+    'function_declaration',
+    'function_expression',
+    'arrow_function',
+    'method_definition',
+    'generator_function',
+    'generator_function_declaration',
 ]);
 /**
  * Extract element type from a TypeScript type annotation AST node.
@@ -306,8 +311,7 @@ const findTsIterableElementType = (iterableName, startNode, pos = 'last') => {
     while (current) {
         if (TS_FUNCTION_NODE_TYPES.has(current.type)) {
             // Search function parameters
-            const paramsNode = current.childForFieldName('parameters')
-                ?? current.childForFieldName('formal_parameters');
+            const paramsNode = current.childForFieldName('parameters') ?? current.childForFieldName('formal_parameters');
             if (paramsNode) {
                 for (let i = 0; i < paramsNode.namedChildCount; i++) {
                     const param = paramsNode.namedChild(i);
@@ -497,7 +501,8 @@ const extractPendingAssignment = (node, scopeEnv) => {
         if (valueNode.type === 'member_expression') {
             const obj = valueNode.childForFieldName('object');
             const prop = valueNode.childForFieldName('property');
-            if (obj && prop?.type === 'property_identifier' &&
+            if (obj &&
+                prop?.type === 'property_identifier' &&
                 (obj.type === 'identifier' || obj.type === 'this')) {
                 return { kind: 'fieldAccess', lhs, receiver: obj.text, field: prop.text };
             }
@@ -518,7 +523,8 @@ const extractPendingAssignment = (node, scopeEnv) => {
         if (funcNode.type === 'member_expression') {
             const obj = funcNode.childForFieldName('object');
             const prop = funcNode.childForFieldName('property');
-            if (obj && prop?.type === 'property_identifier' &&
+            if (obj &&
+                prop?.type === 'property_identifier' &&
                 (obj.type === 'identifier' || obj.type === 'this')) {
                 return { kind: 'methodCallResult', lhs, receiver: obj.text, method: prop.text };
             }
@@ -550,8 +556,10 @@ const findIfConsequenceBlock = (binaryExpr) => {
             return undefined;
         }
         // Stop climbing at function/block boundaries — don't cross scope
-        if (current.type === 'function_declaration' || current.type === 'function_expression'
-            || current.type === 'arrow_function' || current.type === 'method_definition')
+        if (current.type === 'function_declaration' ||
+            current.type === 'function_expression' ||
+            current.type === 'arrow_function' ||
+            current.type === 'method_definition')
             return undefined;
         current = current.parent;
     }
@@ -565,7 +573,7 @@ const extractPatternBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
     if (node.type !== 'binary_expression')
         return undefined;
     // Check for instanceof first (existing behavior)
-    const instanceofOp = node.children.find(c => !c.isNamed && c.text === 'instanceof');
+    const instanceofOp = node.children.find((c) => !c.isNamed && c.text === 'instanceof');
     if (instanceofOp) {
         const left = node.namedChild(0);
         const right = node.namedChild(1);
@@ -574,7 +582,7 @@ const extractPatternBinding = (node, scopeEnv, declarationTypeNodes, scope) => {
         return { varName: left.text, typeName: right.text };
     }
     // Null-check narrowing: x !== null, x != null, x !== undefined, x != undefined
-    const op = node.children.find(c => !c.isNamed && (c.text === '!==' || c.text === '!='));
+    const op = node.children.find((c) => !c.isNamed && (c.text === '!==' || c.text === '!='));
     if (!op)
         return undefined;
     const left = node.namedChild(0);

package/dist/core/ingestion/utils/ast-helpers.d.ts

@@ -1,5 +1,5 @@
 import type Parser from 'tree-sitter';
-import type { NodeLabel } from '../../graph/types.js';
+import type { NodeLabel } from 'gitnexus-shared';
 import type { LanguageProvider } from '../language-provider.js';
 /** Tree-sitter AST node. Re-exported for use across ingestion modules. */
 export type SyntaxNode = Parser.SyntaxNode;
@@ -9,7 +9,7 @@ export type SyntaxNode = Parser.SyntaxNode;
  */
 export declare const DEFINITION_CAPTURE_KEYS: readonly ["definition.function", "definition.class", "definition.interface", "definition.method", "definition.struct", "definition.enum", "definition.namespace", "definition.module", "definition.trait", "definition.impl", "definition.type", "definition.const", "definition.static", "definition.typedef", "definition.macro", "definition.union", "definition.property", "definition.record", "definition.delegate", "definition.annotation", "definition.constructor", "definition.template"];
 /** Extract the definition node from a tree-sitter query capture map. */
-export declare const getDefinitionNodeFromCaptures: (captureMap: Record<string, any>) => SyntaxNode | null;
+export declare const getDefinitionNodeFromCaptures: (captureMap: Record<string, SyntaxNode>) => SyntaxNode | null;
 /**
  * Node types that represent function/method definitions across languages.
  * Used to find the enclosing function for a call site.
@@ -27,7 +27,7 @@ export declare const CONTAINER_TYPE_TO_LABEL: Record<string, string>;
  *  Kotlin grammar uses function_declaration for both top-level functions and class methods.
  *  Returns true when the captured definition node has a class_body ancestor. */
 export declare function isKotlinClassMethod(captureNode: {
-    parent?: any;
+    parent?: SyntaxNode | null;
 } | null | undefined): boolean;
 /**
  * Determine the graph node label from a tree-sitter capture map.
@@ -35,15 +35,15 @@ export declare function isKotlinClassMethod(captureNode: {
  * (e.g. C/C++ duplicate skipping, Kotlin Method promotion).
  * Returns null if the capture should be skipped (import, call, C/C++ duplicate, missing name).
  */
-export declare function getLabelFromCaptures(captureMap: Record<string, any>, provider: LanguageProvider): NodeLabel | null;
+export declare function getLabelFromCaptures(captureMap: Record<string, SyntaxNode>, provider: LanguageProvider): NodeLabel | null;
 /** Walk up AST to find enclosing class/struct/interface/impl, return its generateId or null.
  *  For Go method_declaration nodes, extracts receiver type (e.g. `func (u *User) Save()` → User struct). */
-export declare const findEnclosingClassId: (node: any, filePath: string) => string | null;
+export declare const findEnclosingClassId: (node: SyntaxNode, filePath: string) => string | null;
 /**
  * Find a child of `childType` within a sibling node of `siblingType`.
  * Used for Kotlin AST traversal where visibility_modifier lives inside a modifiers sibling.
  */
-export declare const findSiblingChild: (parent: any, siblingType: string, childType: string) => any | null;
+export declare const findSiblingChild: (parent: SyntaxNode, siblingType: string, childType: string) => SyntaxNode | null;
 /**
  * Extract function name and label from a function_definition or similar AST node.
  * Handles C/C++ qualified_identifier (ClassName::MethodName) and other language patterns.
@@ -72,9 +72,9 @@ export declare const CALL_ARGUMENT_LIST_TYPES: Set<string>;
  */
 export declare const extractMethodSignature: (node: SyntaxNode | null | undefined) => MethodSignature;
 /** Walk an AST node depth-first, returning the first descendant with the given type. */
-export declare function findDescendant(node: any, type: string): any;
+export declare function findDescendant(node: SyntaxNode, type: string): SyntaxNode | null;
 /** Extract the text content from a string or encapsed_string AST node. */
-export declare function extractStringContent(node: any): string | null;
+export declare function extractStringContent(node: SyntaxNode | null | undefined): string | null;
 /** Check if a C/C++ function_definition is inside a class or struct body.
  *  Used by the C/C++ labelOverride to skip duplicate function captures
  *  that are already covered by definition.method queries. */

package/dist/core/ingestion/utils/ast-helpers.js

@@ -55,6 +55,8 @@ export const FUNCTION_NODE_TYPES = new Set([
     // Java
     'method_declaration',
     'constructor_declaration',
+    'compact_constructor_declaration',
+    'annotation_type_element_declaration',
     // C/C++
     // 'function_definition' already included above
     // Go
@@ -91,10 +93,17 @@ export const FUNCTION_DECLARATION_TYPES = new Set([
 ]);
 /** AST node types that represent a class-like container (for HAS_METHOD edge extraction) */
 export const CLASS_CONTAINER_TYPES = new Set([
-    'class_declaration', 'abstract_class_declaration',
-    'interface_declaration', 'struct_declaration', 'record_declaration',
-    'class_specifier', 'struct_specifier',
-    'impl_item', 'trait_item', 'struct_item', 'enum_item',
+    'class_declaration',
+    'abstract_class_declaration',
+    'interface_declaration',
+    'struct_declaration',
+    'record_declaration',
+    'class_specifier',
+    'struct_specifier',
+    'impl_item',
+    'trait_item',
+    'struct_item',
+    'enum_item',
     'class_definition',
     'trait_declaration',
     'protocol_declaration',
@@ -244,15 +253,20 @@ export const findEnclosingClassId = (node, filePath) => {
                 const children = current.children ?? [];
                 const forIdx = children.findIndex((c) => c.text === 'for');
                 if (forIdx !== -1) {
-                    const nameNode = children.slice(forIdx + 1).find((c) => c.type === 'type_identifier' || c.type === 'identifier');
+                    const nameNode = children
+                        .slice(forIdx + 1)
+                        .find((c) => c.type === 'type_identifier' || c.type === 'identifier');
                     if (nameNode) {
                         return generateId('Impl', `${filePath}:${nameNode.text}`);
                     }
                 }
                 // Fall through: plain `impl Struct {}` — use first type_identifier below
             }
-            const nameNode = current.childForFieldName?.('name')
-                ?? current.children?.find((c) => c.type === 'type_identifier' || c.type === 'identifier' || c.type === 'name' || c.type === 'constant');
+            const nameNode = current.childForFieldName?.('name') ??
+                current.children?.find((c) => c.type === 'type_identifier' ||
+                    c.type === 'identifier' ||
+                    c.type === 'name' ||
+                    c.type === 'constant');
             if (nameNode) {
                 const label = CONTAINER_TYPE_TO_LABEL[current.type] || 'Class';
                 return generateId(label, `${filePath}:${nameNode.text}`);
@@ -306,12 +320,15 @@ export const extractFunctionName = (node) => {
                 }
             }
         }
-        while (declarator && (declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator')) {
+        while (declarator &&
+            (declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator')) {
             let nextDeclarator = declarator.childForFieldName?.('declarator');
             if (!nextDeclarator) {
                 for (let i = 0; i < declarator.childCount; i++) {
                     const c = declarator.child(i);
-                    if (c?.type === 'function_declarator' || c?.type === 'pointer_declarator' || c?.type === 'reference_declarator') {
+                    if (c?.type === 'function_declarator' ||
+                        c?.type === 'pointer_declarator' ||
+                        c?.type === 'reference_declarator') {
                         nextDeclarator = c;
                         break;
                     }
@@ -324,8 +341,10 @@ export const extractFunctionName = (node) => {
             if (!innerDeclarator) {
                 for (let i = 0; i < declarator.childCount; i++) {
                     const c = declarator.child(i);
-                    if (c?.type === 'qualified_identifier' || c?.type === 'identifier'
-                        || c?.type === 'field_identifier' || c?.type === 'parenthesized_declarator') {
+                    if (c?.type === 'qualified_identifier' ||
+                        c?.type === 'identifier' ||
+                        c?.type === 'field_identifier' ||
+                        c?.type === 'parenthesized_declarator') {
                         innerDeclarator = c;
                         break;
                     }
@@ -347,7 +366,8 @@ export const extractFunctionName = (node) => {
                     label = 'Method';
                 }
             }
-            else if (innerDeclarator?.type === 'identifier' || innerDeclarator?.type === 'field_identifier') {
+            else if (innerDeclarator?.type === 'identifier' ||
+                innerDeclarator?.type === 'field_identifier') {
                 // field_identifier is used for method names inside C++ class bodies
                 funcName = innerDeclarator.text;
                 if (innerDeclarator.type === 'field_identifier')
@@ -389,7 +409,9 @@ export const extractFunctionName = (node) => {
             if (!nameNode) {
                 for (let i = 0; i < node.childCount; i++) {
                     const c = node.child(i);
-                    if (c?.type === 'identifier' || c?.type === 'property_identifier' || c?.type === 'simple_identifier') {
+                    if (c?.type === 'identifier' ||
+                        c?.type === 'property_identifier' ||
+                        c?.type === 'simple_identifier') {
                         nameNode = c;
                         break;
                     }
@@ -522,11 +544,7 @@ export const extractFunctionName = (node) => {
     return { funcName, label };
 };
 /** Argument list node types shared between extractMethodSignature and countCallArguments. */
-export const CALL_ARGUMENT_LIST_TYPES = new Set([
-    'arguments',
-    'argument_list',
-    'value_arguments',
-]);
+export const CALL_ARGUMENT_LIST_TYPES = new Set(['arguments', 'argument_list', 'value_arguments']);
 /**
  * Extract parameter count and return type text from an AST method/function node.
  * Works across languages by looking for common AST patterns.
@@ -538,10 +556,19 @@ export const extractMethodSignature = (node) => {
     let isVariadic = false;
     const paramTypes = [];
     if (!node)
-        return { parameterCount, requiredParameterCount: undefined, parameterTypes: undefined, returnType };
+        return {
+            parameterCount,
+            requiredParameterCount: undefined,
+            parameterTypes: undefined,
+            returnType,
+        };
     const paramListTypes = new Set([
-        'formal_parameters', 'parameters', 'parameter_list',
-        'function_parameters', 'method_parameters', 'function_value_parameters',
+        'formal_parameters',
+        'parameters',
+        'parameter_list',
+        'function_parameters',
+        'method_parameters',
+        'function_value_parameters',
         'formal_parameter_list', // Dart
     ]);
     // Node types that indicate variadic/rest parameters
@@ -592,14 +619,16 @@ export const extractMethodSignature = (node) => {
         }
         return null;
     };
-    const parameterList = (paramListTypes.has(node.type) ? node // node itself IS the parameter list (e.g. C# primary constructors)
-        : node.childForFieldName?.('parameters')
-            ?? findParameterList(node));
+    const parameterList = paramListTypes.has(node.type)
+        ? node // node itself IS the parameter list (e.g. C# primary constructors)
+        : (node.childForFieldName?.('parameters') ?? findParameterList(node));
     if (parameterList && paramListTypes.has(parameterList.type)) {
         for (const param of parameterList.namedChildren) {
             if (param.type === 'comment')
                 continue;
-            if (param.text === 'self' || param.text === '&self' || param.text === '&mut self' ||
+            if (param.text === 'self' ||
+                param.text === '&self' ||
+                param.text === '&mut self' ||
                 param.type === 'self_parameter') {
                 continue;
             }
@@ -607,9 +636,11 @@ export const extractMethodSignature = (node) => {
             // function_value_parameters, so they appear as named children (e.g.
             // string_literal, integer_literal, boolean_literal, call_expression).
             // Skip any named child that isn't a parameter-like or modifier node.
-            if (param.type.endsWith('_literal') || param.type === 'call_expression'
-                || param.type === 'navigation_expression' || param.type === 'prefix_expression'
-                || param.type === 'parenthesized_expression') {
+            if (param.type.endsWith('_literal') ||
+                param.type === 'call_expression' ||
+                param.type === 'navigation_expression' ||
+                param.type === 'prefix_expression' ||
+                param.type === 'parenthesized_expression') {
                 continue;
             }
             // Check for variadic parameter types
@@ -650,8 +681,10 @@ export const extractMethodSignature = (node) => {
                 // Kotlin: parameter → [simple_identifier, user_type|nullable_type]
                 let found = false;
                 for (const child of param.namedChildren) {
-                    if (child.type === 'user_type' || child.type === 'nullable_type'
-                        || child.type === 'type_identifier' || child.type === 'predefined_type') {
+                    if (child.type === 'user_type' ||
+                        child.type === 'nullable_type' ||
+                        child.type === 'type_identifier' ||
+                        child.type === 'predefined_type') {
                         const typeName = extractSimpleTypeName(child);
                         paramTypes.push(typeName ?? 'unknown');
                         found = true;
@@ -763,11 +796,15 @@ export const extractMethodSignature = (node) => {
         parameterCount = undefined;
     // Only include parameterTypes when at least one type was successfully extracted.
     // Use undefined (not []) to avoid empty array allocations for untyped parameters.
-    const hasTypes = paramTypes.length > 0 && paramTypes.some(t => t !== 'unknown');
+    const hasTypes = paramTypes.length > 0 && paramTypes.some((t) => t !== 'unknown');
     // Only set requiredParameterCount when it differs from total — saves memory on the common case.
-    const requiredParameterCount = (!isVariadic && requiredCount < (parameterCount ?? 0))
-        ? requiredCount : undefined;
-    return { parameterCount, requiredParameterCount, parameterTypes: hasTypes ? paramTypes : undefined, returnType };
+    const requiredParameterCount = !isVariadic && requiredCount < (parameterCount ?? 0) ? requiredCount : undefined;
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes: hasTypes ? paramTypes : undefined,
+        returnType,
+    };
 };
 // ============================================================================
 // Generic AST traversal helpers (shared by parse-worker + php-helpers)
@@ -776,7 +813,7 @@ export const extractMethodSignature = (node) => {
 export function findDescendant(node, type) {
     if (node.type === type)
         return node;
-    for (const child of (node.children ?? [])) {
+    for (const child of node.children ?? []) {
         const found = findDescendant(child, type);
         if (found)
             return found;

package/dist/core/ingestion/utils/call-analysis.d.ts

@@ -70,4 +70,6 @@ export declare function extractMixedChain(receiverNode: SyntaxNode): {
     chain: MixedChainStep[];
     baseReceiverName: string | undefined;
 } | undefined;
+/** Arg types per call position (literals + optional TypeEnv for ids); undefined if unusable */
+export declare const extractCallArgTypes: (callNode: SyntaxNode, inferLiteralType: (node: SyntaxNode) => string | undefined, typeEnvLookup?: (varName: string, callNode: SyntaxNode) => string | undefined) => (string | undefined)[] | undefined;
 export {};