gitnexus 1.6.9-rc.2 → 1.6.9-rc.4

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

@@ -1,17 +1,53 @@
 import Java from 'tree-sitter-java';
 import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
 import { METHOD_ANNOTATION_TO_HTTP, isRouteMemberKey, findEnclosingClass, } from '../../../ingestion/route-extractors/spring-shared.js';
+import { REST_TEMPLATE_TO_HTTP, WEB_CLIENT_SHORT_TO_HTTP, WEB_CLIENT_LONG_VERB_RE, EXCHANGE_ANNOTATION_TO_HTTP, parseRequestLine, pushPrefix, joinPath, scanSpringInheritanceProject, OPENFEIGN_FRAMEWORK, HTTP_INTERFACE_FRAMEWORK, FEIGN_CONFIDENCE, REQUEST_LINE_CONFIDENCE, EXCHANGE_CONFIDENCE, } from './spring-consumer-shared.js';
+/**
+ * Java HTTP plugin. Handles:
+ *   - Spring `@RequestMapping` class prefixes + `@(Get|Post|...)Mapping` method annotations
+ *   - Spring `RestTemplate.getForObject/...`, `exchange(...)`
+ *   - Spring `WebClient.method(HttpMethod.X, ...)`, `WebClient.get().uri(...)`
+ *   - OkHttp `new Request.Builder().url("...")`
+ *   - OpenFeign interfaces with Spring MVC method annotations or
+ *     native `@RequestLine("METHOD /path")` annotations
+ *   - Java / Apache HttpClient literal request construction
+ *
+ * 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.
+ */
+// Each route-defining annotation has two AST shapes — a positional argument
+// and a named one — that must both be matched:
+//   @RequestMapping("/api")          → (annotation_argument_list (string_literal))
+//   @RequestMapping(path = "/api")   → (annotation_argument_list (element_value_pair key:(identifier) value:(string_literal)))
+//   @RequestMapping(value = "/api")  → same as above
+// For named arguments only the route member keys (`path`/`value`) carry a URL;
+// non-route attributes (`produces`, `consumes`, `headers`, `name`, `params`)
+// would otherwise be mis-extracted (e.g. `produces = "application/json"` would
+// corrupt every route). That key filtering is done in `isRouteMemberKey`, and
+// all of these annotations are matched by the one `JAVA_ROUTE_ANNOTATION_PATTERNS`
+// query below (see its header for why the filtering lives in JS, not the query).
+// The Spring class/interface view (`SharedSpringType`) and the interface-based
+// controller inheritance algorithm (`scanSpringInheritanceProject`) are shared
+// with kotlin.ts via spring-consumer-shared.ts so both plugins emit identical
+// provider contracts. `collectSpringTypes` below produces that shared shape.
 // ─── 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.
+// string argument — positional `"..."` or named `key = "..."`, each also in its
+// array form `{"..."}` / `key = {"..."}` (Spring's `path`/`value` are
+// `String[]`) — on a class, interface, or method. This SINGLE query matches that
+// shape generically; the `@value` capture is an alternation over a bare
+// `string_literal` and one nested in an `element_value_array_initializer`, so a
+// single-element array yields the same `@value` (a multi-element array yields one
+// match per element). `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 shape is
+// a change to that loop (and the lookup maps), not to this query.
 //
 // Captures (shared across all branches; intentionally framework-agnostic):
 //   @ann    → the annotation name identifier (RequestMapping, GetMapping, RequestLine, …)
@@ -27,6 +63,18 @@ import { METHOD_ANNOTATION_TO_HTTP, isRouteMemberKey, findEnclosingClass, } from
 // 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.
