gitnexus 1.6.6-rc.149 → 1.6.6-rc.150

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

@@ -1,11 +1,2 @@
 import type { FieldExtractionConfig } from '../generic.js';
-/**
- * Go field extraction config.
- *
- * Go struct fields live inside type_declaration > type_spec > struct_type >
- * field_declaration_list > field_declaration.
- *
- * Visibility in Go is based on the first character: uppercase = exported (public),
- * lowercase = unexported (package).
- */
 export declare const goConfig: FieldExtractionConfig;

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

@@ -10,13 +10,48 @@ import { extractSimpleTypeName } from '../../type-extractors/shared.js';
  * Visibility in Go is based on the first character: uppercase = exported (public),
  * lowercase = unexported (package).
  */
+function goVisibilityForName(name) {
+    const first = name.charAt(0);
+    return first === first.toUpperCase() && first !== first.toLowerCase() ? 'public' : 'package';
+}
+function extractGoFieldNames(node) {
+    const names = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'field_identifier')
+            names.push(child.text);
+    }
+    return names;
+}
 export const goConfig = {
     language: SupportedLanguages.Go,
-    typeDeclarationNodes: ['type_declaration'],
+    typeDeclarationNodes: ['type_declaration', 'struct_type'],
     fieldNodeTypes: ['field_declaration'],
     bodyNodeTypes: ['field_declaration_list'],
     defaultVisibility: 'package',
+    extractOwnerName(node) {
+        if (node.type === 'struct_type') {
+            return node.parent?.type === 'type_spec'
+                ? node.parent.childForFieldName('name')?.text
+                : undefined;
+        }
+        const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
+        return typeSpec?.childForFieldName('name')?.text;
+    },
+    findBodyNodes(node) {
+        if (node.type === 'struct_type') {
+            const body = node.namedChildren.find((child) => child.type === 'field_declaration_list');
+            return body ? [body] : [];
+        }
+        const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
+        const typeNode = typeSpec?.childForFieldName('type');
+        const body = typeNode?.namedChildren.find((child) => child.type === 'field_declaration_list');
+        return body ? [body] : [];
+    },
     extractName(node) {
+        const firstName = extractGoFieldNames(node)[0];
+        if (firstName)
+            return firstName;
         // field_declaration > name:(field_identifier)
         const name = node.childForFieldName('name');
         if (name)
@@ -29,6 +64,7 @@ export const goConfig = {
         }
         return undefined;
     },
+    extractNames: extractGoFieldNames,
     extractType(node) {
         // field_declaration > type:(type_identifier | pointer_type | ...)
         const typeNode = node.childForFieldName('type');
@@ -51,6 +87,9 @@ export const goConfig = {
         }
         return 'package';
     },
+    extractVisibilityForName(_node, name) {
+        return goVisibilityForName(name);
+    },
     isStatic(_node) {
         return false; // Go has no static fields
     },

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

@@ -19,6 +19,10 @@ export interface FieldExtractionConfig {
     bodyNodeTypes: string[];
     /** Default visibility when no modifier is present */
     defaultVisibility: FieldVisibility;
+    /** Extract owner type name from a type declaration node. */
+    extractOwnerName?: (node: SyntaxNode) => string | undefined;
+    /** Find body nodes inside a type declaration node. */
+    findBodyNodes?: (node: SyntaxNode) => SyntaxNode[];
     /**
      * Extract field name from a field declaration node.
      * Use this for nodes that declare exactly one field.
@@ -35,6 +39,8 @@ export interface FieldExtractionConfig {
     extractType: (node: SyntaxNode) => string | undefined;
     /** Extract visibility from a field declaration node */
     extractVisibility: (node: SyntaxNode) => FieldVisibility;
+    /** Extract visibility for one field name from a multi-name declaration. */
+    extractVisibilityForName?: (node: SyntaxNode, name: string) => FieldVisibility;
     /** Check if a field is static */
     isStatic: (node: SyntaxNode) => boolean;
     /** Check if a field is readonly/final/const */

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

@@ -21,10 +21,9 @@ export function createFieldExtractor(config) {
         extract(node, context) {
             if (!this.isTypeDeclaration(node))
                 return null;
-            const nameNode = node.childForFieldName('name');
-            if (!nameNode)
+            const ownerFqn = config.extractOwnerName?.(node) ?? node.childForFieldName('name')?.text;
+            if (!ownerFqn)
                 return null;
-            const ownerFqn = nameNode.text;
             const fields = [];
             // Find body container(s)
             const bodies = this.findBodies(node);
@@ -43,6 +42,8 @@ export function createFieldExtractor(config) {
         // private helpers
         // ------------------------------------------------------------------
         findBodies(node) {
+            if (config.findBodyNodes)
+                return config.findBodyNodes(node);
             const result = [];
             // Try named 'body' field first
             const bodyField = node.childForFieldName('body');
@@ -105,7 +106,7 @@ export function createFieldExtractor(config) {
             return {
                 name,
                 type,
-                visibility: config.extractVisibility(node),
+                visibility: config.extractVisibilityForName?.(node, name) ?? config.extractVisibility(node),
                 isStatic: config.isStatic(node),
                 isReadonly: config.isReadonly(node),
                 sourceFile: context.filePath,

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

@@ -52,11 +52,15 @@ const GO_SCOPE_QUERY = `
 ;; Declarations — variables
 (var_declaration
   (var_spec
-    name: (identifier) @declaration.name)) @declaration.variable
+    (identifier) @declaration.name)) @declaration.variable
+(var_declaration
+  (var_spec_list
+    (var_spec
+      (identifier) @declaration.name))) @declaration.variable
 
 (const_declaration
   (const_spec
-    name: (identifier) @declaration.name)) @declaration.const
+    (identifier) @declaration.name)) @declaration.const
 
 (short_var_declaration
   left: (expression_list (identifier) @declaration.name)) @declaration.variable

package/dist/core/ingestion/parsing-processor.d.ts

@@ -41,6 +41,10 @@ export interface WorkerExtractedData {
  * silently no-op'd by `KnowledgeGraph`).
  */
 export declare const mergeChunkResults: (graph: KnowledgeGraph, symbolTable: SymbolTableWriter, chunkResults: readonly ParseWorkerResult[]) => WorkerExtractedData;
+export declare const processParsingSequential: (graph: KnowledgeGraph, files: {
+    path: string;
+    content: string;
+}[], symbolTable: SymbolTableWriter, astCache: ASTCache, scopeTreeCache: ASTCache | undefined, onFileProgress?: FileProgressCallback) => Promise<void>;
 export declare const processParsing: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;

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

@@ -263,7 +263,7 @@ function seqGetFieldInfo(classNode, provider, context) {
     seqFieldInfoCache.set(cacheKey, cached);
     return cached;
 }
-const processParsingSequential = async (graph, files, symbolTable, astCache, scopeTreeCache, onFileProgress) => {
+export const processParsingSequential = async (graph, files, symbolTable, astCache, scopeTreeCache, onFileProgress) => {
     const parser = await loadParser();
     const total = files.length;
     const logSkipped = isVerboseIngestionEnabled();
@@ -276,6 +276,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
         seqFieldInfoCache.clear();
         seqMethodExtractCache.clear();
         seqMethodMapCache.clear();
+        const seqVariableInfoCache = new Map();
         onFileProgress?.(i + 1, total, file.path);
         if (i % 20 === 0)
             await yieldToEventLoop();
@@ -699,6 +700,31 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 }
                 // All 15 tree-sitter languages register a FieldExtractor — no fallback needed.
             }
+            if ((nodeLabel === 'Const' || nodeLabel === 'Static' || nodeLabel === 'Variable') &&
+                definitionNode &&
+                provider.variableExtractor) {
+                let variableInfoByName = seqVariableInfoCache.get(definitionNode.startIndex);
+                if (!variableInfoByName) {
+                    const varCtx = {
+                        filePath: file.path,
+                        language,
+                    };
+                    variableInfoByName = new Map(provider.variableExtractor
+                        .extractAll(definitionNode, varCtx)
+                        .map((info) => [info.name, info]));
+                    seqVariableInfoCache.set(definitionNode.startIndex, variableInfoByName);
+                }
+                const varInfo = variableInfoByName.get(nodeName);
+                if (varInfo) {
+                    if (varInfo.type)
+                        declaredType = varInfo.type;
+                    seqVisibility = varInfo.visibility;
+                    seqIsStatic = varInfo.isStatic;
+                    methodProps.isConst = varInfo.isConst;
+                    methodProps.isMutable = varInfo.isMutable;
+                    methodProps.scope = varInfo.scope;
+                }
+            }
             // Apply field metadata to the graph node retroactively
             if (seqVisibility !== undefined)
                 node.properties.visibility = seqVisibility;
@@ -708,6 +734,12 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 node.properties.isReadonly = seqIsReadonly;
             if (declaredType !== undefined)
                 node.properties.declaredType = declaredType;
+            if (methodProps.isConst !== undefined)
+                node.properties.isConst = methodProps.isConst;
+            if (methodProps.isMutable !== undefined)
+                node.properties.isMutable = methodProps.isMutable;
+            if (methodProps.scope !== undefined)
+                node.properties.scope = methodProps.scope;
             symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
                 parameterCount: methodProps.parameterCount,
                 requiredParameterCount: methodProps.requiredParameterCount,

package/dist/core/ingestion/tree-sitter-queries.d.ts

@@ -3,7 +3,7 @@ export declare const JAVASCRIPT_QUERIES: string;
 export declare const PYTHON_QUERIES = "\n(class_definition\n  name: (identifier) @name) @definition.class\n\n(function_definition\n  name: (identifier) @name) @definition.function\n\n(import_statement\n  name: (dotted_name) @import.source) @import\n\n; import numpy as np  \u2192  aliased_import captures the module name so the\n; import path is resolved and named-binding extraction stores \"np\" \u2192 \"numpy\".\n(import_statement\n  name: (aliased_import\n    name: (dotted_name) @import.source)) @import\n\n(import_from_statement\n  module_name: (dotted_name) @import.source) @import\n\n(import_from_statement\n  module_name: (relative_import) @import.source) @import\n\n(call\n  function: (identifier) @call.name) @call\n\n(call\n  function: (attribute\n    attribute: (identifier) @call.name)) @call\n\n; Class attribute type annotations \u2014 PEP 526: address: Address or address: Address = Address()\n; Both bare annotations (address: Address) and annotated assignments (name: str = \"test\")\n; are parsed as (assignment left: ... type: ...) in tree-sitter-python.\n(expression_statement\n  (assignment\n    left: (identifier) @name\n    type: (type)) @definition.property)\n\n; Plain variable assignments without type annotation: x = 5, MAX_SIZE = 100\n; Overlap with @definition.property (typed) is handled by parse-worker dedup.\n(expression_statement\n  (assignment\n    left: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Python HTTP clients: requests.get('/path'), httpx.post('/path'), session.get('/path')\n(call\n  function: (attribute\n    attribute: (identifier) @http_client.method)\n  arguments: (argument_list\n    (string (string_content) @http_client.url))) @http_client\n\n; Python decorators: @app.route, @router.get, etc.\n(decorator\n  (call\n    function: (attribute\n      object: (identifier) @decorator.receiver\n      attribute: (identifier) @decorator.name)\n    arguments: (argument_list\n      (string (string_content) @decorator.arg)?))) @decorator\n";
 export declare const JAVA_QUERIES = "\n; Classes, Interfaces, Enums, Annotations\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(enum_declaration name: (identifier) @name) @definition.enum\n(annotation_type_declaration name: (identifier) @name) @definition.annotation\n\n; Methods & Constructors\n(method_declaration name: (identifier) @name) @definition.method\n(constructor_declaration name: (identifier) @name) @definition.constructor\n\n; Fields \u2014 typed field declarations inside class bodies\n(field_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.property\n\n; Imports - capture any import declaration child as source\n(import_declaration (_) @import.source) @import\n\n; Calls\n(method_invocation name: (identifier) @call.name) @call\n(method_invocation object: (_) name: (identifier) @call.name) @call\n(method_reference) @call\n\n; Constructor calls: new Foo()\n(object_creation_expression type: (type_identifier) @call.name) @call\n\n; Local variable declarations inside method bodies\n(local_variable_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_access\n    object: (_) @assignment.receiver\n    field: (identifier) @assignment.property)\n  right: (_)) @assignment\n";
 export declare const C_QUERIES = "\n; Functions (direct declarator)\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n\n; Functions returning pointers (pointer_declarator wraps function_declarator)\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n\n; Functions returning double pointers (nested pointer_declarator)\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function\n\n; Structs, Unions, Enums, Typedefs\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(type_definition\n  type: (struct_specifier\n    body: (field_declaration_list))\n  declarator: (type_identifier) @name) @definition.struct\n(union_specifier name: (type_identifier) @name) @definition.union\n(enum_specifier name: (type_identifier) @name) @definition.enum\n(type_definition\n  type: (enum_specifier\n    body: (enumerator_list))\n  declarator: (type_identifier) @name) @definition.enum\n(enumerator name: (identifier) @name) @definition.const\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n\n; Variable declarations: int x = 5; or int x;\n(declaration\n  declarator: (init_declarator\n    declarator: (identifier) @name)) @definition.variable\n";
-export declare const GO_QUERIES = "\n; Functions & Methods\n(function_declaration name: (identifier) @name) @definition.function\n(method_declaration name: (field_identifier) @name) @definition.method\n(method_elem name: (field_identifier) @name) @definition.method\n\n; Types\n(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct\n(type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface\n\n; Imports\n(import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import\n(import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import\n\n; Struct fields \u2014 named field declarations inside struct types\n(field_declaration_list\n  (field_declaration\n    name: (field_identifier) @name) @definition.property)\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (selector_expression field: (field_identifier) @call.name)) @call\n\n; Const/var declarations\n(const_declaration (const_spec name: (identifier) @name)) @definition.const\n(var_declaration (var_spec name: (identifier) @name)) @definition.variable\n\n; Short variable declaration: x := 5\n(short_var_declaration left: (expression_list (identifier) @name)) @definition.variable\n\n; Struct literal construction: User{Name: \"Alice\"}\n(composite_literal type: (type_identifier) @call.name) @call\n\n; Write access: obj.field = value\n(assignment_statement\n  left: (expression_list\n    (selector_expression\n      operand: (_) @assignment.receiver\n      field: (field_identifier) @assignment.property))\n  right: (_)) @assignment\n\n; Write access: obj.field++ / obj.field--\n(inc_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n(dec_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n";
+export declare const GO_QUERIES = "\n; Functions & Methods\n(function_declaration name: (identifier) @name) @definition.function\n(method_declaration name: (field_identifier) @name) @definition.method\n(method_elem name: (field_identifier) @name) @definition.method\n\n; Types\n(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct\n(type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface\n\n; Imports\n(import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import\n(import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import\n\n; Struct fields \u2014 named field declarations inside struct types\n(field_declaration_list\n  (field_declaration\n    name: (field_identifier) @name) @definition.property)\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (selector_expression field: (field_identifier) @call.name)) @call\n\n; Const/var declarations\n(const_declaration (const_spec (identifier) @name)) @definition.const\n(var_declaration (var_spec (identifier) @name)) @definition.variable\n(var_declaration (var_spec_list (var_spec (identifier) @name))) @definition.variable\n\n; Short variable declaration: x := 5\n(short_var_declaration left: (expression_list (identifier) @name)) @definition.variable\n\n; Struct literal construction: User{Name: \"Alice\"}\n(composite_literal type: (type_identifier) @call.name) @call\n\n; Write access: obj.field = value\n(assignment_statement\n  left: (expression_list\n    (selector_expression\n      operand: (_) @assignment.receiver\n      field: (field_identifier) @assignment.property))\n  right: (_)) @assignment\n\n; Write access: obj.field++ / obj.field--\n(inc_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n(dec_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n";
 export declare const CPP_QUERIES = "\n; Classes, Structs, Namespaces\n(class_specifier name: (type_identifier) @name) @definition.class\n(class_specifier\n  name: (template_type\n    (type_identifier) @name\n    (template_argument_list) @template-arguments)) @definition.class\n; Out-of-line nested definition: class Outer::Inner { ... } / struct Outer::Inner { ... }.\n; Key the node by the full qualified_identifier text so the def materializes a\n; node that matches the HAS_METHOD owner id (also the full qualified text) and\n; stays distinct from a same-tail type in another scope (#1975, #1978).\n(class_specifier name: (qualified_identifier) @name) @definition.class\n(struct_specifier name: (qualified_identifier) @name) @definition.struct\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(struct_specifier\n  name: (template_type\n    (type_identifier) @name\n    (template_argument_list) @template-arguments)) @definition.struct\n(namespace_definition name: (namespace_identifier) @name) @definition.namespace\n(enum_specifier name: (type_identifier) @name) @definition.enum\n\n; Typedefs and unions (common in C-style headers and mixed C/C++ code)\n(type_definition\n  type: (struct_specifier\n    body: (field_declaration_list))\n  declarator: (type_identifier) @name) @definition.struct\n(type_definition\n  type: (enum_specifier\n    body: (enumerator_list))\n  declarator: (type_identifier) @name) @definition.enum\n(enumerator name: (identifier) @name) @definition.const\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n(union_specifier name: (type_identifier) @name) @definition.union\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Functions & Methods (direct declarator)\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(function_definition declarator: (function_declarator declarator: (operator_name) @name)) @definition.function\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))) @definition.method\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (operator_name) @name))) @definition.method\n\n; Functions/methods returning pointers (pointer_declarator wraps function_declarator)\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method\n\n; Functions/methods returning double pointers (nested pointer_declarator)\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))))) @definition.method\n\n; Functions/methods returning references (reference_declarator wraps function_declarator)\n(function_definition declarator: (reference_declarator (function_declarator declarator: (identifier) @name))) @definition.function\n(function_definition declarator: (reference_declarator (function_declarator declarator: (operator_name) @name))) @definition.function\n(function_definition declarator: (reference_declarator (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method\n(function_definition declarator: (reference_declarator (function_declarator declarator: (qualified_identifier name: (operator_name) @name)))) @definition.method\n\n; Destructors (destructor_name is distinct from identifier in tree-sitter-cpp)\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (destructor_name) @name))) @definition.method\n\n; Function declarations / prototypes (common in headers)\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (operator_name) @name)) @definition.function\n(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(declaration declarator: (reference_declarator (function_declarator declarator: (operator_name) @name))) @definition.function\n\n; Class/struct data member fields (Address address; int count;)\n; Uses field_identifier to exclude method declarations (which use function_declarator)\n(field_declaration\n  declarator: (field_identifier) @name) @definition.property\n\n; Pointer member fields (Address* address;)\n(field_declaration\n  declarator: (pointer_declarator\n    declarator: (field_identifier) @name)) @definition.property\n\n; Reference member fields (Address& address;)\n(field_declaration\n  declarator: (reference_declarator\n    (field_identifier) @name)) @definition.property\n\n; Inline class method declarations (inside class body, no body: void save();)\n; tree-sitter-cpp uses field_identifier (not identifier) for names inside class bodies\n(field_declaration declarator: (function_declarator declarator: [(field_identifier) (identifier) (operator_name)] @name)) @definition.method\n\n; Inline class method declarations returning a pointer (User* lookup();)\n(field_declaration declarator: (pointer_declarator declarator: (function_declarator declarator: [(field_identifier) (identifier)] @name))) @definition.method\n\n; Inline class method declarations returning a reference (User& lookup();)\n(field_declaration declarator: (reference_declarator (function_declarator declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method\n\n; Inline class method definitions (inside class body, with body: void Foo() { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (function_declarator\n      declarator: [(field_identifier) (identifier) (operator_name) (destructor_name)] @name)) @definition.method)\n\n; Inline class methods returning a pointer type (User* lookup(int id) { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (pointer_declarator\n      declarator: (function_declarator\n        declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method)\n\n; Inline class methods returning a reference type (User& lookup(int id) { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (reference_declarator\n      (function_declarator\n        declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method)\n\n; Templates\n(template_declaration (class_specifier name: (type_identifier) @name)) @definition.template\n(template_declaration\n  (class_specifier\n    name: (template_type\n      (type_identifier) @name\n      (template_argument_list) @template-arguments))) @definition.template\n(template_declaration (function_definition declarator: (function_declarator declarator: (identifier) @name))) @definition.template\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n(call_expression function: (qualified_identifier name: (identifier) @call.name)) @call\n(call_expression function: (template_function name: (identifier) @call.name)) @call\n(binary_expression operator: \"+\" @call.name) @call\n(binary_expression operator: \"<<\" @call.name) @call\n\n; Constructor calls: new User()\n(new_expression type: (type_identifier) @call.name) @call\n\n; Variable declarations: int x = 5; or auto x = 5;\n(declaration\n  declarator: (init_declarator\n    declarator: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_expression\n    argument: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)\n  right: (_)) @assignment\n\n";
 export declare const CSHARP_QUERIES = "\n; Types\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(struct_declaration name: (identifier) @name) @definition.struct\n(enum_declaration name: (identifier) @name) @definition.enum\n(record_declaration name: (identifier) @name) @definition.record\n(delegate_declaration name: (identifier) @name) @definition.delegate\n\n; Namespaces (block form and C# 10+ file-scoped form)\n(namespace_declaration name: (identifier) @name) @definition.namespace\n(namespace_declaration name: (qualified_name) @name) @definition.namespace\n(file_scoped_namespace_declaration name: (identifier) @name) @definition.namespace\n(file_scoped_namespace_declaration name: (qualified_name) @name) @definition.namespace\n\n; Methods & Properties\n(method_declaration name: (identifier) @name) @definition.method\n(local_function_statement name: (identifier) @name) @definition.function\n(constructor_declaration name: (identifier) @name) @definition.constructor\n(property_declaration name: (identifier) @name) @definition.property\n\n; Primary constructors (C# 12): class User(string name, int age) { }\n(class_declaration name: (identifier) @name (parameter_list) @definition.constructor)\n(record_declaration name: (identifier) @name (parameter_list) @definition.constructor)\n\n; Using\n(using_directive (qualified_name) @import.source) @import\n(using_directive (identifier) @import.source) @import\n\n; Calls\n(invocation_expression function: (identifier) @call.name) @call\n(invocation_expression function: (member_access_expression name: (identifier) @call.name)) @call\n\n; Null-conditional method calls: user?.Save()\n; Parses as: invocation_expression \u2192 conditional_access_expression \u2192 member_binding_expression \u2192 identifier\n(invocation_expression\n  function: (conditional_access_expression\n    (member_binding_expression\n      (identifier) @call.name))) @call\n\n; Constructor calls: new Foo() and new Foo { Props }\n(object_creation_expression type: (identifier) @call.name) @call\n\n; Target-typed new (C# 9): User u = new(\"x\", 5)\n(variable_declaration type: (identifier) @call.name (variable_declarator (implicit_object_creation_expression) @call))\n\n; Local variable declarations\n(local_declaration_statement\n  (variable_declaration\n    (variable_declarator\n      (identifier) @name))) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (member_access_expression\n    expression: (_) @assignment.receiver\n    name: (identifier) @assignment.property)\n  right: (_)) @assignment\n";
 export declare const RUST_QUERIES = "\n; Functions & Items\n(function_item name: (identifier) @name) @definition.function\n(function_signature_item name: (identifier) @name) @definition.function\n(struct_item name: (type_identifier) @name) @definition.struct\n; A union is materialized as a Struct node (same rationale as the\n; scope-resolution @declaration.struct in languages/rust/query.ts: every\n; registry-primary resolution gate includes Struct but excludes Union, so a\n; Union-labeled node would be an unresolvable orphan). #1934 F71.\n(union_item name: (type_identifier) @name) @definition.struct\n(enum_item name: (type_identifier) @name) @definition.enum\n(trait_item name: (type_identifier) @name) @definition.trait\n(impl_item type: (type_identifier) @name !trait) @definition.impl\n(impl_item type: (generic_type type: (type_identifier) @name) !trait) @definition.impl\n; Scoped inherent impl: impl path::Type { ... }. Key the Impl node by the full\n; scoped_type_identifier text so it matches the owner id (also full text) and\n; stays distinct from a same-tail type in another module (#1975).\n(impl_item type: (scoped_type_identifier) @name !trait) @definition.impl\n(mod_item name: (identifier) @name) @definition.module\n\n; Type aliases, const, static, macros\n(type_item name: (type_identifier) @name) @definition.type\n(const_item name: (identifier) @name) @definition.const\n(static_item name: (identifier) @name) @definition.static\n(macro_definition name: (identifier) @name) @definition.macro\n\n; Use statements\n(use_declaration argument: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n(call_expression function: (scoped_identifier name: (identifier) @call.name)) @call\n(call_expression function: (generic_function function: (identifier) @call.name)) @call\n\n; Struct literal construction: User { name: value }\n(struct_expression name: (type_identifier) @call.name) @call\n\n; Struct fields \u2014 named field declarations inside struct bodies\n(field_declaration_list\n  (field_declaration\n    name: (field_identifier) @name) @definition.property)\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_expression\n    value: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(compound_assignment_expr\n  left: (field_expression\n    value: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)\n  right: (_)) @assignment\n";

package/dist/core/ingestion/tree-sitter-queries.js

@@ -828,8 +828,9 @@ export const GO_QUERIES = `
 (call_expression function: (selector_expression field: (field_identifier) @call.name)) @call
 
 ; Const/var declarations
-(const_declaration (const_spec name: (identifier) @name)) @definition.const
-(var_declaration (var_spec name: (identifier) @name)) @definition.variable
+(const_declaration (const_spec (identifier) @name)) @definition.const
+(var_declaration (var_spec (identifier) @name)) @definition.variable
+(var_declaration (var_spec_list (var_spec (identifier) @name))) @definition.variable
 
 ; Short variable declaration: x := 5
 (short_var_declaration left: (expression_list (identifier) @name)) @definition.variable

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

@@ -15,7 +15,69 @@ import { extractSimpleTypeName } from '../../type-extractors/shared.js';
  *
  * Visibility: uppercase first letter = exported (public), lowercase = unexported (package).
  */
+function goVisibilityForName(name) {
+    const firstChar = name.charAt(0);
+    return firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase()
+        ? 'public'
+        : 'package';
+}
+function collectGoSpecNames(spec) {
+    const names = [];
+    for (let i = 0; i < spec.namedChildCount; i++) {
+        const child = spec.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'identifier') {
+            names.push(child.text);
+            continue;
+        }
+        break;
+    }
+    return names;
+}
+function collectGoSpecs(node) {
+    const specs = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'var_spec' || child?.type === 'const_spec') {
+            specs.push(child);
+            continue;
+        }
+        if (child?.type === 'var_spec_list') {
+            specs.push(...collectGoSpecs(child));
+        }
+    }
+    return specs;
+}
+function collectGoDeclarationNames(node) {
+    if (node.type === 'short_var_declaration') {
+        const left = node.childForFieldName('left');
+        if (left?.type !== 'expression_list')
+            return [];
+        return left.namedChildren
+            .filter((child) => child.type === 'identifier')
+            .map((child) => child.text);
+    }
+    const names = [];
+    for (const spec of collectGoSpecs(node))
+        names.push(...collectGoSpecNames(spec));
+    return names;
+}
+function findGoSpecForName(node, name) {
+    for (const spec of collectGoSpecs(node)) {
+        if (collectGoSpecNames(spec).includes(name))
+            return spec;
+    }
+    return undefined;
+}
+function extractGoSpecType(spec) {
+    const typeNode = spec.childForFieldName('type');
+    return typeNode ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim()) : undefined;
+}
 function extractGoVarName(node) {
+    const firstName = collectGoDeclarationNames(node)[0];
+    if (firstName)
+        return firstName;
     // var_declaration/const_declaration → var_spec/const_spec → identifier
     for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
@@ -43,13 +105,10 @@ function extractGoVarName(node) {
     return undefined;
 }
 function extractGoVarType(node) {
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child?.type === 'var_spec' || child?.type === 'const_spec') {
-            const typeNode = child.childForFieldName('type');
-            if (typeNode)
-                return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
-        }
+    for (const spec of collectGoSpecs(node)) {
+        const typeName = extractGoSpecType(spec);
+        if (typeName)
+            return typeName;
     }
     return undefined;
 }
@@ -60,6 +119,10 @@ export const goVariableConfig = {
     variableNodeTypes: ['var_declaration', 'short_var_declaration'],
     extractName: extractGoVarName,
     extractType: extractGoVarType,
+    extractTypeForName(node, name) {
+        const spec = findGoSpecForName(node, name);
+        return spec ? extractGoSpecType(spec) : undefined;
+    },
     extractVisibility(node) {
         const name = extractGoVarName(node);
         if (!name)
@@ -70,6 +133,10 @@ export const goVariableConfig = {
             ? 'public'
             : 'package';
     },
+    extractNames: collectGoDeclarationNames,
+    extractVisibilityForName(_node, name) {
+        return goVisibilityForName(name);
+    },
     isConst(node) {
         return node.type === 'const_declaration';
     },

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

@@ -50,13 +50,16 @@ export function createVariableExtractor(config) {
             return allNodeTypes.has(node.type);
         },
         extract(node, context) {
+            return this.extractAll(node, context)[0] ?? null;
+        },
+        extractAll(node, context) {
             if (!allNodeTypes.has(node.type))
-                return null;
-            const name = config.extractName(node);
-            if (!name)
-                return null;
-            const type = config.extractType(node) ?? null;
-            const visibility = config.extractVisibility(node);
+                return [];
+            const names = config.extractNames
+                ? config.extractNames(node)
+                : [config.extractName(node)].filter((name) => Boolean(name));
+            if (names.length === 0)
+                return [];
             // isConst/isStatic: node type membership is a hint, but config.isConst/isStatic
             // has final say. For languages where const and non-const share a node type
             // (e.g., TS lexical_declaration for both const and let), config.isConst disambiguates.
@@ -64,17 +67,17 @@ export function createVariableExtractor(config) {
             const isStatic = staticNodeSet.has(node.type) || config.isStatic(node);
             const isMutable = config.isMutable(node);
             const scope = determineScope(node);
-            return {
+            return names.map((name) => ({
                 name,
-                type,
-                visibility,
+                type: config.extractTypeForName?.(node, name) ?? config.extractType(node) ?? null,
+                visibility: config.extractVisibilityForName?.(node, name) ?? config.extractVisibility(node),
                 isConst,
                 isStatic,
                 isMutable,
                 scope,
                 sourceFile: context.filePath,
                 line: node.startPosition.row + 1,
-            };
+            }));
         },
     };
 }

package/dist/core/ingestion/variable-types.d.ts

@@ -51,6 +51,9 @@ export interface VariableExtractor {
     /** Extract variable metadata from a declaration node.
      *  Returns null if the node is not a recognized variable declaration. */
     extract(node: SyntaxNode, context: VariableExtractorContext): VariableInfo | null;
+    /** Extract every variable metadata entry from a declaration node.
+     *  Returns [] if the node is not a recognized variable declaration. */
+    extractAll(node: SyntaxNode, context: VariableExtractorContext): VariableInfo[];
     /** Check if a node is a recognized variable declaration type. */
     isVariableDeclaration(node: SyntaxNode): boolean;
 }
@@ -69,10 +72,16 @@ export interface VariableExtractionConfig {
     variableNodeTypes: string[];
     /** Extract the variable name from a declaration node */
     extractName: (node: SyntaxNode) => string | undefined;
+    /** Extract multiple variable names from a declaration node. */
+    extractNames?: (node: SyntaxNode) => string[];
     /** Extract type annotation from a declaration node */
     extractType: (node: SyntaxNode) => string | undefined;
+    /** Extract type annotation for one variable name from a multi-name declaration. */
+    extractTypeForName?: (node: SyntaxNode, name: string) => string | undefined;
     /** Extract visibility from a declaration node */
     extractVisibility: (node: SyntaxNode) => VariableVisibility;
+    /** Extract visibility for one variable name from a multi-name declaration. */
+    extractVisibilityForName?: (node: SyntaxNode, name: string) => VariableVisibility;
     /** Check if a declaration is const/immutable */
     isConst: (node: SyntaxNode) => boolean;
     /** Check if a declaration is static */

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

@@ -830,6 +830,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         // (e.g. @definition.function) to avoid duplicate nodes when @definition.const/@definition.variable
         // patterns overlap with the same source range.
         const processedDefinitionNodes = new Set();
+        const variableInfoCache = new Map();
         for (const match of matches) {
             const captureMap = {};
             for (const c of match.captures) {
@@ -1223,17 +1224,6 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 }) === true) {
                 continue;
             }
-            // Dedup: variable captures (Const/Static/Variable) may overlap with higher-priority
-            // captures (e.g. `const fn = () => {}` matches both @definition.function and @definition.const).
-            // Skip variable captures whose definition node was already processed.
-            if ((nodeLabel === 'Const' || nodeLabel === 'Static' || nodeLabel === 'Variable') &&
-                definitionNode &&
-                processedDefinitionNodes.has(definitionNode.startIndex)) {
-                continue;
-            }
-            if (definitionNode) {
-                processedDefinitionNodes.add(definitionNode.startIndex);
-            }
             const exportDefaultCall = nodeLabel === 'Function' && definitionNode?.type === 'export_statement'
                 ? definitionNode.namedChildren.find((child) => child.type === 'call_expression')
                 : undefined;
@@ -1263,6 +1253,23 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 !defaultExportHocName)
                 continue;
             const nodeName = extractedClassSymbol?.name ?? defaultExportHocName ?? (nameNode ? nameNode.text : 'init');
+            // Dedup: variable captures (Const/Static/Variable) may overlap with higher-priority
+            // captures (e.g. `const fn = () => {}` matches both @definition.function and @definition.const).
+            // Multi-name declarations share the same definition node, so include the emitted name.
+            if (definitionNode) {
+                const definitionBaseKey = `${definitionNode.startIndex}`;
+                if (nodeLabel === 'Const' || nodeLabel === 'Static' || nodeLabel === 'Variable') {
+                    const definitionNameKey = `${definitionBaseKey}:${nodeName}`;
+                    if (processedDefinitionNodes.has(definitionBaseKey) ||
+                        processedDefinitionNodes.has(definitionNameKey)) {
+                        continue;
+                    }
+                    processedDefinitionNodes.add(definitionNameKey);
+                }
+                else {
+                    processedDefinitionNodes.add(definitionBaseKey);
+                }
+            }
             const startLine = definitionNode
                 ? definitionNode.startPosition.row + lineOffset
                 : nameNode
@@ -1486,11 +1493,18 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             if ((nodeLabel === 'Const' || nodeLabel === 'Static' || nodeLabel === 'Variable') &&
                 definitionNode &&
                 provider.variableExtractor) {
-                const varCtx = {
-                    filePath: file.path,
-                    language,
-                };
-                const varInfo = provider.variableExtractor.extract(definitionNode, varCtx);
+                let variableInfoByName = variableInfoCache.get(definitionNode.startIndex);
+                if (!variableInfoByName) {
+                    const varCtx = {
+                        filePath: file.path,
+                        language,
+                    };
+                    variableInfoByName = new Map(provider.variableExtractor
+                        .extractAll(definitionNode, varCtx)
+                        .map((info) => [info.name, info]));
+                    variableInfoCache.set(definitionNode.startIndex, variableInfoByName);
+                }
+                const varInfo = variableInfoByName.get(nodeName);
                 if (varInfo) {
                     if (varInfo.type)
                         declaredType = varInfo.type;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.149",
+  "version": "1.6.6-rc.150",
   "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",