gitnexus 1.6.6-rc.93 → 1.6.6-rc.95

package/dist/core/group/extractors/grpc-patterns/node.js

@@ -69,21 +69,38 @@ const NEW_QUALIFIED_CTOR_SPEC = {
 // proto loader). Matches either a bare call or an `obj.loadPackageDefinition(...)`
 // call. Plugin gates the qualified-constructor consumer on this —
 // structural check avoids materializing `tree.rootNode.text` for every file.
-const LOAD_PACKAGE_DEFINITION_SPEC = {
-    meta: {},
-    query: `
-    (call_expression
-      function: [
-        (identifier) @fn (#eq? @fn "loadPackageDefinition")
-        (member_expression property: (property_identifier) @fn (#eq? @fn "loadPackageDefinition"))
-      ])
-  `,
-};
+//
+// These are TWO separate specs, NOT one `function: [ (identifier) ... (member_expression) ... ]`
+// alternation. Under the pinned tree-sitter@0.21.1 binding a top-level alternation
+// whose branches reuse the same capture name (`@fn`) collapses to one pattern with
+// a shared predicate bucket; the second branch's `@fn` is left unbound and its
+// `#eq?` is never enforced, so the member-expression branch would match EVERY
+// `obj.method(...)` call (e.g. `console.log(...)`) — turning this gate always-on
+// and emitting spurious qualified-constructor consumers. Two specs compile to two
+// queries with independent predicate buckets; `runCompiledPatterns` concatenates
+// their matches, so the `.length > 0` gate still means "either form is present".
+const LOAD_PACKAGE_DEFINITION_SPECS = [
+    {
+        meta: {},
+        query: `
+      (call_expression
+        function: (identifier) @fn (#eq? @fn "loadPackageDefinition"))
+    `,
+    },
+    {
+        meta: {},
+        query: `
+      (call_expression
+        function: (member_expression
+          property: (property_identifier) @fn (#eq? @fn "loadPackageDefinition")))
+    `,
+    },
+];
 function compileBundle(language, name) {
     const mk = (spec, suffix) => compilePatterns({
         name: `${name}-${suffix}`,
         language,
-        patterns: [spec],
+        patterns: Array.isArray(spec) ? spec : [spec],
     });
     return {
         grpcMethod: mk(GRPC_METHOD_SPEC, 'grpc-method'),
@@ -91,7 +108,7 @@ function compileBundle(language, name) {
         getService: mk(GET_SERVICE_SPEC, 'get-service'),
         newSimpleCtor: mk(NEW_SIMPLE_CTOR_SPEC, 'new-simple-ctor'),
         newQualifiedCtor: mk(NEW_QUALIFIED_CTOR_SPEC, 'new-qualified-ctor'),
-        loadPackageDefinition: mk(LOAD_PACKAGE_DEFINITION_SPEC, 'load-package-definition'),
+        loadPackageDefinition: mk(LOAD_PACKAGE_DEFINITION_SPECS, 'load-package-definition'),
     };
 }
 const JAVASCRIPT_BUNDLE = compileBundle(JavaScript, 'javascript-grpc');

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

@@ -6,14 +6,18 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
  *   - Spring `RestTemplate.getForObject/...`, `exchange(...)`
  *   - Spring `WebClient.method(HttpMethod.X, ...)`, `WebClient.get().uri(...)`
  *   - OkHttp `new Request.Builder().url("...")`
- *   - OpenFeign interfaces with Spring MVC method annotations
+ *   - OpenFeign interfaces with Spring MVC method annotations or
+ *     native `@RequestLine("METHOD /path")` annotations
  *   - Java / Apache HttpClient literal request construction
  *
- * The plugin runs two pattern bundles: one to collect class-level
- * `@RequestMapping` prefixes keyed by the enclosing class node, and a
- * second to match method-level annotations. The `scan` function walks
- * up from each matched annotation to find its enclosing class and
- * combines the prefix with the method path.
+ * Every route-defining annotation (class/interface `@RequestMapping`
+ * prefixes, `@FeignClient(path)` prefixes, `@(Get|...)Mapping` method
+ * routes and native `@RequestLine`s) is matched by a single consolidated
+ * query (`JAVA_ROUTE_ANNOTATION_PATTERNS`) in one pass via
+ * `scanRouteAnnotations`. The `scan` function then walks up from each
+ * matched method to its enclosing class/interface to combine the prefix
+ * with the method path. Call-site consumers (RestTemplate, WebClient,
+ * OkHttp, Java/Apache HttpClient) keep their own focused queries.
  */
 const METHOD_ANNOTATION_TO_HTTP = {
     GetMapping: 'GET',
@@ -22,9 +26,34 @@ const METHOD_ANNOTATION_TO_HTTP = {
     DeleteMapping: 'DELETE',
     PatchMapping: 'PATCH',
 };
-// ─── Provider: Spring class/interface-level @RequestMapping prefix ───
-const SPRING_TYPE_PREFIX_PATTERNS = compilePatterns({
-    name: 'java-spring-type-prefix',
+// ─── Route-defining annotations (one generic query, one pass) ─────────
+// Every Java route-mapper annotation shares one shape: an annotation carrying a
+// single string argument — positional `"..."` or named `key = "..."` — on a
+// class, interface, or method. This SINGLE query matches that shape generically;
+// `scanRouteAnnotations` then reads the annotation NAME (`@ann`) and declaration
+// kind (`@node.type`) in its for-loop to decide what each match means. Adding a
+// new framework annotation that follows this single-string-argument shape is a
+// change to that loop (and the lookup maps), not to this query. Annotations with
+// a different argument shape — e.g. an array value `@RequestMapping({"/a","/b"})`
+// — are out of scope here (as they were for the prior queries) and would need a
+// new branch.
+//
+// Captures (shared across all branches; intentionally framework-agnostic):
+//   @ann    → the annotation name identifier (RequestMapping, GetMapping, RequestLine, …)
+//   @node   → the enclosing declaration (class_declaration | interface_declaration | method_declaration)
+//   @value  → the string-literal argument
+//   @key    → the named-argument member key (absent for the positional shape)
+//   @member → the method name (method_declaration branches only)
+//
+// The query carries NO `#eq?` / `#match?` predicates. Under the pinned
+// tree-sitter 0.21.x binding a top-level `[ ... ]` alternation compiles to one
+// pattern whose text predicates share a single bucket keyed by capture name, and
+// a `#match?` against a capture absent from the matched branch evaluates FALSE —
+// silently dropping sibling-branch matches. Keeping the query predicate-free
+// sidesteps that hazard entirely; all name/key discrimination lives in the
+// for-loop, where it reads as straight-line code.
+const JAVA_ROUTE_ANNOTATION_PATTERNS = compilePatterns({
+    name: 'java-route-annotation',
     language: Java,
     patterns: [
         {
@@ -34,36 +63,44 @@ const SPRING_TYPE_PREFIX_PATTERNS = compilePatterns({
           (class_declaration
             (modifiers
               (annotation
-                name: (identifier) @ann (#eq? @ann "RequestMapping")
-                arguments: (annotation_argument_list (string_literal) @prefix)))) @type
+                name: (identifier) @ann
+                arguments: (annotation_argument_list (string_literal) @value)))) @node
           (interface_declaration
             (modifiers
               (annotation
-                name: (identifier) @ann (#eq? @ann "RequestMapping")
-                arguments: (annotation_argument_list (string_literal) @prefix)))) @type
-        ]
-      `,
-        },
-        {
-            meta: {},
-            query: `
-        [
+                name: (identifier) @ann
+                arguments: (annotation_argument_list (string_literal) @value)))) @node
           (class_declaration
             (modifiers
               (annotation
-                name: (identifier) @ann (#eq? @ann "RequestMapping")
+                name: (identifier) @ann
                 arguments: (annotation_argument_list
                   (element_value_pair
-                    key: (identifier) @key (#match? @key "^(path|value)$")
-                    value: (string_literal) @prefix))))) @type
+                    key: (identifier) @key
+                    value: (string_literal) @value))))) @node
           (interface_declaration
             (modifiers
               (annotation
-                name: (identifier) @ann (#eq? @ann "RequestMapping")
+                name: (identifier) @ann
                 arguments: (annotation_argument_list
                   (element_value_pair
-                    key: (identifier) @key (#match? @key "^(path|value)$")
-                    value: (string_literal) @prefix))))) @type
+                    key: (identifier) @key
+                    value: (string_literal) @value))))) @node
+          (method_declaration
+            (modifiers
+              (annotation
+                name: (identifier) @ann
+                arguments: (annotation_argument_list (string_literal) @value)))
+            name: (identifier) @member) @node
+          (method_declaration
+            (modifiers
+              (annotation
+                name: (identifier) @ann
+                arguments: (annotation_argument_list
+                  (element_value_pair
+                    key: (identifier) @key
+                    value: (string_literal) @value))))
+            name: (identifier) @member) @node
         ]
       `,
         },
@@ -84,88 +121,43 @@ const SPRING_TYPE_DECLARATION_PATTERNS = compilePatterns({
         },
     ],
 });
-// ─── Consumer: OpenFeign interface-level prefixes ───────────────────
-// Feign's `name`/`value` attributes identify a service, not an HTTP path,
-// so only `path` is used as a URL prefix. `@RequestMapping` on a Feign
-// interface is also common and does carry a path prefix.
-const FEIGN_INTERFACE_PREFIX_PATTERNS = compilePatterns({
-    name: 'java-feign-interface-prefix',
-    language: Java,
-    patterns: [
-        {
-            meta: {},
-            query: `
-        (interface_declaration
-          (modifiers
-            (annotation
-              name: (identifier) @ann (#eq? @ann "FeignClient")
-              arguments: (annotation_argument_list
-                (element_value_pair
-                  key: (identifier) @key (#eq? @key "path")
-                  value: (string_literal) @prefix))))) @interface
-      `,
-        },
-        {
-            meta: {},
-            query: `
-        (interface_declaration
-          (modifiers
-            (annotation
-              name: (identifier) @ann (#eq? @ann "RequestMapping")
-              arguments: (annotation_argument_list (string_literal) @prefix)))) @interface
-      `,
-        },
-        {
-            meta: {},
-            query: `
-        (interface_declaration
-          (modifiers
-            (annotation
-              name: (identifier) @ann (#eq? @ann "RequestMapping")
-              arguments: (annotation_argument_list
-                (element_value_pair
-                  key: (identifier) @key (#match? @key "^(path|value)$")
-                  value: (string_literal) @prefix))))) @interface
-      `,
-        },
-    ],
-});
-// ─── Provider: Spring @(Get|Post|...)Mapping method annotations ───────
-// Same dual-pattern approach: positional vs named argument. The named
-// pattern restricts the annotation member name to `path`/`value` to
-// avoid capturing unrelated string-valued attributes
-// (`produces`, `consumes`, `headers`, `name`, `params`, ...).
-const SPRING_METHOD_ROUTE_PATTERNS = compilePatterns({
-    name: 'java-spring-method-route',
-    language: Java,
-    patterns: [
-        {
-            meta: {},
-            query: `
-        (method_declaration
-          (modifiers
-            (annotation
-              name: (identifier) @ann (#match? @ann "^(Get|Post|Put|Delete|Patch)Mapping$")
-              arguments: (annotation_argument_list (string_literal) @path)))
-          name: (identifier) @method_name) @method
-      `,
-        },
-        {
-            meta: {},
-            query: `
-        (method_declaration
-          (modifiers
-            (annotation
-              name: (identifier) @ann (#match? @ann "^(Get|Post|Put|Delete|Patch)Mapping$")
-              arguments: (annotation_argument_list
-                (element_value_pair
-                  key: (identifier) @key (#match? @key "^(path|value)$")
-                  value: (string_literal) @path))))
-          name: (identifier) @method_name) @method
-      `,
-        },
-    ],
-});
+// ─── Consumer: OpenFeign `@RequestLine("METHOD /path")` parsing ───────
+// OpenFeign's native annotation pairs an HTTP method and path in a single
+// string literal — see https://github.com/OpenFeign/feign#interface-annotations.
+// It is method-level only and is mutually exclusive with Spring MVC
+// `@GetMapping` / `@PostMapping` etc. on the same method (mixing them
+// requires a different Feign Contract — they are not combined). The match
+// itself comes from `JAVA_ROUTE_ANNOTATION_PATTERNS`; this regex splits the
+// verb from the path of the captured literal.
+//
+// Examples:
+//   @RequestLine("GET /users/{id}")
+//   @RequestLine("POST /users?status=active")
+const REQUEST_LINE_VERB_RE = /^\s*(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s+(\S.*?)\s*$/i;
+/**
+ * Parse a Feign `@RequestLine` value into a method + path pair.
+ *
+ * `@RequestLine("METHOD /path[?query]")` packs both fields in one string;
+ * the query portion is dropped because contract IDs are method+path only
+ * (consistent with how other consumers like RestTemplate/WebClient drop
+ * query strings when their values are inline literals).
+ *
+ * Returns null if the value is not a recognized HTTP verb followed by a
+ * path beginning with `/`.
+ */
+function parseRequestLine(raw) {
+    const match = REQUEST_LINE_VERB_RE.exec(raw);
+    if (!match)
+        return null;
+    const [, verb, rest] = match;
+    if (typeof verb !== 'string' || typeof rest !== 'string')
+        return null;
+    const queryIdx = rest.indexOf('?');
+    const pathOnly = (queryIdx >= 0 ? rest.slice(0, queryIdx) : rest).trim();
+    if (!pathOnly.startsWith('/'))
+        return null;
+    return { method: verb.toUpperCase(), path: pathOnly };
+}
 // ─── Consumer: Spring RestTemplate (object-named + method-named) ──────
 // RestTemplate.getForObject / getForEntity → GET
 // RestTemplate.postForObject / postForEntity → POST
@@ -364,38 +356,110 @@ function hasAnnotation(node, names) {
     }
     return false;
 }
-function collectTypePrefixes(tree) {
-    const prefixByTypeId = new Map();
-    for (const match of runCompiledPatterns(SPRING_TYPE_PREFIX_PATTERNS, tree)) {
-        const prefixNode = match.captures.prefix;
-        const typeNode = match.captures.type;
-        if (!prefixNode || !typeNode)
-            continue;
-        const prefix = unquoteLiteral(prefixNode.text);
-        if (prefix !== null)
-            prefixByTypeId.set(typeNode.id, prefix);
-    }
-    return prefixByTypeId;
+/**
+ * A named annotation argument contributes a route only when its member key is
+ * `path` or `value`; a positional argument (no key node) always qualifies.
+ * This is the JS-side replacement for the in-query `^(path|value)$` filter and
+ * drops Spring's non-route string attributes (`produces`, `consumes`,
+ * `headers`, `name`, `params`) that would otherwise be mis-read as routes.
+ */
+function isRouteMemberKey(keyNode) {
+    if (!keyNode)
+        return true;
+    return keyNode.text === 'path' || keyNode.text === 'value';
 }
-function collectMethodRoutes(tree) {
-    const routesByMethodId = new Map();
-    for (const match of runCompiledPatterns(SPRING_METHOD_ROUTE_PATTERNS, tree)) {
-        const annNode = match.captures.ann;
-        const pathNode = match.captures.path;
-        const methodNode = match.captures.method;
-        if (!annNode || !pathNode || !methodNode)
-            continue;
-        const httpMethod = METHOD_ANNOTATION_TO_HTTP[annNode.text];
-        if (!httpMethod)
+/**
+ * Resolve every Java route-defining annotation in a single tree-sitter pass.
+ *
+ * The generic `JAVA_ROUTE_ANNOTATION_PATTERNS` query yields one match per
+ * annotation-carrying-a-string-argument on any class / interface / method. This
+ * loop reads the annotation name and declaration kind to decide what each match
+ * means, ignoring annotations it does not recognise. The HTTP verb map
+ * (`METHOD_ANNOTATION_TO_HTTP`) and the `path`/`value` key filter
+ * (`isRouteMemberKey`) live here rather than in the query (see its header).
+ */
+function scanRouteAnnotations(tree) {
+    const matches = runCompiledPatterns(JAVA_ROUTE_ANNOTATION_PATTERNS, tree);
+    // The two prefix maps intentionally diverge for the same interface node:
+    // `prefixByTypeId` feeds the Spring *provider* path (class prefix +
+    // collectSpringTypes cross-file inheritance), while `feignPrefixByInterfaceId`
+    // feeds the OpenFeign *consumer* path in scan(). An interface carrying both
+    // `@RequestMapping` and `@FeignClient(path)` lands a different value in each.
+    const prefixByTypeId = new Map();
+    const feignPrefixByInterfaceId = new Map();
+    const methodRoutes = [];
+    const requestLines = [];
+    // Interface `@RequestMapping` prefixes rank below `@FeignClient(path)`;
+    // collect them and apply only after the FeignClient pass below.
+    const interfaceRequestMappingPrefixes = [];
+    for (const { captures } of matches) {
+        const annNode = captures.ann;
+        const node = captures.node;
+        const valueNode = captures.value;
+        if (!annNode || !node || !valueNode)
             continue;
-        const rawPath = unquoteLiteral(pathNode.text);
-        if (rawPath === null)
+        const ann = annNode.text;
+        const keyNode = captures.key; // undefined for the positional shape
+        if (node.type === 'method_declaration') {
+            // Method-level: a Spring `@(Get|...)Mapping` route, or native `@RequestLine`.
+            const httpMethod = METHOD_ANNOTATION_TO_HTTP[ann];
+            if (httpMethod) {
+                if (!isRouteMemberKey(keyNode))
+                    continue;
+                const rawPath = unquoteLiteral(valueNode.text);
+                if (rawPath !== null) {
+                    methodRoutes.push({
+                        methodNode: node,
+                        methodName: captures.member?.text ?? null,
+                        httpMethod,
+                        rawPath,
+                    });
+                }
+            }
+            else if (ann === 'RequestLine') {
+                // Feign packs verb + path in one literal; its only named argument is `value`.
+                if (keyNode && keyNode.text !== 'value')
+                    continue;
+                const raw = unquoteLiteral(valueNode.text);
+                const parsed = raw !== null ? parseRequestLine(raw) : null;
+                if (parsed) {
+                    requestLines.push({
+                        methodNode: node,
+                        methodName: captures.member?.text ?? null,
+                        parsed,
+                    });
+                }
+            }
             continue;
-        const routes = routesByMethodId.get(methodNode.id) ?? [];
-        routes.push({ method: httpMethod, path: rawPath });
-        routesByMethodId.set(methodNode.id, routes);
+        }
+        // Type-level (class or interface): a Spring `@RequestMapping` URL prefix, or
+        // — on an interface — an OpenFeign `@FeignClient(path = "...")` prefix.
+        if (ann === 'RequestMapping') {
+            if (!isRouteMemberKey(keyNode))
+                continue;
+            const prefix = unquoteLiteral(valueNode.text);
+            if (prefix !== null) {
+                prefixByTypeId.set(node.id, prefix);
+                if (node.type === 'interface_declaration') {
+                    interfaceRequestMappingPrefixes.push({ id: node.id, prefix });
+                }
+            }
+        }
+        else if (ann === 'FeignClient' && node.type === 'interface_declaration') {
+            // Feign's `name`/`value` identify a service, not a path — only `path` is a prefix.
+            if (!keyNode || keyNode.text !== 'path')
+                continue;
+            const prefix = unquoteLiteral(valueNode.text);
+            if (prefix !== null && !feignPrefixByInterfaceId.has(node.id)) {
+                feignPrefixByInterfaceId.set(node.id, prefix);
+            }
+        }
+    }
+    for (const { id, prefix } of interfaceRequestMappingPrefixes) {
+        if (!feignPrefixByInterfaceId.has(id))
+            feignPrefixByInterfaceId.set(id, prefix);
     }
-    return routesByMethodId;
+    return { prefixByTypeId, feignPrefixByInterfaceId, methodRoutes, requestLines };
 }
 function collectDirectMethods(typeNode) {
     const out = [];
@@ -432,8 +496,13 @@ function collectImplementedInterfaces(typeNode) {
     return out;
 }
 function collectSpringTypes(filePath, tree) {
-    const prefixByTypeId = collectTypePrefixes(tree);
-    const routesByMethodId = collectMethodRoutes(tree);
+    const { prefixByTypeId, methodRoutes } = scanRouteAnnotations(tree);
+    const routesByMethodId = new Map();
+    for (const route of methodRoutes) {
+        const routes = routesByMethodId.get(route.methodNode.id) ?? [];
+        routes.push({ method: route.httpMethod, path: route.rawPath });
+        routesByMethodId.set(route.methodNode.id, routes);
+    }
     const out = [];
     for (const match of runCompiledPatterns(SPRING_TYPE_DECLARATION_PATTERNS, tree)) {
         const typeNode = match.captures.type;
@@ -521,59 +590,60 @@ export const JAVA_HTTP_PLUGIN = {
     language: Java,
     scan(tree) {
         const out = [];
-        // ─── Providers: Spring class prefix + method annotations ────────
-        const prefixByTypeId = collectTypePrefixes(tree);
-        const feignPrefixByInterfaceId = new Map();
-        for (const match of runCompiledPatterns(FEIGN_INTERFACE_PREFIX_PATTERNS, tree)) {
-            const prefixNode = match.captures.prefix;
-            const interfaceNode = match.captures.interface;
-            if (!prefixNode || !interfaceNode)
-                continue;
-            const prefix = unquoteLiteral(prefixNode.text);
-            if (prefix !== null && !feignPrefixByInterfaceId.has(interfaceNode.id))
-                feignPrefixByInterfaceId.set(interfaceNode.id, prefix);
-        }
-        for (const match of runCompiledPatterns(SPRING_METHOD_ROUTE_PATTERNS, tree)) {
-            const annNode = match.captures.ann;
-            const pathNode = match.captures.path;
-            const nameNode = match.captures.method_name;
-            const methodNode = match.captures.method;
-            if (!annNode || !pathNode || !methodNode)
-                continue;
-            const httpMethod = METHOD_ANNOTATION_TO_HTTP[annNode.text];
-            if (!httpMethod)
-                continue;
-            const rawPath = unquoteLiteral(pathNode.text);
-            if (rawPath === null)
-                continue;
-            const enclosingInterface = findEnclosingInterface(methodNode);
+        // ─── Spring providers + OpenFeign consumers (one query pass) ────
+        // `scanRouteAnnotations` resolves every route-defining annotation —
+        // class/interface prefixes, method `@(Get|...)Mapping`s and native
+        // `@RequestLine`s — from a single `matches()` pass over the tree.
+        const { prefixByTypeId, feignPrefixByInterfaceId, methodRoutes, requestLines } = scanRouteAnnotations(tree);
+        // A `@(Get|...)Mapping` inside a `@FeignClient` interface is an OpenFeign
+        // *consumer* (it describes a remote call); the same annotation inside a
+        // class is a Spring *provider*. A mapping on a non-Feign interface has no
+        // enclosing class and is dropped here — interface→controller inheritance is
+        // handled by `scanProject`.
+        for (const route of methodRoutes) {
+            const enclosingInterface = findEnclosingInterface(route.methodNode);
             if (enclosingInterface && hasAnnotation(enclosingInterface, 'FeignClient')) {
                 const prefix = feignPrefixByInterfaceId.get(enclosingInterface.id) ?? '';
-                const fullPath = joinPath(prefix, rawPath);
                 out.push({
                     role: 'consumer',
                     framework: 'openfeign',
-                    method: httpMethod,
-                    path: fullPath,
-                    name: nameNode?.text ?? null,
+                    method: route.httpMethod,
+                    path: joinPath(prefix, route.rawPath),
+                    name: route.methodName,
                     confidence: 0.7,
                 });
                 continue;
             }
-            const enclosingClass = findEnclosingClass(methodNode);
+            const enclosingClass = findEnclosingClass(route.methodNode);
             if (!enclosingClass)
                 continue;
             const prefix = prefixByTypeId.get(enclosingClass.id) ?? '';
-            const fullPath = joinPath(prefix, rawPath);
             out.push({
                 role: 'provider',
                 framework: 'spring',
-                method: httpMethod,
-                path: fullPath,
-                name: nameNode?.text ?? null,
+                method: route.httpMethod,
+                path: joinPath(prefix, route.rawPath),
+                name: route.methodName,
                 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.
+        for (const requestLine of requestLines) {
+            const enclosingInterface = findEnclosingInterface(requestLine.methodNode);
+            if (!enclosingInterface || !hasAnnotation(enclosingInterface, 'FeignClient'))
+                continue;
+            const prefix = feignPrefixByInterfaceId.get(enclosingInterface.id) ?? '';
+            out.push({
+                role: 'consumer',
+                framework: 'openfeign',
+                method: requestLine.parsed.method,
+                path: joinPath(prefix, requestLine.parsed.path),
+                name: requestLine.methodName,
+                confidence: 0.75,
+            });
+        }
         // ─── Consumers: RestTemplate ────────────────────────────────────
         for (const match of runCompiledPatterns(REST_TEMPLATE_PATTERNS, tree)) {
             const methodNode = match.captures.method;

package/package.json

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