+//
+// KNOWN LIMITATION — fully-qualified route annotations are not matched. `@ann`
+// binds `name: (identifier)`, but a FQN annotation (`@org.springframework…
+// GetMapping("/x")`) parses its name as a `scoped_identifier`, which this query
+// does not match, so its route is not extracted. (The class is still recognized
+// as a controller — `hasAnnotation` trailing-segment-matches the FQN — only the
+// route-string extraction is missed.) In practice annotations are imported and
+// written by simple name, so this is rare. It is a minor asymmetry with the
+// Kotlin plugin, whose grammar models a FQN as separate `type_identifier`
+// segments that its route queries DO match. Aligning Java would mean matching
+// `scoped_identifier` too; that is deferred to avoid re-keying existing Java
+// contracts via the predicate hazard above. Pinned by an anti-overreach test.
 const JAVA_ROUTE_ANNOTATION_PATTERNS = compilePatterns({
     name: 'java-route-annotation',
     language: Java,
@@ -39,12 +87,12 @@ const JAVA_ROUTE_ANNOTATION_PATTERNS = compilePatterns({
             (modifiers
               (annotation
                 name: (identifier) @ann
-                arguments: (annotation_argument_list (string_literal) @value)))) @node
+                arguments: (annotation_argument_list [(string_literal) @value (element_value_array_initializer (string_literal) @value)])))) @node
           (interface_declaration
             (modifiers
               (annotation
                 name: (identifier) @ann
-                arguments: (annotation_argument_list (string_literal) @value)))) @node
+                arguments: (annotation_argument_list [(string_literal) @value (element_value_array_initializer (string_literal) @value)])))) @node
           (class_declaration
             (modifiers
               (annotation
@@ -52,7 +100,7 @@ const JAVA_ROUTE_ANNOTATION_PATTERNS = compilePatterns({
                 arguments: (annotation_argument_list
                   (element_value_pair
                     key: (identifier) @key
-                    value: (string_literal) @value))))) @node
+                    value: [(string_literal) @value (element_value_array_initializer (string_literal) @value)]))))) @node
           (interface_declaration
             (modifiers
               (annotation
@@ -60,12 +108,12 @@ const JAVA_ROUTE_ANNOTATION_PATTERNS = compilePatterns({
                 arguments: (annotation_argument_list
                   (element_value_pair
                     key: (identifier) @key
-                    value: (string_literal) @value))))) @node
+                    value: [(string_literal) @value (element_value_array_initializer (string_literal) @value)]))))) @node
           (method_declaration
             (modifiers
               (annotation
                 name: (identifier) @ann
-                arguments: (annotation_argument_list (string_literal) @value)))
+                arguments: (annotation_argument_list [(string_literal) @value (element_value_array_initializer (string_literal) @value)])))
             name: (identifier) @member) @node
           (method_declaration
             (modifiers
@@ -74,7 +122,7 @@ const JAVA_ROUTE_ANNOTATION_PATTERNS = compilePatterns({
                 arguments: (annotation_argument_list
                   (element_value_pair
                     key: (identifier) @key
-                    value: (string_literal) @value))))
+                    value: [(string_literal) @value (element_value_array_initializer (string_literal) @value)]))))
             name: (identifier) @member) @node
         ]
       `,
@@ -96,60 +144,6 @@ const SPRING_TYPE_DECLARATION_PATTERNS = compilePatterns({
         },
     ],
 });
-// ─── 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
-// RestTemplate.put → PUT
-// RestTemplate.delete → DELETE
-// RestTemplate.patchForObject → PATCH
-// Source-scan only: receiver must be named exactly `restTemplate`.
-// Fields, `this.restTemplate`, aliases, and other injection names are deferred.
-const REST_TEMPLATE_TO_HTTP = {
-    getForObject: 'GET',
-    getForEntity: 'GET',
-    postForObject: 'POST',
-    postForEntity: 'POST',
-    put: 'PUT',
-    delete: 'DELETE',
-    patchForObject: 'PATCH',
-};
 const REST_TEMPLATE_PATTERNS = compilePatterns({
     name: 'java-rest-template',
     language: Java,
@@ -184,13 +178,6 @@ const REST_TEMPLATE_EXCHANGE_PATTERNS = compilePatterns({
         },
     ],
 });
-const WEB_CLIENT_SHORT_TO_HTTP = {
-    get: 'GET',
-    post: 'POST',
-    put: 'PUT',
-    delete: 'DELETE',
-    patch: 'PATCH',
-};
 const WEB_CLIENT_SHORT_FORM_PATTERNS = compilePatterns({
     name: 'java-web-client-short-form',
     language: Java,
@@ -209,6 +196,36 @@ const WEB_CLIENT_SHORT_FORM_PATTERNS = compilePatterns({
         },
     ],
 });
+// ─── Consumer: WebClient long form `webClient.method(HttpMethod.X).uri("/y")` ─
+// The fluent long form carries the verb as a `HttpMethod.X` field access through
+// `.method(...)` and the path on a separate `.uri(...)` hop. A single structural
+// query matches the whole chain (the same field-access shape used by
+// REST_TEMPLATE_EXCHANGE_PATTERNS) — the earlier "intentionally deferred" note
+// predated the Kotlin plugin proving the structural query is enough. Variable-
+// bound verbs (`webClient.method(verb).uri(...)`) do NOT match: the value carries
+// a bare `identifier`, not a `HttpMethod.X` field access — source-scan can't
+// follow the binding (anti-overreach test pins this, parity with Kotlin).
+const WEB_CLIENT_LONG_FORM_PATTERNS = compilePatterns({
+    name: 'java-web-client-long-form',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (method_invocation
+          object: (method_invocation
+            object: (identifier) @obj (#eq? @obj "webClient")
+            name: (identifier) @method_call (#eq? @method_call "method")
+            arguments: (argument_list
+              (field_access
+                object: (identifier) @httpMethodCls (#eq? @httpMethodCls "HttpMethod")
+                field: (identifier) @verb)))
+          name: (identifier) @uri_method (#eq? @uri_method "uri")
+          arguments: (argument_list . (string_literal) @path))
+      `,
+        },
+    ],
+});
 // ─── Consumer: OkHttp `new Request.Builder().url("path")` ─────────────
 // Note: `Request.Builder` is a `scoped_type_identifier` whose text includes
 // the dot, so `#eq?` against the literal string matches cleanly (no need
