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

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

@@ -1,5 +1,7 @@
 import { requireVendoredGrammar } from '../../../tree-sitter/vendored-grammars.js';
 import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
+import { METHOD_ANNOTATION_TO_HTTP, 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';
 /**
  * Kotlin HTTP plugin (Spring providers + consumers).
  *
@@ -65,50 +67,34 @@ try {
 catch {
     Kotlin = null;
 }
-const METHOD_ANNOTATION_TO_HTTP = {
-    GetMapping: 'GET',
-    PostMapping: 'POST',
-    PutMapping: 'PUT',
-    DeleteMapping: 'DELETE',
-    PatchMapping: 'PATCH',
-};
+// The Spring `@(Get|...)Mapping` verb map, RestTemplate / WebClient short-form
+// verb maps, the `@(Get|...)Exchange` verb map, `joinPath`, `parseRequestLine`,
+// and the shared confidence/framework constants are imported from
+// `spring-consumer-shared.ts` / `spring-shared.ts` so the Kotlin and Java
+// plugins emit identical contract IDs.
+// The WebClient long-form verb gate (`WEB_CLIENT_LONG_VERB_RE`) is imported from
+// `spring-consumer-shared.ts` so the Java and Kotlin long-form scans accept the
+// same verb set (HEAD/OPTIONS/TRACE excluded, matching the short form).
+// The de-duping prefix accumulator (`pushPrefix`) is imported from
+// `spring-consumer-shared.ts` so the Java and Kotlin plugins build their
+// per-declaration prefix maps identically.
 /**
- * RestTemplate method-name → HTTP verb. Mirrors the Java plugin's
- * `REST_TEMPLATE_TO_HTTP` (java.ts) so a polyglot repo emits the
- * same contract IDs from .java and .kt sources.
- */
-const REST_TEMPLATE_TO_HTTP = {
-    getForObject: 'GET',
-    getForEntity: 'GET',
-    postForObject: 'POST',
-    postForEntity: 'POST',
-    put: 'PUT',
-    delete: 'DELETE',
-    patchForObject: 'PATCH',
-};
-/**
- * WebClient short-form verb → HTTP verb. The reactive WebClient API
- * exposes `.get()`, `.post()`, `.put()`, `.delete()`, `.patch()` as
- * one-liners that return a `RequestHeadersUriSpec` whose `.uri(...)`
- * carries the path. We capture both pieces in a single query (see
- * `WEB_CLIENT_SHORT_PATTERNS` below) and translate the verb here.
- */
-const WEB_CLIENT_SHORT_TO_HTTP = {
-    get: 'GET',
-    post: 'POST',
-    put: 'PUT',
-    delete: 'DELETE',
-    patch: 'PATCH',
-};
-/**
- * Allowed HTTP verbs for the WebClient long-form path
- * `webClient.method(HttpMethod.X).uri("/y")`. Compiled once at module
- * load (instead of inside the scan loop) per maintainer feedback on
- * PR #1884. Mirrors the keys of `WEB_CLIENT_SHORT_TO_HTTP` above —
- * keeping HEAD/OPTIONS/TRACE intentionally excluded for symmetry
- * with the short form and the Java plugin.
+ * Tree-sitter sub-pattern for the Kotlin `arrayOf("/a", "/b")` annotation-array
+ * form, capturing each element string under `cap` (`@prefix` or `@path`).
+ *
+ * Kept as a DEDICATED query fragment embedded in its own pattern — NEVER as an
+ * arm of the `[(string_literal) (collection_literal …)]` alternation. The
+ * `#eq? @arrayOf "arrayOf"` predicate, sharing a single alternation bucket with
+ * the string/collection arms, would evaluate FALSE for those arms (where
+ * `@arrayOf` is absent) and silently drop them — the tree-sitter 0.21.x hazard
+ * documented in `java.ts`. tree-sitter yields one match per `arrayOf` element,
+ * so multi-element arrays accumulate through the same loops as `collection_literal`
+ * (verified by AST probe). The `arrayOf` callee constraint keeps unrelated calls
+ * (`buildPath("/x")`) from matching.
  */
-const WEB_CLIENT_LONG_VERB_RE = /^(GET|POST|PUT|DELETE|PATCH)$/;
+const arrayOfArg = (cap) => `(call_expression
+  (simple_identifier) @arrayOf (#eq? @arrayOf "arrayOf")
+  (call_suffix (value_arguments (value_argument (string_literal) ${cap}))))`;
 /**
  * Build the plugin only if the Kotlin grammar is available. Compiling
  * the queries against a null grammar would throw at module load time
@@ -148,7 +134,7 @@ function buildKotlinPlugin(language) {
                 (constructor_invocation
                   (user_type (type_identifier) @ann (#eq? @ann "RequestMapping"))
                   (value_arguments
-                    (value_argument . (string_literal) @prefix)))))
+                    (value_argument . [(string_literal) @prefix (collection_literal (string_literal) @prefix)])))))
             (type_identifier) @cls) @class
         `,
             },
@@ -163,7 +149,35 @@ function buildKotlinPlugin(language) {
                   (value_arguments
                     (value_argument
                       (simple_identifier) @key (#match? @key "^(path|value)$")
-                      (string_literal) @prefix)))))
+                      [(string_literal) @prefix (collection_literal (string_literal) @prefix)])))))
+            (type_identifier) @cls) @class
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (class_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "RequestMapping"))
+                  (value_arguments
+                    (value_argument . ${arrayOfArg('@prefix')})))))
+            (type_identifier) @cls) @class
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (class_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "RequestMapping"))
+                  (value_arguments
+                    (value_argument
+                      (simple_identifier) @key (#match? @key "^(path|value)$")
+                      ${arrayOfArg('@prefix')})))))
             (type_identifier) @cls) @class
         `,
             },
@@ -186,7 +200,35 @@ function buildKotlinPlugin(language) {
                 (constructor_invocation
                   (user_type (type_identifier) @ann (#match? @ann "^(Get|Post|Put|Delete|Patch)Mapping$"))
                   (value_arguments
-                    (value_argument . (string_literal) @path)))))
+                    (value_argument . [(string_literal) @path (collection_literal (string_literal) @path)])))))
+            (simple_identifier) @method_name) @method
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (function_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#match? @ann "^(Get|Post|Put|Delete|Patch)Mapping$"))
+                  (value_arguments
+                    (value_argument
+                      (simple_identifier) @key (#match? @key "^(path|value)$")
+                      [(string_literal) @path (collection_literal (string_literal) @path)])))))
+            (simple_identifier) @method_name) @method
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (function_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#match? @ann "^(Get|Post|Put|Delete|Patch)Mapping$"))
+                  (value_arguments
+                    (value_argument . ${arrayOfArg('@path')})))))
             (simple_identifier) @method_name) @method
         `,
             },
@@ -201,7 +243,7 @@ function buildKotlinPlugin(language) {
                   (value_arguments
                     (value_argument
                       (simple_identifier) @key (#match? @key "^(path|value)$")
-                      (string_literal) @path)))))
+                      ${arrayOfArg('@path')})))))
             (simple_identifier) @method_name) @method
         `,
             },
@@ -381,32 +423,355 @@ function buildKotlinPlugin(language) {
             },
         ],
     });
+    // ─── Consumer (OpenFeign): @FeignClient interface marker + path prefix ─
+    // A `@FeignClient` interface's `@(Get|...)Mapping` methods describe OUTBOUND
+    // calls (consumers), not routes the service serves. Pattern 1 marks the
+    // interface; pattern 2 captures its optional `path = "/prefix"` (the
+    // `name`/`value`/`url` attributes identify the remote service, not a path).
+    // In tree-sitter-kotlin an `interface` is a `class_declaration`, so the
+    // method-route loop reclassifies @*Mapping methods whose enclosing
+    // class_declaration is in `feignClassIds` (see scan()).
+    const SPRING_FEIGN_CLIENT_PATTERNS = compilePatterns({
+        name: 'kotlin-spring-feign-client',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (class_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "FeignClient")))))) @class
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (class_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "FeignClient"))
+                  (value_arguments
+                    (value_argument
+                      (simple_identifier) @key (#eq? @key "path")
+                      [(string_literal) @prefix (collection_literal (string_literal) @prefix)])))))) @class
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (class_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "FeignClient"))
+                  (value_arguments
+                    (value_argument
+                      (simple_identifier) @key (#eq? @key "path")
+                      ${arrayOfArg('@prefix')})))))) @class
+        `,
+            },
+        ],
+    });
+    // ─── Consumer: Spring 6 HTTP Interface @(Get|...)Exchange ─────────────
+    // Declarative client interfaces proxied by HttpServiceProxyFactory (over
+    // RestClient / WebClient / RestTemplate). The path lives in `url`/`value`
+    // (named) or positionally. Always a consumer — no provider ambiguity.
+    const SPRING_EXCHANGE_PATTERNS = compilePatterns({
+        name: 'kotlin-spring-http-exchange',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (function_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#match? @ann "^(Get|Post|Put|Delete|Patch)Exchange$"))
+                  (value_arguments
+                    (value_argument . [(string_literal) @path (collection_literal (string_literal) @path)])))))
+            (simple_identifier) @method_name) @method
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (function_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#match? @ann "^(Get|Post|Put|Delete|Patch)Exchange$"))
+                  (value_arguments
+                    (value_argument
+                      (simple_identifier) @key (#match? @key "^(url|value)$")
+                      [(string_literal) @path (collection_literal (string_literal) @path)])))))
+            (simple_identifier) @method_name) @method
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (function_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#match? @ann "^(Get|Post|Put|Delete|Patch)Exchange$"))
+                  (value_arguments
+                    (value_argument . ${arrayOfArg('@path')})))))
+            (simple_identifier) @method_name) @method
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (function_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#match? @ann "^(Get|Post|Put|Delete|Patch)Exchange$"))
+                  (value_arguments
+                    (value_argument
+                      (simple_identifier) @key (#match? @key "^(url|value)$")
+                      ${arrayOfArg('@path')})))))
+            (simple_identifier) @method_name) @method
+        `,
+            },
+        ],
+    });
+    // ─── Consumer: HTTP Interface type-level @HttpExchange(url) prefix ─────
+    const SPRING_HTTP_EXCHANGE_CLASS_PATTERNS = compilePatterns({
+        name: 'kotlin-spring-http-exchange-class',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (class_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "HttpExchange"))
+                  (value_arguments
+                    (value_argument . [(string_literal) @prefix (collection_literal (string_literal) @prefix)])))))) @class
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (class_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "HttpExchange"))
+                  (value_arguments
+                    (value_argument
+                      (simple_identifier) @key (#match? @key "^(url|value)$")
+                      [(string_literal) @prefix (collection_literal (string_literal) @prefix)])))))) @class
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (class_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "HttpExchange"))
+                  (value_arguments
+                    (value_argument . ${arrayOfArg('@prefix')})))))) @class
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (class_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "HttpExchange"))
+                  (value_arguments
+                    (value_argument
+                      (simple_identifier) @key (#match? @key "^(url|value)$")
+                      ${arrayOfArg('@prefix')})))))) @class
+        `,
+            },
+        ],
+    });
+    // ─── Consumer: OpenFeign native @RequestLine("VERB /path") ────────────
+    // Two patterns mirror the positional vs named split. java.ts accepts the
+    // named `value` argument (java.ts:442 drops any non-`value` key); the
+    // positional pattern's `.` anchor only matches when the string literal is the
+    // first argument, so the named form needs its own pattern. Constraining
+    // `#eq? @key "value"` keeps non-`value` keys (`name`, etc.) dropped — Java
+    // parity, just enforced in the query rather than the JS loop.
+    const SPRING_REQUEST_LINE_PATTERNS = compilePatterns({
+        name: 'kotlin-spring-request-line',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (function_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "RequestLine"))
+                  (value_arguments
+                    (value_argument . (string_literal) @value)))))
+            (simple_identifier) @method_name) @method
+        `,
+            },
+            {
+                meta: {},
+                query: `
+          (function_declaration
+            (modifiers
+              (annotation
+                (constructor_invocation
+                  (user_type (type_identifier) @ann (#eq? @ann "RequestLine"))
+                  (value_arguments
+                    (value_argument
+                      (simple_identifier) @key (#eq? @key "value")
+                      (string_literal) @value)))))
+            (simple_identifier) @method_name) @method
+        `,
+            },
+        ],
+    });
+    // ─── Provider via interface inheritance (Spring interface-based controller) ─
+    // Pattern: `@RestController class X(...) : XApi` where the route annotations
+    // live on the `XApi` interface and the controller's `override fun` carries
+    // none. Java resolves this in `scanProject` (scanSpringProject); this is the
+    // Kotlin port. tree-sitter-kotlin models BOTH class and interface as
+    // `class_declaration`; the `interface` keyword token distinguishes them.
+    const KOTLIN_TYPE_DECLARATION_PATTERNS = compilePatterns({
+        name: 'kotlin-type-declaration',
+        language,
+        patterns: [{ meta: {}, query: `(class_declaration (type_identifier) @name) @type` }],
+    });
+    /** A `class_declaration` is an interface when it carries the `interface` keyword token. */
+    const isKotlinInterface = (node) => node.children.some((c) => c.type === 'interface');
+    /** Resolve an `annotation` node's simple name: `@Foo` / `@Foo(...)` / `@a.b.Foo` → "Foo". */
+    const kotlinAnnotationName = (annotation) => {
+        const direct = annotation.namedChildren.find((c) => c.type === 'user_type');
+        const ctor = annotation.namedChildren.find((c) => c.type === 'constructor_invocation');
+        const userType = direct ?? ctor?.namedChildren.find((c) => c.type === 'user_type');
+        // A fully-qualified annotation (`@a.b.Foo`) parses to a `user_type` carrying
+        // one `type_identifier` per dotted segment (`a`, `b`, `Foo`); the trailing
+        // one is the simple name. Taking the FIRST would resolve `@org…RestController`
+        // to "org" and miss the controller.
+        const idents = userType?.namedChildren.filter((c) => c.type === 'type_identifier') ?? [];
+        const ident = idents.at(-1);
+        return ident ? ident.text : null;
+    };
     /**
-     * Find the nearest enclosing class_declaration ancestor for a node, or
-     * null if the node is top-level. Mirrors the Java plugin's helper.
+     * Whether a `class_declaration` is a Spring `@RestController` / `@Controller`.
+     * All forms attach under `modifiers` as an `annotation` (confirmed against
+     * tree-sitter-kotlin fwcd): the bare `@RestController`, the common
+     * `@RestController @RequestMapping("/x")` pair, AND the arg-form
+     * `@RestController("beanName")` — the last parses to an `annotation` whose
+     * child is a `constructor_invocation` (NOT a detached sibling), which
+     * `kotlinAnnotationName` reads. A single pass over `modifiers` covers them all.
      */
-    function findEnclosingClass(node) {
-        let cur = node.parent;
-        while (cur) {
-            if (cur.type === 'class_declaration')
-                return cur;
-            cur = cur.parent;
+    const CONTROLLER_ANNOTATIONS = new Set(['RestController', 'Controller']);
+    const kotlinClassIsController = (typeNode) => {
+        const modifiers = typeNode.namedChildren.find((c) => c.type === 'modifiers');
+        for (const ann of modifiers?.namedChildren ?? []) {
+            if (ann.type !== 'annotation')
+                continue;
+            const name = kotlinAnnotationName(ann);
+            if (name && CONTROLLER_ANNOTATIONS.has(name))
+                return true;
         }
-        return null;
-    }
-    /**
-     * Join a class-level prefix and a method-level path. Identical
-     * semantics to the Java plugin: strip leading/trailing slashes on
-     * the prefix, strip leading slashes on the method path, ensure a
-     * single slash between them.
-     */
-    function joinPath(prefix, methodPath) {
-        const cleanPrefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
-        const cleanSub = methodPath.replace(/^\/+/, '');
-        if (!cleanPrefix)
-            return `/${cleanSub}`;
-        return `/${cleanPrefix}/${cleanSub}`;
-    }
+        return false;
+    };
+    /** Supertype names from `: A, B` (`delegation_specifier` → `user_type` → `type_identifier`). */
+    const collectKotlinSupertypes = (node) => {
+        const out = [];
+        for (const child of node.namedChildren) {
+            if (child.type !== 'delegation_specifier')
+                continue;
+            const userType = child.namedChildren.find((c) => c.type === 'user_type');
+            // FQN supertype (`: a.b.Api`) → one `type_identifier` per segment; the
+            // trailing one is the simple name (taking the first would yield "a").
+            const idents = userType?.namedChildren.filter((c) => c.type === 'type_identifier') ?? [];
+            const ident = idents.at(-1);
+            if (ident)
+                out.push(ident.text);
+        }
+        return out;
+    };
+    /** Direct `function_declaration` members of a type (no descent into nested types). */
+    const collectKotlinDirectMethods = (typeNode) => {
+        const body = typeNode.namedChildren.find((c) => c.type === 'class_body');
+        if (!body)
+            return [];
+        return body.namedChildren.filter((c) => c.type === 'function_declaration');
+    };
+    const kotlinFunctionName = (fn) => fn.namedChildren.find((c) => c.type === 'simple_identifier')?.text ?? null;
+    const collectKotlinSpringTypes = (filePath, tree) => {
+        // Class-level @RequestMapping prefixes (reuse the provider class-prefix query).
+        const prefixByClassId = new Map();
+        for (const match of runCompiledPatterns(SPRING_CLASS_PREFIX_PATTERNS, tree)) {
+            const prefixNode = match.captures.prefix;
+            const classNode = match.captures.class;
+            if (!prefixNode || !classNode)
+                continue;
+            const prefix = unquoteLiteral(prefixNode.text);
+            if (prefix !== null)
+                pushPrefix(prefixByClassId, classNode.id, prefix);
+        }
+        // Method @(Get|...)Mapping routes keyed by the function_declaration node id.
+        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)
+                continue;
+            const rawPath = unquoteLiteral(pathNode.text);
+            if (rawPath === null)
+                continue;
+            const arr = routesByMethodId.get(methodNode.id) ?? [];
+            arr.push({ method: httpMethod, path: rawPath });
+            routesByMethodId.set(methodNode.id, arr);
+        }
+        const out = [];
+        for (const match of runCompiledPatterns(KOTLIN_TYPE_DECLARATION_PATTERNS, tree)) {
+            const typeNode = match.captures.type;
+            const nameNode = match.captures.name;
+            if (!typeNode || !nameNode)
+                continue;
+            const kind = isKotlinInterface(typeNode) ? 'interface' : 'class';
+            const methods = collectKotlinDirectMethods(typeNode)
+                .map((fn) => ({ name: kotlinFunctionName(fn), routes: routesByMethodId.get(fn.id) ?? [] }))
+                .filter((m) => {
+                return m.name !== null;
+            });
+            out.push({
+                filePath,
+                kind,
+                name: nameNode.text,
+                isController: kind === 'class' ? kotlinClassIsController(typeNode) : false,
+                classPrefixes: prefixByClassId.get(typeNode.id) ?? [],
+                implementedInterfaces: kind === 'class' ? collectKotlinSupertypes(typeNode) : [],
+                methods,
+            });
+        }
+        return out;
+    };
+    // The interface-based-controller inheritance algorithm is shared with java.ts
+    // (`scanSpringInheritanceProject`); this collects the language-specific
+    // `SharedSpringType` view and delegates. kotlinClassIsController handles every
+    // controller form (bare, paired, and the arg-form `@RestController("bean")`)
+    // via the `modifiers` `annotation`/`constructor_invocation` shape.
+    const scanKotlinProject = (files) => scanSpringInheritanceProject(files.flatMap((f) => collectKotlinSpringTypes(f.filePath, f.tree)));
     return {
         name: 'kotlin-http',
         language,
@@ -421,9 +786,38 @@ function buildKotlinPlugin(language) {
                     continue;
                 const prefix = unquoteLiteral(prefixNode.text);
                 if (prefix !== null)
-                    prefixByClassId.set(classNode.id, prefix);
+                    pushPrefix(prefixByClassId, classNode.id, prefix);
             }
-            // ─── Method routes ──────────────────────────────────────────────
+            // ─── OpenFeign client interfaces + HTTP Interface type prefixes ──
+            // In tree-sitter-kotlin an `interface` is a `class_declaration`, so a
+            // `@FeignClient` interface's @(Get|...)Mapping methods would otherwise be
+            // mis-emitted as providers. Collect the FeignClient class ids (and their
+            // optional `path` prefix) so the method-route loop can reclassify them.
+            const feignClassIds = new Set();
+            const feignPrefixByClassId = new Map();
+            for (const match of runCompiledPatterns(SPRING_FEIGN_CLIENT_PATTERNS, tree)) {
+                const classNode = match.captures.class;
+                if (!classNode)
+                    continue;
+                feignClassIds.add(classNode.id);
+                const prefixNode = match.captures.prefix;
+                if (prefixNode) {
+                    const prefix = unquoteLiteral(prefixNode.text);
+                    if (prefix !== null)
+                        pushPrefix(feignPrefixByClassId, classNode.id, prefix);
+                }
+            }
+            const httpExchangePrefixByClassId = new Map();
+            for (const match of runCompiledPatterns(SPRING_HTTP_EXCHANGE_CLASS_PATTERNS, tree)) {
+                const classNode = match.captures.class;
+                const prefixNode = match.captures.prefix;
+                if (!classNode || !prefixNode)
+                    continue;
+                const prefix = unquoteLiteral(prefixNode.text);
+                if (prefix !== null)
+                    pushPrefix(httpExchangePrefixByClassId, classNode.id, prefix);
+            }
+            // ─── Method routes (Spring providers) + OpenFeign consumers ─────
             for (const match of runCompiledPatterns(SPRING_METHOD_ROUTE_PATTERNS, tree)) {
                 const annNode = match.captures.ann;
                 const pathNode = match.captures.path;
@@ -438,16 +832,46 @@ function buildKotlinPlugin(language) {
                 if (rawPath === null)
                     continue;
                 const enclosingClass = findEnclosingClass(methodNode);
-                const prefix = enclosingClass ? (prefixByClassId.get(enclosingClass.id) ?? '') : '';
-                const fullPath = joinPath(prefix, rawPath);
-                out.push({
-                    role: 'provider',
-                    framework: 'spring',
-                    method: httpMethod,
-                    path: fullPath,
-                    name: nameNode?.text ?? null,
-                    confidence: 0.8,
-                });
+                // A @(Get|...)Mapping inside a @FeignClient interface is an OpenFeign
+                // consumer (a remote call), not a route this service serves.
+                if (enclosingClass && feignClassIds.has(enclosingClass.id)) {
+                    // @FeignClient(path) wins over @RequestMapping; a multi-element prefix
+                    // yields one consumer per (prefix × this route).
+                    const prefixes = feignPrefixByClassId.get(enclosingClass.id) ??
+                        prefixByClassId.get(enclosingClass.id) ?? [''];
+                    for (const prefix of prefixes) {
+                        out.push({
+                            role: 'consumer',
+                            framework: OPENFEIGN_FRAMEWORK,
+                            method: httpMethod,
+                            path: joinPath(prefix, rawPath),
+                            name: nameNode?.text ?? null,
+                            confidence: FEIGN_CONFIDENCE,
+                        });
+                    }
+                    continue;
+                }
+                // A @(Get|...)Mapping on a (non-Feign) interface declares a route
+                // *contract*, not a route this service serves — the implementing
+                // @RestController is the provider, emitted via scanProject's interface
+                // inheritance. Java drops these implicitly (findEnclosingClass returns
+                // null for an interface_declaration); tree-sitter-kotlin models an
+                // interface as a class_declaration, so skip it explicitly here.
+                if (enclosingClass && isKotlinInterface(enclosingClass))
+                    continue;
+                // A multi-element class `@RequestMapping(["/a","/b"])` registers the method
+                // under each prefix — emit one provider per (prefix × this route).
+                const prefixes = enclosingClass ? (prefixByClassId.get(enclosingClass.id) ?? ['']) : [''];
+                for (const prefix of prefixes) {
+                    out.push({
+                        role: 'provider',
+                        framework: 'spring',
+                        method: httpMethod,
+                        path: joinPath(prefix, rawPath),
+                        name: nameNode?.text ?? null,
+                        confidence: 0.8,
+                    });
+                }
             }
             // ─── Consumers: RestTemplate ────────────────────────────────────
             for (const match of runCompiledPatterns(REST_TEMPLATE_PATTERNS, tree)) {
@@ -537,8 +961,78 @@ function buildKotlinPlugin(language) {
                     confidence: 0.7,
                 });
             }
+            // ─── Consumers: Spring HTTP Interface @(Get|...)Exchange ────────
+            for (const match of runCompiledPatterns(SPRING_EXCHANGE_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 = EXCHANGE_ANNOTATION_TO_HTTP[annNode.text];
+                if (!httpMethod)
+                    continue;
+                const rawPath = unquoteLiteral(pathNode.text);
+                if (rawPath === null)
+                    continue;
+                const enclosingClass = findEnclosingClass(methodNode);
+                const prefixes = enclosingClass
+                    ? (httpExchangePrefixByClassId.get(enclosingClass.id) ?? [''])
+                    : [''];
+                for (const prefix of prefixes) {
+                    out.push({
+                        role: 'consumer',
+                        framework: HTTP_INTERFACE_FRAMEWORK,
+                        method: httpMethod,
+                        path: joinPath(prefix, rawPath),
+                        name: nameNode?.text ?? null,
+                        confidence: EXCHANGE_CONFIDENCE,
+                    });
+                }
+            }
+            // ─── Consumers: OpenFeign native @RequestLine("VERB /path") ─────
+            // Method-level only and always declared on an interface — Feign builds its
+            // proxy from the interface, so a `@RequestLine` on a concrete class is not
+            // a client call. We do NOT require an enclosing `@FeignClient` (core Feign
+            // uses `@RequestLine` with `Feign.builder()`, not Spring Cloud's
+            // `@FeignClient`); the `RequestLine` name plus the structural interface
+            // check keep false positives away. Mirrors java.ts's `findEnclosingInterface`
+            // gate — in tree-sitter-kotlin an interface is a `class_declaration`, so we
+            // test the `interface` keyword via isKotlinInterface.
+            for (const match of runCompiledPatterns(SPRING_REQUEST_LINE_PATTERNS, tree)) {
+                const valueNode = match.captures.value;
+                const nameNode = match.captures.method_name;
+                const methodNode = match.captures.method;
+                if (!valueNode || !methodNode)
+                    continue;
+                const raw = unquoteLiteral(valueNode.text);
+                const parsed = raw !== null ? parseRequestLine(raw) : null;
+                if (!parsed)
+                    continue;
+                const enclosingClass = findEnclosingClass(methodNode);
+                if (!enclosingClass || !isKotlinInterface(enclosingClass))
+                    continue;
+                // Mirror java.ts (which pre-merges the @RequestMapping fallback into
+                // feignPrefixByInterfaceId, "path wins"): @FeignClient(path) wins, else
+                // the interface's class-level @RequestMapping prefix, else none. Without
+                // the prefixByClassId fallback Kotlin dropped the class prefix that Java
+                // applies — the same fallback chain the @GetMapping-in-Feign path uses above.
+                const prefixes = feignPrefixByClassId.get(enclosingClass.id) ??
+                    prefixByClassId.get(enclosingClass.id) ?? [''];
+                for (const prefix of prefixes) {
+                    out.push({
+                        role: 'consumer',
+                        framework: OPENFEIGN_FRAMEWORK,
+                        method: parsed.method,
+                        path: joinPath(prefix, parsed.path),
+                        name: nameNode?.text ?? null,
+                        confidence: REQUEST_LINE_CONFIDENCE,
+                    });
+                }
+            }
             return out;
         },
+        scanProject: scanKotlinProject,
     };
 }
 /**