gitnexus 1.6.4-rc.47 → 1.6.4-rc.48

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

@@ -210,6 +210,95 @@ const TYPESCRIPT_SCOPE_QUERY = `
   key: (string (string_fragment) @declaration.name)
   value: (function_expression) @declaration.function)
 
+;; HOC-wrapped variable declarations: \`const X = HOC((args) => { ... })\`.
+;;
+;; Covers the dominant React UI idiom (\`React.forwardRef\`, \`React.memo\`,
+;; bare \`forwardRef\` / \`memo\` / \`observer\`), Hook callbacks
+;; (\`useCallback\`, \`useMemo\`), and library-wrapper factories (\`debounce\`,
+;; \`throttle\`, user-defined \`withErrorBoundary\` / \`createHook\`, etc.).
+;; All produce the same AST shape:
+;;
+;;   lexical_declaration
+;;     variable_declarator
+;;       name: identifier "X"                          ← we want this name
+;;       value: call_expression
+;;         function: identifier | member_expression    ← any callee
+;;         arguments: arguments
+;;           arrow_function | function_expression      ← the actual code
+;;
+;; The pre-fix \`tsExtractFunctionName\` only handled \`variable_declarator\`
+;; and \`pair\` parents, so HOC-wrapped arrows fell through anonymous. The
+;; registry-primary \`query.ts\` had no pattern for this shape either —
+;; \`const Button = forwardRef((p, r) => { ... })\` registered as a
+;; \`Variable\` with no \`Function\` def, and every call inside the arrow
+;; body lost caller attribution: \`resolveCallerGraphId\` walked up past
+;; the empty arrow scope to the module's File fallback. Sourcerer-fe alone
+;; has ~296 such declarations (57 forwardRef + 21 memo + 161 useCallback
+;; + 57 useMemo) — all invisible to \`gitnexus_context\` /
+;; \`gitnexus_impact\` for outgoing edges before this fix.
+;;
+;; Anchor discipline: same as the \`lexical_declaration\` / \`pair\` blocks
+;; above — on the INNER \`arrow_function\` / \`function_expression\`, NOT
+;; the outer \`call_expression\`. The arrow's range matches its own
+;; \`@scope.function\` range, so \`pass2AttachDeclarations.atPosition\`
+;; resolves \`innermost\` to the arrow's own scope and
+;; \`rangesEqual(anchor.range, innermost.range)\` triggers the auto-hoist
+;; that promotes the binding to the parent scope (where \`const X\`
+;; lives).
+;;
+;; Trade-off — chained array-method form: \`const x = arr.find((y) => p(y))\`
+;; has the same syntactic shape and would also match, naming the
+;; \`.find\` callback as \`x\`. The resulting \`Function:x\` is mostly
+;; harmless: \`x\` is consumed as a value (\`if (x) { ... }\`), never
+;; invoked as a function, so it gets zero incoming \`CALLS\` edges. The
+;; one outgoing edge \`Function:x → p\` is a minor mis-attribution that
+;; could in principle be fixed by adding a \`function: [(identifier)
+;; (member_expression)]\` predicate that excludes property-identifiers
+;; matching a known array-method blocklist (\`map\` / \`filter\` / \`find\`
+;; / \`reduce\` / \`forEach\` / \`some\` / \`every\`). We don't do that here
+;; because (a) the false-positive cost is negligible, (b) the blocklist
+;; would need maintenance, and (c) any user-defined fluent-API method
+;; with a callback argument would still false-positive — there's no
+;; clean syntactic line.
+;;
+;; Trade-off — multi-arrow arguments: \`const x = call(arrow1, arrow2)\`
+;; would emit TWO matches with the same name \`x\`. tree-sitter-query
+;; iterates all arrow_function direct children of \`arguments\`, so each
+;; emits its own \`(name=x, function=...)\` pair. \`pass2AttachDeclarations\`
+;; pushes both \`Function:x\` defs into the same arrow scopes (each in
+;; its own arrow's \`ownedDefs\`) and hoists both bindings to the parent.
+;; The downstream registry's qualified-name dedup then collapses them
+;; via \`(filePath, type, qualifiedName)\` — second wins. Acceptable;
+;; multi-arrow-callback APIs are rare (\`new Promise(executor)\` is the
+;; main one and takes a single executor).
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      arguments: (arguments
+        (arrow_function) @declaration.function))))
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      arguments: (arguments
+        (function_expression) @declaration.function))))
+
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      arguments: (arguments
+        (arrow_function) @declaration.function))))
+
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      arguments: (arguments
+        (function_expression) @declaration.function))))
+
 ;; Method definitions — regular + private (#field) methods.
 (method_definition
   name: (property_identifier) @declaration.name) @declaration.method

package/dist/core/ingestion/languages/typescript.js

@@ -37,11 +37,21 @@ import { emitTsScopeCaptures, interpretTsImport, interpretTsTypeBinding, tsBindi
  *   - `{ addItem: (item) => ... }` (pair / property_assignment) → "addItem"
  *     Covers Zustand stores, TanStack Query factories, React Context
  *     providers, and most other HOF-heavy idioms (issue #1166).
+ *   - `const X = HOC((args) => { ... })` (arguments → call_expression →
+ *     variable_declarator) → "X". Covers `React.forwardRef`, `memo`,
+ *     `useCallback`, `useMemo`, `observer`, `debounce`, and other HOC
+ *     factories that wrap their behaviour-defining arrow. Without this
+ *     branch, every shadcn/Radix UI component (`const Button =
+ *     React.forwardRef(...)`) registered as an anonymous arrow with
+ *     calls inside falling back to File-level attribution. The same
+ *     applied to all `useCallback` / `useMemo` callbacks bound to a
+ *     const — the sole way to give them a named caller anchor.
  *
  * Returns `null` for funcName when the arrow lives in a context that has
- * no static name — call arguments, computed keys, return-from-arrow
- * positions. The parent walk in findEnclosingFunctionId then continues
- * up to the next named ancestor (or to the file).
+ * no static name — bare call arguments (not bound to a const), computed
+ * keys, return-from-arrow positions. The parent walk in
+ * findEnclosingFunctionId then continues up to the next named ancestor
+ * (or to the file).
  */
 const tsExtractFunctionName = (node) => {
     if (node.type !== 'arrow_function' && node.type !== 'function_expression')
@@ -82,6 +92,36 @@ const tsExtractFunctionName = (node) => {
         // no static name — fall through anonymous.
         return { funcName: null, label: 'Function' };
     }
+    // HOC-wrapped variable declarations: `const Button = forwardRef((p, r) => { ... })`,
+    // `const handleClick = useCallback(() => doStuff(), [deps])`,
+    // `const Card = React.memo((props) => { ... })`. The arrow's `parent` is
+    // `arguments`, grandparent is `call_expression`, great-grandparent is
+    // `variable_declarator`. Walk the chain up and take the variable's name
+    // — the meaningful identifier the developer wrote on the LHS. Mirrors
+    // the four registry-primary patterns in `typescript/query.ts`. The
+    // wrapping callee (`forwardRef`, `memo`, `React.memo`, `useCallback`,
+    // user-defined HOCs) is intentionally NOT constrained: any function
+    // call whose result is bound to a const and whose first/positional
+    // argument is an arrow takes the const's name. Chained array-method
+    // calls (`const x = arr.find((y) => p(y))`) match too and produce a
+    // mostly-harmless `Function:x` (consumed as a value, never invoked),
+    // accepted as a small false-positive cost vs. the much larger gain of
+    // capturing the React UI-component idiom.
+    if (parent.type === 'arguments') {
+        const callExpr = parent.parent;
+        if (!callExpr || callExpr.type !== 'call_expression') {
+            return { funcName: null, label: 'Function' };
+        }
+        const declarator = callExpr.parent;
+        if (!declarator || declarator.type !== 'variable_declarator') {
+            return { funcName: null, label: 'Function' };
+        }
+        const nameNode = declarator.childForFieldName?.('name');
+        if (nameNode?.type === 'identifier') {
+            return { funcName: nameNode.text, label: 'Function' };
+        }
+        return { funcName: null, label: 'Function' };
+    }
     return { funcName: null, label: 'Function' };
 };
 export const BUILT_INS = new Set([

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

@@ -1,5 +1,5 @@
-export declare const TYPESCRIPT_QUERIES = "\n(class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(abstract_class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(interface_declaration\n  name: (type_identifier) @name) @definition.interface\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n; TypeScript overload signatures (function_signature is a separate node type from function_declaration)\n(function_signature\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n; ES2022 #private methods (private_property_identifier not matched by property_identifier)\n(method_definition\n  name: (private_property_identifier) @name) @definition.method\n\n; Abstract method signatures in abstract classes\n(abstract_method_signature\n  name: (property_identifier) @name) @definition.method\n\n; Interface method signatures\n(method_signature\n  name: (property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n; Object-property arrows / function expressions: `{ addItem: () => ... }`.\n; The pair's key field carries the meaningful name. Without these patterns,\n; calls inside the arrow are attributed to the file (issue #1166), and the\n; arrow itself is invisible to context() / impact() despite carrying real\n; behaviour (Zustand actions, TanStack queryFn, React Context providers).\n; String-key variant covers `\"add-item\": () => ...`; computed keys\n; (`[K]: () => ...`) intentionally fall through anonymous.\n(pair\n  key: (property_identifier) @name\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (property_identifier) @name\n  value: (function_expression)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (function_expression)) @definition.function\n\n; Variable/constant declarations (non-function values).\n; Overlap with @definition.function patterns is handled by parse-worker dedup.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name))) @definition.const\n\n; var declarations (mutable, function-scoped)\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Generic awaited free call: await fn<T>(args)\n; tree-sitter-typescript parses \"await fn<T>(args)\" as a call_expression whose\n; \"function\" field is an await_expression (not a bare identifier), because the\n; grammar resolves the ambiguity between generics and comparisons by consuming\n; \"await fn\" as an expression before attaching <T> as type_arguments.\n(call_expression\n  function: (await_expression\n    (identifier) @call.name)\n  (type_arguments)) @call\n\n; Generic awaited member call: await obj.fn<T>(args)\n(call_expression\n  function: (await_expression\n    (member_expression\n      property: (property_identifier) @call.name))\n  (type_arguments)) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Class properties \u2014 public_field_definition covers most TS class fields\n(public_field_definition\n  name: (property_identifier) @name) @definition.property\n\n; Private class fields: #address: Address\n(public_field_definition\n  name: (private_property_identifier) @name) @definition.property\n\n; Constructor parameter properties: constructor(public address: Address)\n(required_parameter\n  (accessibility_modifier)\n  pattern: (identifier) @name) @definition.property\n\n; Heritage queries - class extends\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (extends_clause\n      value: (identifier) @heritage.extends))) @heritage\n\n; Heritage queries - class implements interface\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (implements_clause\n      (type_identifier) @heritage.implements))) @heritage.impl\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; HTTP consumers: fetch('/path'), axios.get('/path'), $.get('/path'), etc.\n; fetch() \u2014 global function\n(call_expression\n  function: (identifier) @_fetch_fn (#eq? @_fetch_fn \"fetch\")\n  arguments: (arguments\n    [(string (string_fragment) @route.url)\n     (template_string) @route.template_url])) @route.fetch\n\n; axios.get/post/put/delete/patch('/path'), $.get/post/ajax({url:'/path'})\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @http_client.method)\n  arguments: (arguments\n    (string (string_fragment) @http_client.url))) @http_client\n\n; Decorators: @Controller, @Get, @Post, etc.\n(decorator\n  (call_expression\n    function: (identifier) @decorator.name\n    arguments: (arguments (string (string_fragment) @decorator.arg)?))) @decorator\n\n; Express/Hono route registration: app.get('/path', handler), router.post('/path', fn)\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @express_route.method)\n  arguments: (arguments\n    (string (string_fragment) @express_route.path))) @express_route\n";
-export declare const JAVASCRIPT_QUERIES = "\n(class_declaration\n  name: (identifier) @name) @definition.class\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n; ES2022 #private methods\n(method_definition\n  name: (private_property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n; Object-property arrows / function expressions: `{ addItem: () => ... }`.\n; See TYPESCRIPT_QUERIES for rationale (issue #1166).\n(pair\n  key: (property_identifier) @name\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (property_identifier) @name\n  value: (function_expression)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (function_expression)) @definition.function\n\n; Variable/constant declarations (non-function values).\n; Overlap with @definition.function patterns is handled by parse-worker dedup.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name))) @definition.const\n\n; var declarations (mutable, function-scoped)\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Class fields \u2014 field_definition captures JS class fields (class User { address = ... })\n(field_definition\n  property: (property_identifier) @name) @definition.property\n\n; Heritage queries - class extends (JavaScript uses different AST than TypeScript)\n; In tree-sitter-javascript, class_heritage directly contains the parent identifier\n(class_declaration\n  name: (identifier) @heritage.class\n  (class_heritage\n    (identifier) @heritage.extends)) @heritage\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; HTTP consumers: fetch('/path'), axios.get('/path'), $.get('/path'), etc.\n(call_expression\n  function: (identifier) @_fetch_fn (#eq? @_fetch_fn \"fetch\")\n  arguments: (arguments\n    [(string (string_fragment) @route.url)\n     (template_string) @route.template_url])) @route.fetch\n\n; axios.get/post, $.get/post/ajax\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @http_client.method)\n  arguments: (arguments\n    (string (string_fragment) @http_client.url))) @http_client\n\n; Express/Hono route registration\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @express_route.method)\n  arguments: (arguments\n    (string (string_fragment) @express_route.path))) @express_route\n";
+export declare const TYPESCRIPT_QUERIES = "\n(class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(abstract_class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(interface_declaration\n  name: (type_identifier) @name) @definition.interface\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n; TypeScript overload signatures (function_signature is a separate node type from function_declaration)\n(function_signature\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n; ES2022 #private methods (private_property_identifier not matched by property_identifier)\n(method_definition\n  name: (private_property_identifier) @name) @definition.method\n\n; Abstract method signatures in abstract classes\n(abstract_method_signature\n  name: (property_identifier) @name) @definition.method\n\n; Interface method signatures\n(method_signature\n  name: (property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n; Object-property arrows / function expressions: `{ addItem: () => ... }`.\n; The pair's key field carries the meaningful name. Without these patterns,\n; calls inside the arrow are attributed to the file (issue #1166), and the\n; arrow itself is invisible to context() / impact() despite carrying real\n; behaviour (Zustand actions, TanStack queryFn, React Context providers).\n; String-key variant covers `\"add-item\": () => ...`; computed keys\n; (`[K]: () => ...`) intentionally fall through anonymous.\n(pair\n  key: (property_identifier) @name\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (property_identifier) @name\n  value: (function_expression)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (function_expression)) @definition.function\n\n; HOC-wrapped variable declarations: `const X = HOC((args) => { ... })`.\n; Mirrors the registry-primary patterns in `languages/typescript/query.ts`\n; so the legacy Call-Resolution DAG and the registry-primary pipeline\n; produce the same set of `Function` nodes \u2014 required for the CI parity\n; gate. Covers React.forwardRef / memo / useCallback / useMemo / observer\n; / debounce / user-defined HOC factories. The `var X = HOC(...)` form is\n; mirrored too (registry-primary has it) so that codebases mixing `var` and\n; `const` see identical attribution on both pipelines. See\n; `tsExtractFunctionName` for the resolution logic and the `query.ts`\n; comment for the full anchor-discipline rationale and the chained-\n; array-method trade-off.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (arrow_function)))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (function_expression)))))) @definition.function\n\n; `var X = HOC(...)` parity with registry-primary. Legacy code (and any\n; transpiler output that downlevels `const` to `var`) hits this shape.\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n; Variable/constant declarations (non-function values).\n; Overlap with @definition.function patterns is handled by parse-worker dedup.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name))) @definition.const\n\n; var declarations (mutable, function-scoped)\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Generic awaited free call: await fn<T>(args)\n; tree-sitter-typescript parses \"await fn<T>(args)\" as a call_expression whose\n; \"function\" field is an await_expression (not a bare identifier), because the\n; grammar resolves the ambiguity between generics and comparisons by consuming\n; \"await fn\" as an expression before attaching <T> as type_arguments.\n(call_expression\n  function: (await_expression\n    (identifier) @call.name)\n  (type_arguments)) @call\n\n; Generic awaited member call: await obj.fn<T>(args)\n(call_expression\n  function: (await_expression\n    (member_expression\n      property: (property_identifier) @call.name))\n  (type_arguments)) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Class properties \u2014 public_field_definition covers most TS class fields\n(public_field_definition\n  name: (property_identifier) @name) @definition.property\n\n; Private class fields: #address: Address\n(public_field_definition\n  name: (private_property_identifier) @name) @definition.property\n\n; Constructor parameter properties: constructor(public address: Address)\n(required_parameter\n  (accessibility_modifier)\n  pattern: (identifier) @name) @definition.property\n\n; Heritage queries - class extends\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (extends_clause\n      value: (identifier) @heritage.extends))) @heritage\n\n; Heritage queries - class implements interface\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (implements_clause\n      (type_identifier) @heritage.implements))) @heritage.impl\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; HTTP consumers: fetch('/path'), axios.get('/path'), $.get('/path'), etc.\n; fetch() \u2014 global function\n(call_expression\n  function: (identifier) @_fetch_fn (#eq? @_fetch_fn \"fetch\")\n  arguments: (arguments\n    [(string (string_fragment) @route.url)\n     (template_string) @route.template_url])) @route.fetch\n\n; axios.get/post/put/delete/patch('/path'), $.get/post/ajax({url:'/path'})\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @http_client.method)\n  arguments: (arguments\n    (string (string_fragment) @http_client.url))) @http_client\n\n; Decorators: @Controller, @Get, @Post, etc.\n(decorator\n  (call_expression\n    function: (identifier) @decorator.name\n    arguments: (arguments (string (string_fragment) @decorator.arg)?))) @decorator\n\n; Express/Hono route registration: app.get('/path', handler), router.post('/path', fn)\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @express_route.method)\n  arguments: (arguments\n    (string (string_fragment) @express_route.path))) @express_route\n";
+export declare const JAVASCRIPT_QUERIES = "\n(class_declaration\n  name: (identifier) @name) @definition.class\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n; ES2022 #private methods\n(method_definition\n  name: (private_property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n; Object-property arrows / function expressions: `{ addItem: () => ... }`.\n; See TYPESCRIPT_QUERIES for rationale (issue #1166).\n(pair\n  key: (property_identifier) @name\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (property_identifier) @name\n  value: (function_expression)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (function_expression)) @definition.function\n\n; HOC-wrapped variable declarations: `const X = HOC((args) => { ... })`.\n; See TYPESCRIPT_QUERIES section above for the full rationale (issue #1166\n; follow-up \u2014 covers forwardRef / memo / useCallback / useMemo / observer\n; / debounce / user-defined HOC factories). Both `const` and `var` forms\n; are mirrored so JS code that uses `var` (or transpiler output) gets the\n; same attribution as the registry-primary path.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (arrow_function)))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (function_expression)))))) @definition.function\n\n; `var X = HOC(...)` parity with registry-primary.\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n; Variable/constant declarations (non-function values).\n; Overlap with @definition.function patterns is handled by parse-worker dedup.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name))) @definition.const\n\n; var declarations (mutable, function-scoped)\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Class fields \u2014 field_definition captures JS class fields (class User { address = ... })\n(field_definition\n  property: (property_identifier) @name) @definition.property\n\n; Heritage queries - class extends (JavaScript uses different AST than TypeScript)\n; In tree-sitter-javascript, class_heritage directly contains the parent identifier\n(class_declaration\n  name: (identifier) @heritage.class\n  (class_heritage\n    (identifier) @heritage.extends)) @heritage\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; HTTP consumers: fetch('/path'), axios.get('/path'), $.get('/path'), etc.\n(call_expression\n  function: (identifier) @_fetch_fn (#eq? @_fetch_fn \"fetch\")\n  arguments: (arguments\n    [(string (string_fragment) @route.url)\n     (template_string) @route.template_url])) @route.fetch\n\n; axios.get/post, $.get/post/ajax\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @http_client.method)\n  arguments: (arguments\n    (string (string_fragment) @http_client.url))) @http_client\n\n; Express/Hono route registration\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @express_route.method)\n  arguments: (arguments\n    (string (string_fragment) @express_route.path))) @express_route\n";
 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; Heritage queries - Python class inheritance\n(class_definition\n  name: (identifier) @heritage.class\n  superclasses: (argument_list\n    (identifier) @heritage.extends)) @heritage\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; Heritage - extends class\n(class_declaration name: (identifier) @heritage.class\n  (superclass (type_identifier) @heritage.extends)) @heritage\n\n; Heritage - implements interfaces\n(class_declaration name: (identifier) @heritage.class\n  (super_interfaces (type_list (type_identifier) @heritage.implements))) @heritage.impl\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(union_specifier name: (type_identifier) @name) @definition.union\n(enum_specifier name: (type_identifier) @name) @definition.enum\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";

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