@@ -287,32 +304,6 @@ function findEnclosingInterface(node) {
     }
     return null;
 }
-/**
- * Join a class-level prefix and a method-level path into a single URL
- * path. Mirrors the semantics of the original regex implementation:
- * strip trailing slashes on the prefix, then ensure a single slash
- * between prefix and method path.
- */
-function joinPath(prefix, methodPath) {
-    const cleanPrefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
-    const cleanSub = methodPath.replace(/^\/+/, '');
-    if (!cleanPrefix)
-        return `/${cleanSub}`;
-    return `/${cleanPrefix}/${cleanSub}`;
-}
-function joinInheritedSpringPath(controllerPrefix, inheritedPath, inheritedOwnerPrefix = '') {
-    const joined = joinPath(controllerPrefix, inheritedPath);
-    const cleanPrefix = controllerPrefix.replace(/^\/+/, '').replace(/\/+$/, '');
-    const cleanOwnerPrefix = inheritedOwnerPrefix.replace(/^\/+/, '').replace(/\/+$/, '');
-    const cleanInherited = inheritedPath.replace(/^\/+/, '');
-    if (!cleanPrefix)
-        return joined;
-    if (cleanPrefix === cleanOwnerPrefix &&
-        (cleanInherited === cleanPrefix || cleanInherited.startsWith(`${cleanPrefix}/`))) {
-        return `/${cleanInherited}`;
-    }
-    return joined;
-}
 function getNodeName(node) {
     return node.childForFieldName('name')?.text ?? null;
 }
@@ -353,11 +344,15 @@ function scanRouteAnnotations(tree) {
     // `@RequestMapping` and `@FeignClient(path)` lands a different value in each.
     const prefixByTypeId = new Map();
     const feignPrefixByInterfaceId = new Map();
+    const httpExchangePrefixByTypeId = new Map();
     const methodRoutes = [];
     const requestLines = [];
+    const exchangeRoutes = [];
     // Interface `@RequestMapping` prefixes rank below `@FeignClient(path)`;
     // collect them and apply only after the FeignClient pass below.
     const interfaceRequestMappingPrefixes = [];
+    // `pushPrefix` (the de-duping accumulator) is shared from
+    // spring-consumer-shared.ts so Java and Kotlin build prefix maps identically.
     for (const { captures } of matches) {
         const annNode = captures.ann;
         const node = captures.node;
@@ -396,6 +391,22 @@ function scanRouteAnnotations(tree) {
                     });
                 }
             }
