gitnexus 1.3.11 → 1.4.0

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

@@ -0,0 +1,29 @@
+/**
+ * Per-language type extraction configurations.
+ * Assembled here into a dispatch map keyed by SupportedLanguages.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { typeConfig as typescriptConfig } from './typescript.js';
+import { javaTypeConfig, kotlinTypeConfig } from './jvm.js';
+import { typeConfig as csharpConfig } from './csharp.js';
+import { typeConfig as goConfig } from './go.js';
+import { typeConfig as rustConfig } from './rust.js';
+import { typeConfig as pythonConfig } from './python.js';
+import { typeConfig as swiftConfig } from './swift.js';
+import { typeConfig as cCppConfig } from './c-cpp.js';
+import { typeConfig as phpConfig } from './php.js';
+export const typeConfigs = {
+    [SupportedLanguages.JavaScript]: typescriptConfig,
+    [SupportedLanguages.TypeScript]: typescriptConfig,
+    [SupportedLanguages.Java]: javaTypeConfig,
+    [SupportedLanguages.Kotlin]: kotlinTypeConfig,
+    [SupportedLanguages.CSharp]: csharpConfig,
+    [SupportedLanguages.Go]: goConfig,
+    [SupportedLanguages.Rust]: rustConfig,
+    [SupportedLanguages.Python]: pythonConfig,
+    [SupportedLanguages.Swift]: swiftConfig,
+    [SupportedLanguages.C]: cCppConfig,
+    [SupportedLanguages.CPlusPlus]: cCppConfig,
+    [SupportedLanguages.PHP]: phpConfig,
+};
+export { TYPED_PARAMETER_TYPES, extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';

package/dist/core/ingestion/type-extractors/jvm.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageTypeConfig } from './types.js';
+export declare const javaTypeConfig: LanguageTypeConfig;
+export declare const kotlinTypeConfig: LanguageTypeConfig;

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

@@ -0,0 +1,121 @@
+import { extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';
+// ── Java ──────────────────────────────────────────────────────────────────
+const JAVA_DECLARATION_NODE_TYPES = new Set([
+    'local_variable_declaration',
+    'field_declaration',
+]);
+/** Java: Type x = ...; Type x; */
+const extractJavaDeclaration = (node, env) => {
+    const typeNode = node.childForFieldName('type');
+    if (!typeNode)
+        return;
+    const typeName = extractSimpleTypeName(typeNode);
+    if (!typeName)
+        return;
+    // Find variable_declarator children
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type !== 'variable_declarator')
+            continue;
+        const nameNode = child.childForFieldName('name');
+        if (nameNode) {
+            const varName = extractVarName(nameNode);
+            if (varName)
+                env.set(varName, typeName);
+        }
+    }
+};
+/** Java: formal_parameter → type name */
+const extractJavaParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'formal_parameter') {
+        typeNode = node.childForFieldName('type');
+        nameNode = node.childForFieldName('name');
+    }
+    else {
+        // Generic fallback
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+export const javaTypeConfig = {
+    declarationNodeTypes: JAVA_DECLARATION_NODE_TYPES,
+    extractDeclaration: extractJavaDeclaration,
+    extractParameter: extractJavaParameter,
+};
+// ── Kotlin ────────────────────────────────────────────────────────────────
+const KOTLIN_DECLARATION_NODE_TYPES = new Set([
+    'property_declaration',
+    'variable_declaration',
+]);
+/** Kotlin: val x: Foo = ... */
+const extractKotlinDeclaration = (node, env) => {
+    if (node.type === 'property_declaration') {
+        // Kotlin property_declaration: name/type are inside a variable_declaration child
+        const varDecl = findChildByType(node, 'variable_declaration');
+        if (varDecl) {
+            const nameNode = findChildByType(varDecl, 'simple_identifier');
+            const typeNode = findChildByType(varDecl, 'user_type');
+            if (!nameNode || !typeNode)
+                return;
+            const varName = extractVarName(nameNode);
+            const typeName = extractSimpleTypeName(typeNode);
+            if (varName && typeName)
+                env.set(varName, typeName);
+            return;
+        }
+        // Fallback: try direct fields
+        const nameNode = node.childForFieldName('name')
+            ?? findChildByType(node, 'simple_identifier');
+        const typeNode = node.childForFieldName('type')
+            ?? findChildByType(node, 'user_type');
+        if (!nameNode || !typeNode)
+            return;
+        const varName = extractVarName(nameNode);
+        const typeName = extractSimpleTypeName(typeNode);
+        if (varName && typeName)
+            env.set(varName, typeName);
+    }
+    else if (node.type === 'variable_declaration') {
+        // variable_declaration directly inside functions
+        const nameNode = findChildByType(node, 'simple_identifier');
+        const typeNode = findChildByType(node, 'user_type');
+        if (nameNode && typeNode) {
+            const varName = extractVarName(nameNode);
+            const typeName = extractSimpleTypeName(typeNode);
+            if (varName && typeName)
+                env.set(varName, typeName);
+        }
+    }
+};
+/** Kotlin: formal_parameter → type name */
+const extractKotlinParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'formal_parameter') {
+        typeNode = node.childForFieldName('type');
+        nameNode = node.childForFieldName('name');
+    }
+    else {
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+export const kotlinTypeConfig = {
+    declarationNodeTypes: KOTLIN_DECLARATION_NODE_TYPES,
+    extractDeclaration: extractKotlinDeclaration,
+    extractParameter: extractKotlinParameter,
+};

package/dist/core/ingestion/type-extractors/php.d.ts

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

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

@@ -0,0 +1,31 @@
+import { extractSimpleTypeName, extractVarName } from './shared.js';
+// PHP has no local variable type annotations; only params carry types
+const DECLARATION_NODE_TYPES = new Set();
+/** PHP: no typed local variable declarations */
+const extractDeclaration = (_node, _env) => {
+    // PHP has no local variable type annotations
+};
+/** PHP: simple_parameter → type $name */
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'simple_parameter') {
+        typeNode = node.childForFieldName('type');
+        nameNode = node.childForFieldName('name');
+    }
+    else {
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+export const typeConfig = {
+    declarationNodeTypes: DECLARATION_NODE_TYPES,
+    extractDeclaration,
+    extractParameter,
+};

package/dist/core/ingestion/type-extractors/python.d.ts

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

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

@@ -0,0 +1,41 @@
+import { extractSimpleTypeName, extractVarName } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set([
+    'assignment',
+]);
+/** Python: x: Foo = ... (PEP 484 annotations) */
+const extractDeclaration = (node, env) => {
+    // Python annotated assignment: left : type = value
+    // tree-sitter represents this differently based on grammar version
+    const left = node.childForFieldName('left');
+    const typeNode = node.childForFieldName('type');
+    if (!left || !typeNode)
+        return;
+    const varName = extractVarName(left);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+/** Python: parameter with type annotation */
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'parameter') {
+        nameNode = node.childForFieldName('name');
+        typeNode = node.childForFieldName('type');
+    }
+    else {
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+export const typeConfig = {
+    declarationNodeTypes: DECLARATION_NODE_TYPES,
+    extractDeclaration,
+    extractParameter,
+};

package/dist/core/ingestion/type-extractors/rust.d.ts

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

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

@@ -0,0 +1,39 @@
+import { extractSimpleTypeName, extractVarName } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set([
+    'let_declaration',
+]);
+/** Rust: let x: Foo = ... */
+const extractDeclaration = (node, env) => {
+    const pattern = node.childForFieldName('pattern');
+    const typeNode = node.childForFieldName('type');
+    if (!pattern || !typeNode)
+        return;
+    const varName = extractVarName(pattern);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+/** Rust: parameter → pattern: type */
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'parameter') {
+        nameNode = node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    else {
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+export const typeConfig = {
+    declarationNodeTypes: DECLARATION_NODE_TYPES,
+    extractDeclaration,
+    extractParameter,
+};

package/dist/core/ingestion/type-extractors/shared.d.ts

@@ -0,0 +1,17 @@
+import type { SyntaxNode } from '../utils.js';
+/**
+ * Extract the simple type name from a type AST node.
+ * Handles generic types (e.g., List<User> → List), qualified names
+ * (e.g., models.User → User), and nullable types (e.g., User? → User).
+ * Returns undefined for complex types (unions, intersections, function types).
+ */
+export declare const extractSimpleTypeName: (typeNode: SyntaxNode) => string | undefined;
+/**
+ * Extract variable name from a declarator or pattern node.
+ * Returns the simple identifier text, or undefined for destructuring/complex patterns.
+ */
+export declare const extractVarName: (node: SyntaxNode) => string | undefined;
+/** Node types for function/method parameters with type annotations */
+export declare const TYPED_PARAMETER_TYPES: Set<string>;
+/** Find the first named child with the given node type */
+export declare const findChildByType: (node: SyntaxNode, type: string) => SyntaxNode | null;

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

@@ -0,0 +1,97 @@
+/**
+ * Extract the simple type name from a type AST node.
+ * Handles generic types (e.g., List<User> → List), qualified names
+ * (e.g., models.User → User), and nullable types (e.g., User? → User).
+ * Returns undefined for complex types (unions, intersections, function types).
+ */
+export const extractSimpleTypeName = (typeNode) => {
+    // Direct type identifier
+    if (typeNode.type === 'type_identifier' || typeNode.type === 'identifier'
+        || typeNode.type === 'simple_identifier') {
+        return typeNode.text;
+    }
+    // Qualified/scoped names: take the last segment (e.g., models.User → User)
+    if (typeNode.type === 'scoped_identifier' || typeNode.type === 'qualified_identifier'
+        || typeNode.type === 'scoped_type_identifier' || typeNode.type === 'qualified_name'
+        || typeNode.type === 'qualified_type'
+        || typeNode.type === 'member_expression' || typeNode.type === 'attribute') {
+        const last = typeNode.lastNamedChild;
+        if (last && (last.type === 'type_identifier' || last.type === 'identifier'
+            || last.type === 'simple_identifier' || last.type === 'name')) {
+            return last.text;
+        }
+    }
+    // Generic types: extract the base type (e.g., List<User> → List)
+    if (typeNode.type === 'generic_type' || typeNode.type === 'parameterized_type') {
+        const base = typeNode.childForFieldName('name')
+            ?? typeNode.childForFieldName('type')
+            ?? typeNode.firstNamedChild;
+        if (base)
+            return extractSimpleTypeName(base);
+    }
+    // Nullable types (Kotlin User?, C# User?)
+    if (typeNode.type === 'nullable_type') {
+        const inner = typeNode.firstNamedChild;
+        if (inner)
+            return extractSimpleTypeName(inner);
+    }
+    // Type annotations that wrap the actual type (TS/Python: `: Foo`, Kotlin: user_type)
+    if (typeNode.type === 'type_annotation' || typeNode.type === 'type'
+        || typeNode.type === 'user_type') {
+        const inner = typeNode.firstNamedChild;
+        if (inner)
+            return extractSimpleTypeName(inner);
+    }
+    // Pointer/reference types (C++, Rust): User*, &User, &mut User
+    if (typeNode.type === 'pointer_type' || typeNode.type === 'reference_type') {
+        const inner = typeNode.firstNamedChild;
+        if (inner)
+            return extractSimpleTypeName(inner);
+    }
+    // PHP named_type / optional_type
+    if (typeNode.type === 'named_type' || typeNode.type === 'optional_type') {
+        const inner = typeNode.childForFieldName('name') ?? typeNode.firstNamedChild;
+        if (inner)
+            return extractSimpleTypeName(inner);
+    }
+    // Name node (PHP)
+    if (typeNode.type === 'name') {
+        return typeNode.text;
+    }
+    return undefined;
+};
+/**
+ * Extract variable name from a declarator or pattern node.
+ * Returns the simple identifier text, or undefined for destructuring/complex patterns.
+ */
+export const extractVarName = (node) => {
+    if (node.type === 'identifier' || node.type === 'simple_identifier'
+        || node.type === 'variable_name' || node.type === 'name') {
+        return node.text;
+    }
+    // variable_declarator (Java/C#): has a 'name' field
+    if (node.type === 'variable_declarator') {
+        const nameChild = node.childForFieldName('name');
+        if (nameChild)
+            return extractVarName(nameChild);
+    }
+    return undefined;
+};
+/** Node types for function/method parameters with type annotations */
+export const TYPED_PARAMETER_TYPES = new Set([
+    'required_parameter', // TS: (x: Foo)
+    'optional_parameter', // TS: (x?: Foo)
+    'formal_parameter', // Java/Kotlin
+    'parameter', // C#/Rust/Go/Python/Swift
+    'parameter_declaration', // C/C++ void f(Type name)
+    'simple_parameter', // PHP function(Foo $x)
+]);
+/** Find the first named child with the given node type */
+export const findChildByType = (node, type) => {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === type)
+            return child;
+    }
+    return null;
+};

package/dist/core/ingestion/type-extractors/swift.d.ts

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

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

@@ -0,0 +1,43 @@
+import { extractSimpleTypeName, extractVarName, findChildByType } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set([
+    'property_declaration',
+]);
+/** Swift: let x: Foo = ... */
+const extractDeclaration = (node, env) => {
+    // Swift property_declaration has pattern and type_annotation
+    const pattern = node.childForFieldName('pattern')
+        ?? findChildByType(node, 'pattern');
+    const typeAnnotation = node.childForFieldName('type')
+        ?? findChildByType(node, 'type_annotation');
+    if (!pattern || !typeAnnotation)
+        return;
+    const varName = extractVarName(pattern) ?? pattern.text;
+    const typeName = extractSimpleTypeName(typeAnnotation);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+/** Swift: parameter → name: type */
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'parameter') {
+        nameNode = node.childForFieldName('name')
+            ?? node.childForFieldName('internal_name');
+        typeNode = node.childForFieldName('type');
+    }
+    else {
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+export const typeConfig = {
+    declarationNodeTypes: DECLARATION_NODE_TYPES,
+    extractDeclaration,
+    extractParameter,
+};

package/dist/core/ingestion/type-extractors/types.d.ts

@@ -0,0 +1,14 @@
+import type { SyntaxNode } from '../utils.js';
+/** Extracts type bindings from a declaration node into the env map */
+export type TypeBindingExtractor = (node: SyntaxNode, env: Map<string, string>) => void;
+/** Extracts type bindings from a parameter node into the env map */
+export type ParameterExtractor = (node: SyntaxNode, env: Map<string, string>) => void;
+/** Per-language type extraction configuration */
+export interface LanguageTypeConfig {
+    /** Node types that represent typed declarations for this language */
+    declarationNodeTypes: ReadonlySet<string>;
+    /** Extract a (varName → typeName) binding from a declaration node */
+    extractDeclaration: TypeBindingExtractor;
+    /** Extract a (varName → typeName) binding from a parameter node */
+    extractParameter: ParameterExtractor;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/core/ingestion/type-extractors/typescript.d.ts

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

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

@@ -0,0 +1,46 @@
+import { extractSimpleTypeName, extractVarName } from './shared.js';
+const DECLARATION_NODE_TYPES = new Set([
+    'lexical_declaration',
+    'variable_declaration',
+]);
+/** TypeScript: const x: Foo = ..., let x: Foo */
+const extractDeclaration = (node, env) => {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const declarator = node.namedChild(i);
+        if (declarator?.type !== 'variable_declarator')
+            continue;
+        const nameNode = declarator.childForFieldName('name');
+        const typeAnnotation = declarator.childForFieldName('type');
+        if (!nameNode || !typeAnnotation)
+            continue;
+        const varName = extractVarName(nameNode);
+        const typeName = extractSimpleTypeName(typeAnnotation);
+        if (varName && typeName)
+            env.set(varName, typeName);
+    }
+};
+/** TypeScript: required_parameter / optional_parameter → name: type */
+const extractParameter = (node, env) => {
+    let nameNode = null;
+    let typeNode = null;
+    if (node.type === 'required_parameter' || node.type === 'optional_parameter') {
+        nameNode = node.childForFieldName('pattern') ?? node.childForFieldName('name');
+        typeNode = node.childForFieldName('type');
+    }
+    else {
+        // Generic fallback
+        nameNode = node.childForFieldName('name') ?? node.childForFieldName('pattern');
+        typeNode = node.childForFieldName('type');
+    }
+    if (!nameNode || !typeNode)
+        return;
+    const varName = extractVarName(nameNode);
+    const typeName = extractSimpleTypeName(typeNode);
+    if (varName && typeName)
+        env.set(varName, typeName);
+};
+export const typeConfig = {
+    declarationNodeTypes: DECLARATION_NODE_TYPES,
+    extractDeclaration,
+    extractParameter,
+};

package/dist/core/ingestion/utils.d.ts

@@ -1,4 +1,45 @@
+import type Parser from 'tree-sitter';
 import { SupportedLanguages } from '../../config/supported-languages.js';
+/** Tree-sitter AST node. Re-exported for use across ingestion modules. */
+export type SyntaxNode = Parser.SyntaxNode;
+/**
+ * Ordered list of definition capture keys for tree-sitter query matches.
+ * Used to extract the definition node from a capture map.
+ */
+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>) => any | null;
+/**
+ * Node types that represent function/method definitions across languages.
+ * Used to find the enclosing function for a call site.
+ */
+export declare const FUNCTION_NODE_TYPES: Set<string>;
+/**
+ * Node types for standard function declarations that need C/C++ declarator handling.
+ * Used by extractFunctionName to determine how to extract the function name.
+ */
+export declare const FUNCTION_DECLARATION_TYPES: Set<string>;
+/**
+ * Built-in function/method names that should not be tracked as call targets.
+ * Covers JS/TS, Python, Kotlin, C/C++, PHP, Swift standard library functions.
+ */
+export declare const BUILT_IN_NAMES: Set<string>;
+/** Check if a name is a built-in function or common noise that should be filtered out */
+export declare const isBuiltInOrNoise: (name: string) => boolean;
+/** AST node types that represent a class-like container (for HAS_METHOD edge extraction) */
+export declare const CLASS_CONTAINER_TYPES: Set<string>;
+export declare const CONTAINER_TYPE_TO_LABEL: Record<string, string>;
+/** 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;
+/**
+ * Extract function name and label from a function_definition or similar AST node.
+ * Handles C/C++ qualified_identifier (ClassName::MethodName) and other language patterns.
+ */
+export declare const extractFunctionName: (node: any) => {
+    funcName: string | null;
+    label: string;
+};
 /**
  * Yield control to the event loop so spinners/progress can render.
  * Call periodically in hot loops to prevent UI freezes.
@@ -13,3 +54,29 @@ export declare const findSiblingChild: (parent: any, siblingType: string, childT
  * Map file extension to SupportedLanguage enum
  */
 export declare const getLanguageFromFilename: (filename: string) => SupportedLanguages | null;
+export interface MethodSignature {
+    parameterCount: number | undefined;
+    returnType: string | undefined;
+}
+/**
+ * Extract parameter count and return type text from an AST method/function node.
+ * Works across languages by looking for common AST patterns.
+ */
+export declare const extractMethodSignature: (node: SyntaxNode | null | undefined) => MethodSignature;
+/**
+ * Count direct arguments for a call expression across common tree-sitter grammars.
+ * Returns undefined when the argument container cannot be located cheaply.
+ */
+export declare const countCallArguments: (callNode: SyntaxNode | null | undefined) => number | undefined;
+type CallForm = 'free' | 'member' | 'constructor';
+/**
+ * Infer whether a captured call site is a free call, member call, or constructor.
+ * Returns undefined if the form cannot be determined.
+ *
+ * Works by inspecting the AST structure between callNode (@call) and nameNode (@call.name).
+ * No tree-sitter query changes needed — the distinction is in the node types.
+ */
+export declare const inferCallForm: (callNode: SyntaxNode, nameNode: SyntaxNode) => CallForm | undefined;
+export declare const extractReceiverName: (nameNode: SyntaxNode) => string | undefined;
+export declare const isVerboseIngestionEnabled: () => boolean;
+export {};