@@ -83,6 +83,63 @@ export const TYPESCRIPT_QUERIES = `
   key: (string (string_fragment) @name)
   value: (function_expression)) @definition.function
 
+; HOC-wrapped variable declarations: \`const X = HOC((args) => { ... })\`.
+; Mirrors the registry-primary patterns in \`languages/typescript/query.ts\`
+; so the legacy Call-Resolution DAG and the registry-primary pipeline
+; produce the same set of \`Function\` nodes — required for the CI parity
+; gate. Covers React.forwardRef / memo / useCallback / useMemo / observer
+; / debounce / user-defined HOC factories. The \`var X = HOC(...)\` form is
+; mirrored too (registry-primary has it) so that codebases mixing \`var\` and
+; \`const\` see identical attribution on both pipelines. See
+; \`tsExtractFunctionName\` for the resolution logic and the \`query.ts\`
+; comment for the full anchor-discipline rationale and the chained-
+; array-method trade-off.
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (call_expression
+      arguments: (arguments
+        (arrow_function))))) @definition.function
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (call_expression
+      arguments: (arguments
+        (function_expression))))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (call_expression
+        arguments: (arguments
+          (arrow_function)))))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (call_expression
+        arguments: (arguments
+          (function_expression)))))) @definition.function
+
+; \`var X = HOC(...)\` parity with registry-primary. Legacy code (and any
+; transpiler output that downlevels \`const\` to \`var\`) hits this shape.
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (call_expression
+      arguments: (arguments
+        (arrow_function))))) @definition.function
+
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (call_expression
+      arguments: (arguments
+        (function_expression))))) @definition.function
+
 ; Variable/constant declarations (non-function values).
 ; Overlap with @definition.function patterns is handled by parse-worker dedup.
 (lexical_declaration
@@ -258,6 +315,57 @@ export const JAVASCRIPT_QUERIES = `
   key: (string (string_fragment) @name)
   value: (function_expression)) @definition.function
 
+; HOC-wrapped variable declarations: \`const X = HOC((args) => { ... })\`.
+; See TYPESCRIPT_QUERIES section above for the full rationale (issue #1166
+; follow-up — covers forwardRef / memo / useCallback / useMemo / observer
+; / debounce / user-defined HOC factories). Both \`const\` and \`var\` forms
+; are mirrored so JS code that uses \`var\` (or transpiler output) gets the
+; same attribution as the registry-primary path.
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (call_expression
+      arguments: (arguments
+        (arrow_function))))) @definition.function
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (call_expression
+      arguments: (arguments
+        (function_expression))))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (call_expression
+        arguments: (arguments
+          (arrow_function)))))) @definition.function
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: (call_expression
+        arguments: (arguments
+          (function_expression)))))) @definition.function
+
+; \`var X = HOC(...)\` parity with registry-primary.
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (call_expression
+      arguments: (arguments
+        (arrow_function))))) @definition.function
+
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @name
+    value: (call_expression
+      arguments: (arguments
+        (function_expression))))) @definition.function
+
 ; Variable/constant declarations (non-function values).
 ; Overlap with @definition.function patterns is handled by parse-worker dedup.
 (lexical_declaration

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.47",
+  "version": "1.6.4-rc.48",
   "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",