+            else if (EXCHANGE_ANNOTATION_TO_HTTP[ann]) {
+                // Spring 6 HTTP Interface `@(Get|...)Exchange` — the path lives in the
+                // `url` or `value` attribute (or positionally); other attributes
+                // (`accept`, `contentType`, …) are not routes.
+                if (keyNode && keyNode.text !== 'url' && keyNode.text !== 'value')
+                    continue;
+                const rawPath = unquoteLiteral(valueNode.text);
+                if (rawPath !== null) {
+                    exchangeRoutes.push({
+                        methodNode: node,
+                        methodName: captures.member?.text ?? null,
+                        httpMethod: EXCHANGE_ANNOTATION_TO_HTTP[ann],
+                        rawPath,
+                    });
+                }
+            }
             continue;
         }
         // Type-level (class or interface): a Spring `@RequestMapping` URL prefix, or
@@ -405,7 +416,7 @@ function scanRouteAnnotations(tree) {
                 continue;
             const prefix = unquoteLiteral(valueNode.text);
             if (prefix !== null) {
-                prefixByTypeId.set(node.id, prefix);
+                pushPrefix(prefixByTypeId, node.id, prefix);
                 if (node.type === 'interface_declaration') {
                     interfaceRequestMappingPrefixes.push({ id: node.id, prefix });
                 }
@@ -416,16 +427,33 @@ function scanRouteAnnotations(tree) {
             if (!keyNode || keyNode.text !== 'path')
                 continue;
             const prefix = unquoteLiteral(valueNode.text);
-            if (prefix !== null && !feignPrefixByInterfaceId.has(node.id)) {
-                feignPrefixByInterfaceId.set(node.id, prefix);
-            }
+            if (prefix !== null)
+                pushPrefix(feignPrefixByInterfaceId, node.id, prefix);
+        }
+        else if (ann === 'HttpExchange') {
+            // Spring HTTP Interface type-level prefix: the path lives in `url`/`value`
+            // (or positionally). Applies to its `@(Get|...)Exchange` consumer methods.
+            if (keyNode && keyNode.text !== 'url' && keyNode.text !== 'value')
+                continue;
+            const prefix = unquoteLiteral(valueNode.text);
+            if (prefix !== null)
+                pushPrefix(httpExchangePrefixByTypeId, node.id, prefix);
         }
     }
+    // `@RequestMapping` on a Feign interface is the fallback prefix, but only when
+    // the interface has no `@FeignClient(path)` of its own (path wins).
     for (const { id, prefix } of interfaceRequestMappingPrefixes) {
         if (!feignPrefixByInterfaceId.has(id))
-            feignPrefixByInterfaceId.set(id, prefix);
+            pushPrefix(feignPrefixByInterfaceId, id, prefix);
     }
-    return { prefixByTypeId, feignPrefixByInterfaceId, methodRoutes, requestLines };
+    return {
+        prefixByTypeId,
+        feignPrefixByInterfaceId,
+        httpExchangePrefixByTypeId,
+        methodRoutes,
+        requestLines,
+        exchangeRoutes,
+    };
 }
 function collectDirectMethods(typeNode) {
     const out = [];
@@ -486,7 +514,7 @@ function collectSpringTypes(filePath, tree) {
             filePath,
             kind,
             name: typeNameNode.text,
-            classPrefix: prefixByTypeId.get(typeNode.id) ?? '',
+            classPrefixes: prefixByTypeId.get(typeNode.id) ?? [],
             implementedInterfaces: kind === 'class' ? collectImplementedInterfaces(typeNode) : [],
             isController: kind === 'class' && hasAnnotation(typeNode, ['RestController', 'Controller']),
             methods,
@@ -494,63 +522,11 @@ function collectSpringTypes(filePath, tree) {
     }
     return out;
 }
+// The interface-based-controller inheritance algorithm is shared with kotlin.ts
+// (`scanSpringInheritanceProject`); this collects the `SharedSpringType` view and
+// delegates so Java and Kotlin emit byte-identical provider contracts.
 function scanSpringProject(files) {
-    const types = files.flatMap((file) => collectSpringTypes(file.filePath, file.tree));
-    const interfaceRoutes = new Map();
-    for (const type of types) {
-        if (type.kind !== 'interface')
-            continue;
-        if (interfaceRoutes.has(type.name)) {
-            interfaceRoutes.set(type.name, null);
-            continue;
-        }
-        const methodMap = new Map();
-        for (const method of type.methods) {
-            const routes = method.routes.map((route) => ({
-                method: route.method,
-                path: type.classPrefix ? joinPath(type.classPrefix, route.path) : route.path,
-                ownerPrefix: type.classPrefix,
-            }));
-            if (routes.length > 0)
-                methodMap.set(method.name, routes);
-        }
-        interfaceRoutes.set(type.name, methodMap);
-    }
-    const detectionsByFile = new Map();
-    for (const type of types) {
-        if (type.kind !== 'class' || !type.isController)
-            continue;
-        for (const method of type.methods) {
-            if (method.routes.length > 0)
-                continue;
-            const inheritedRoutes = type.implementedInterfaces.flatMap((interfaceName) => {
-                const routeMap = interfaceRoutes.get(interfaceName);
-                if (!routeMap)
-                    return [];
-                const routes = routeMap.get(method.name) ?? [];
-                return routes.map((route) => ({
-                    method: route.method,
-                    path: joinInheritedSpringPath(type.classPrefix, route.path, route.ownerPrefix),
-                }));
-            });
-            for (const route of inheritedRoutes) {
-                const detections = detectionsByFile.get(type.filePath) ?? [];
-                detections.push({
-                    role: 'provider',
-                    framework: 'spring',
-                    method: route.method,
-                    path: route.path,
-                    name: method.name,
-                    confidence: 0.8,
-                });
-                detectionsByFile.set(type.filePath, detections);
-            }
-        }
-    }
-    return [...detectionsByFile.entries()].map(([filePath, detections]) => ({
-        filePath,
-        detections,
-    }));
+    return scanSpringInheritanceProject(files.flatMap((file) => collectSpringTypes(file.filePath, file.tree)));
 }
 export const JAVA_HTTP_PLUGIN = {
     name: 'java-http',
@@ -561,7 +537,7 @@ export const JAVA_HTTP_PLUGIN = {
         // `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);
+        const { prefixByTypeId, feignPrefixByInterfaceId, httpExchangePrefixByTypeId, methodRoutes, requestLines, exchangeRoutes, } = 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
@@ -570,29 +546,35 @@ export const JAVA_HTTP_PLUGIN = {
         for (const route of methodRoutes) {
             const enclosingInterface = findEnclosingInterface(route.methodNode);
             if (enclosingInterface && hasAnnotation(enclosingInterface, 'FeignClient')) {
-                const prefix = feignPrefixByInterfaceId.get(enclosingInterface.id) ?? '';
+                const prefixes = feignPrefixByInterfaceId.get(enclosingInterface.id) ?? [''];
+                for (const prefix of prefixes) {
+                    out.push({
+                        role: 'consumer',
+                        framework: OPENFEIGN_FRAMEWORK,
+                        method: route.httpMethod,
+                        path: joinPath(prefix, route.rawPath),
+                        name: route.methodName,
+                        confidence: FEIGN_CONFIDENCE,
+                    });
+                }
+                continue;
+            }
+            const enclosingClass = findEnclosingClass(route.methodNode);
+            if (!enclosingClass)
+                continue;
+            // A multi-element class `@RequestMapping({"/a","/b"})` registers the method
+            // under each prefix — emit one provider per (prefix × this route).
+            const prefixes = prefixByTypeId.get(enclosingClass.id) ?? [''];
+            for (const prefix of prefixes) {
                 out.push({
-                    role: 'consumer',
-                    framework: 'openfeign',
+                    role: 'provider',
+                    framework: 'spring',
                     method: route.httpMethod,
                     path: joinPath(prefix, route.rawPath),
                     name: route.methodName,
-                    confidence: 0.7,
+                    confidence: 0.8,
                 });
-                continue;
             }
-            const enclosingClass = findEnclosingClass(route.methodNode);
-            if (!enclosingClass)
-                continue;
-            const prefix = prefixByTypeId.get(enclosingClass.id) ?? '';
-            out.push({
-                role: 'provider',
-                framework: 'spring',
-                method: route.httpMethod,
-                path: joinPath(prefix, route.rawPath),
-                name: route.methodName,
-                confidence: 0.8,
-            });
         }
         // Native OpenFeign `@RequestLine("METHOD /path")`. Method-level only and
         // always declared on an interface (Feign builds a proxy from the interface).
@@ -608,15 +590,36 @@ export const JAVA_HTTP_PLUGIN = {
             const enclosingInterface = findEnclosingInterface(requestLine.methodNode);
             if (!enclosingInterface)
                 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,
-            });
+            const prefixes = feignPrefixByInterfaceId.get(enclosingInterface.id) ?? [''];
+            for (const prefix of prefixes) {
+                out.push({
+                    role: 'consumer',
+                    framework: OPENFEIGN_FRAMEWORK,
+                    method: requestLine.parsed.method,
+                    path: joinPath(prefix, requestLine.parsed.path),
+                    name: requestLine.methodName,
+                    confidence: REQUEST_LINE_CONFIDENCE,
+                });
+            }
+        }
+        // ─── Consumers: Spring HTTP Interface @(Get|...)Exchange ────────
+        // Declarative client interfaces proxied by `HttpServiceProxyFactory`
+        // (over RestClient / WebClient / RestTemplate). Always a consumer — no
+        // provider ambiguity — with an optional type-level `@HttpExchange(url)`
+        // prefix. The verb comes from the annotation name (`@GetExchange` → GET).
+        for (const route of exchangeRoutes) {
+            const enclosing = findEnclosingInterface(route.methodNode) ?? findEnclosingClass(route.methodNode);
+            const prefixes = enclosing ? (httpExchangePrefixByTypeId.get(enclosing.id) ?? ['']) : [''];
+            for (const prefix of prefixes) {
+                out.push({
+                    role: 'consumer',
+                    framework: HTTP_INTERFACE_FRAMEWORK,
+                    method: route.httpMethod,
+                    path: joinPath(prefix, route.rawPath),
+                    name: route.methodName,
+                    confidence: EXCHANGE_CONFIDENCE,
+                });
+            }
         }
         // ─── Consumers: RestTemplate ────────────────────────────────────
         for (const match of runCompiledPatterns(REST_TEMPLATE_PATTERNS, tree)) {
@@ -657,9 +660,9 @@ export const JAVA_HTTP_PLUGIN = {
             });
         }
         // ─── Consumers: WebClient.get().uri("path") short form ─────────
-        // Source-scan only: receiver must be named exactly `webClient`.
-        // The real long-form chain `webClient.method(HttpMethod.X).uri("/x")`
-        // needs multi-hop chain analysis and is intentionally deferred.
+        // Source-scan only: receiver must be named exactly `webClient`. The
+        // long-form chain `webClient.method(HttpMethod.X).uri("/x")` is handled
+        // separately below by WEB_CLIENT_LONG_FORM_PATTERNS.
         for (const match of runCompiledPatterns(WEB_CLIENT_SHORT_FORM_PATTERNS, tree)) {
             const verbNode = match.captures.verb;
             const pathNode = match.captures.path;
@@ -680,6 +683,31 @@ export const JAVA_HTTP_PLUGIN = {
                 confidence: 0.7,
             });
         }
+        // ─── Consumers: WebClient.method(HttpMethod.X).uri("path") long form ─
+        // The verb is captured as the literal `HttpMethod.X` field name; gate it on
+        // the shared verb regex (HEAD/OPTIONS/TRACE excluded, matching the short
+        // form). The short-form query requires an empty inner argument list, so it
+        // cannot also fire on this chain — no double-emit.
+        for (const match of runCompiledPatterns(WEB_CLIENT_LONG_FORM_PATTERNS, tree)) {
+            const verbNode = match.captures.verb;
+            const pathNode = match.captures.path;
+            if (!verbNode || !pathNode)
+                continue;
+            const verbText = verbNode.text;
+            if (!WEB_CLIENT_LONG_VERB_RE.test(verbText))
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'spring-web-client',
+                method: verbText,
+                path,
+                name: null,
+                confidence: 0.7,
+            });
+        }
         // ─── Consumers: OkHttp Request.Builder().url("path") ────────────
         for (const match of runCompiledPatterns(OK_HTTP_PATTERNS, tree)) {
             const pathNode = match.captures.path;