gitnexus 1.6.6-rc.97 → 1.6.6-rc.99

package/dist/core/group/extractors/http-patterns/java.js

@@ -627,12 +627,19 @@ export const JAVA_HTTP_PLUGIN = {
                 confidence: 0.8,
             });
         }
-        // Native OpenFeign `@RequestLine("METHOD /path")`. Method-level only; the
-        // enclosing interface MUST carry `@FeignClient`, otherwise the same
-        // annotation name in unrelated libraries would be a false positive.
+        // Native OpenFeign `@RequestLine("METHOD /path")`. Method-level only and
+        // always declared on an interface (Feign builds a proxy from the interface).
+        // We do NOT require an enclosing `@FeignClient`: `@RequestLine` is a core
+        // `feign.*` annotation used with `Feign.builder()`, whereas `@FeignClient`
+        // is the Spring Cloud variant that uses Spring MVC annotations instead — the
+        // two are effectively mutually exclusive, so requiring `@FeignClient` here
+        // would miss the annotation's primary use. The `RequestLine` name is itself
+        // a strong, framework-specific signal, so a structural interface check is
+        // enough to keep false positives away. A `@FeignClient(path=...)` prefix is
+        // still applied when present (rare, but harmless).
         for (const requestLine of requestLines) {
             const enclosingInterface = findEnclosingInterface(requestLine.methodNode);
-            if (!enclosingInterface || !hasAnnotation(enclosingInterface, 'FeignClient'))
+            if (!enclosingInterface)
                 continue;
             const prefix = feignPrefixByInterfaceId.get(enclosingInterface.id) ?? '';
             out.push({

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

@@ -1,4 +1,4 @@
-import { findNodeAtRange, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
 import { getGoParser, getGoScopeQuery } from './query.js';
 import { recordGoCacheHit, recordGoCacheMiss } from './cache-stats.js';
 import { computeGoCallArity, computeGoDeclarationArity } from './arity-metadata.js';
@@ -22,39 +22,61 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
     const out = [];
     for (const m of rawMatches) {
         const grouped = {};
+        // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
+        // hands us the matched node as `c.node`; keeping it here lets us derive the
+        // anchor/relative node by walking LOCALLY (parent chain / own subtree)
+        // instead of re-walking from tree.rootNode (the O(matches x rootChildren)
+        // hotpath that made #1848's 250-struct DAO file take ~10s). The captured
+        // node either IS the node the old findNodeAtRange re-derived, or is a close
+        // relative reachable by a bounded local walk.
+        const nodeMap = {};
         for (const c of m.captures) {
             const tag = '@' + c.name;
             if (tag.startsWith('@_'))
                 continue; // skip anonymous captures
             grouped[tag] = nodeToCapture(tag, c.node);
+            nodeMap[tag] = c.node;
         }
         if (Object.keys(grouped).length === 0)
             continue;
         if (grouped['@import.statement'] !== undefined) {
-            const anchor = grouped['@import.statement'];
-            const importNode = findNodeAtRange(tree.rootNode, anchor.range, 'import_declaration') ??
-                findNodeAtRange(tree.rootNode, anchor.range, 'import_spec');
+            // The captured node is the `import_spec`; the original code preferred its
+            // enclosing `import_declaration` ONLY when that ancestor shares the exact
+            // same range (which never happens — the declaration always includes the
+            // `import` keyword prefix — so it falls back to the import_spec itself).
+            // Replicate that exactly via a local ancestor walk, never from root.
+            const importNode = resolveImportNode(nodeMap['@import.statement']);
             if (importNode !== null) {
                 out.push(...splitGoImportStatement(importNode));
                 continue;
             }
         }
         if (grouped['@scope.function'] !== undefined) {
-            const scopeCap = grouped['@scope.function'];
-            const fnNode = findNodeAtRange(tree.rootNode, scopeCap.range, 'function_declaration') ??
-                findNodeAtRange(tree.rootNode, scopeCap.range, 'method_declaration');
+            // @scope.function captures function_declaration | method_declaration |
+            // func_literal. The original looked for a function_declaration or
+            // method_declaration at the captured range; the captured node IS that
+            // node for the first two, and a func_literal never coincides in range
+            // with either, so the lookup yields null for func_literal.
+            const scopeNode = nodeMap['@scope.function'];
+            const fnNode = scopeNode.type === 'function_declaration' || scopeNode.type === 'method_declaration'
+                ? scopeNode
+                : null;
             if (fnNode !== null) {
                 const receiver = synthesizeGoReceiverBinding(fnNode);
                 if (receiver !== null)
                     out.push(receiver);
             }
         }
-        if (isRawMultiAssignTypeBinding(tree.rootNode, grouped))
+        if (isRawMultiAssignTypeBinding(nodeMap))
             continue;
-        const declAnchor = grouped['@declaration.function'] ?? grouped['@declaration.method'];
-        if (declAnchor !== undefined) {
-            const fnNode = findNodeAtRange(tree.rootNode, declAnchor.range, 'function_declaration') ??
-                findNodeAtRange(tree.rootNode, declAnchor.range, 'method_declaration');
+        const declAnchorNode = nodeMap['@declaration.function'] ?? nodeMap['@declaration.method'];
+        if (declAnchorNode !== undefined) {
+            // @declaration.function / @declaration.method are captured directly on
+            // the function_declaration / method_declaration node.
+            const fnNode = declAnchorNode.type === 'function_declaration' ||
+                declAnchorNode.type === 'method_declaration'
+                ? declAnchorNode
+                : null;
             if (fnNode !== null) {
                 const arity = computeGoDeclarationArity(fnNode);
                 if (arity.parameterCount !== undefined) {
@@ -70,13 +92,14 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
             out.push(grouped);
             continue;
         }
-        const callAnchor = grouped['@reference.call.free'] ??
-            grouped['@reference.call.member'] ??
-            grouped['@reference.call.constructor'];
-        if (callAnchor !== undefined && grouped['@reference.arity'] === undefined) {
-            const callNode = findNodeAtRange(tree.rootNode, callAnchor.range, 'call_expression') ??
-                findNodeAtRange(tree.rootNode, callAnchor.range, 'composite_literal');
-            if (callNode !== null) {
+        // @reference.call.free / .member are captured on the call_expression;
+        // @reference.call.constructor on the composite_literal. The captured node
+        // IS the node the old findNodeAtRange re-derived for each, so use it.
+        const callNode = nodeMap['@reference.call.free'] ??
+            nodeMap['@reference.call.member'] ??
+            nodeMap['@reference.call.constructor'];
+        if (callNode !== undefined && grouped['@reference.arity'] === undefined) {
+            if (callNode.type === 'call_expression' || callNode.type === 'composite_literal') {
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(computeGoCallArity(callNode)));
             }
         }
@@ -109,15 +132,54 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
     }
     return out;
 }
-function isRawMultiAssignTypeBinding(rootNode, grouped) {
-    const anchor = grouped['@type-binding.constructor'] ??
-        grouped['@type-binding.call-return'] ??
-        grouped['@type-binding.assertion'];
+/**
+ * Resolve the node passed to `splitGoImportStatement` for an @import.statement
+ * match. The capture is on the `import_spec`; the original preferred an
+ * `import_declaration` at the SAME range, else the import_spec. An
+ * import_declaration always includes the `import` keyword and so never shares
+ * the spec's exact range — the only candidate is an ancestor, and it can only
+ * match when ranges coincide. Walk the parent chain (bounded, local) for an
+ * import_declaration whose range equals the spec's; otherwise return the spec.
+ */
+function resolveImportNode(importSpec) {
+    let current = importSpec.parent;
+    while (current !== null) {
+        if (current.type === 'import_declaration') {
+            if (nodeRangeEquals(current, importSpec))
+                return current;
+            break;
+        }
+        // import_spec is nested at most under import_declaration ->
+        // import_spec_list -> import_spec; stop once we leave the import subtree.
+        if (current.type !== 'import_spec_list')
+            break;
+        current = current.parent;
+    }
+    return importSpec;
+}
+/** True iff two nodes occupy the exact same source range. */
+function nodeRangeEquals(a, b) {
+    return (a.startPosition.row === b.startPosition.row &&
+        a.startPosition.column === b.startPosition.column &&
+        a.endPosition.row === b.endPosition.row &&
+        a.endPosition.column === b.endPosition.column);
+}
+function isRawMultiAssignTypeBinding(nodeMap) {
+    const anchor = nodeMap['@type-binding.constructor'] ??
+        nodeMap['@type-binding.call-return'] ??
+        nodeMap['@type-binding.assertion'];
     if (anchor === undefined)
         return false;
-    const node = findNodeAtRange(rootNode, anchor.range, 'short_var_declaration');
-    if (node === null)
+    // These tags are captured directly ON the short_var_declaration, so the
+    // captured node IS what the original findNodeAtRange(root, range,
+    // 'short_var_declaration') re-derived. The var_declaration (var-form)
+    // variants — @type-binding.assertion (`var x = e.(T)`) and
+    // @type-binding.call-return (`var x = Func()`) — anchor on a var_declaration
+    // instead; the old range+type lookup found no short_var_declaration at that
+    // range and returned null -> false, which this type guard reproduces exactly.
+    if (anchor.type !== 'short_var_declaration')
         return false;
+    const node = anchor;
     const lhs = node.childForFieldName('left');
     const rhs = node.childForFieldName('right');
     if (lhs === null)

package/package.json

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