gitnexus 1.6.6-rc.75 → 1.6.6-rc.76

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

@@ -1,18 +1,26 @@
 import { createRequire } from 'node:module';
 import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
 /**
- * Kotlin HTTP plugin (Spring providers).
+ * Kotlin HTTP plugin (Spring providers + consumers).
  *
- * Mirrors the Java plugin for Spring `@RequestMapping` class prefixes
- * and `@(Get|Post|...)Mapping` method annotations on Kotlin Spring
- * Boot controllers. Both positional shorthand (`@GetMapping("/x")`)
- * and named annotation arguments (`@GetMapping(value = "/x")` and
+ * **Providers** (#1849) — Spring `@RequestMapping` class prefixes and
+ * `@(Get|Post|...)Mapping` method annotations on Kotlin Spring Boot
+ * controllers. Both positional shorthand (`@GetMapping("/x")`) and
+ * named annotation arguments (`@GetMapping(value = "/x")` and
  * `@GetMapping(path = "/x")`) are supported.
  *
- * Consumer detection (RestTemplate / WebClient / OkHttp) is intentionally
- * out of scope for this plugin — Kotlin call-site ASTs are sufficiently
- * different from Java's `method_invocation` shape that they warrant a
- * separate, focused follow-up.
+ * **Consumers** (this PR) — three call-site patterns common in Kotlin
+ * Spring projects:
+ *
+ *   1. `restTemplate.getForObject("/x", ...)` and friends
+ *   2. `webClient.get().uri("/x")` (short form, 1 verb hop + 1 uri hop)
+ *   3. `Request.Builder().url("/x")` (OkHttp)
+ *
+ * The long-form `webClient.method(HttpMethod.X).uri("/y")` chain is
+ * intentionally deferred to a follow-up: it requires walk-up logic
+ * to recover the verb from a sibling `call_expression`, and we can
+ * land 80% of real-world Kotlin Spring consumer coverage with the
+ * three simpler patterns above.
  *
  * tree-sitter-kotlin (fwcd) AST shapes used here:
  *   class_declaration
@@ -26,6 +34,20 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
  *               string_literal
  *     type_identifier                     ← class name
  *
+ * Consumer call shape (Kotlin chains everything via `navigation_expression`):
+ *   call_expression                       ← outer `.uri("/x")` or `.url("/x")`
+ *     navigation_expression
+ *       call_expression                   ← inner `.get()` / `Request.Builder()` / `restTemplate.x`
+ *         navigation_expression
+ *           simple_identifier             ← receiver: `webClient` / `Request` / `restTemplate`
+ *           navigation_suffix             ← `.method` / `.Builder` / `.getForObject`
+ *         call_suffix (value_arguments)
+ *       navigation_suffix                 ← `.uri` / `.url`
+ *     call_suffix
+ *       value_arguments
+ *         value_argument
+ *           string_literal                ← the path
+ *
  * tree-sitter-kotlin is an optional npm dependency — when its native
  * binding is unavailable the plugin gracefully exports `null` and
  * `http-patterns/index.ts` skips registration for `.kt`/`.kts` files.
@@ -46,6 +68,34 @@ const METHOD_ANNOTATION_TO_HTTP = {
     DeleteMapping: 'DELETE',
     PatchMapping: 'PATCH',
 };
+/**
+ * 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',
+};
 /**
  * Build the plugin only if the Kotlin grammar is available. Compiling
  * the queries against a null grammar would throw at module load time
@@ -144,6 +194,127 @@ function buildKotlinPlugin(language) {
             },
         ],
     });
+    // ─── Consumer: Spring RestTemplate ────────────────────────────────────
+    // Kotlin call-site shape mirrors the Java plugin's
+    // `REST_TEMPLATE_PATTERNS`, but goes through tree-sitter-kotlin's
+    // `navigation_expression` instead of Java's `method_invocation`:
+    //
+    //   restTemplate.getForObject("/x", User::class.java)
+    //
+    // becomes
+    //
+    //   call_expression
+    //     navigation_expression
+    //       simple_identifier "restTemplate"
+    //       navigation_suffix → simple_identifier "getForObject"
+    //     call_suffix
+    //       value_arguments
+    //         value_argument . string_literal "/x"   ← captured
+    //         value_argument User::class.java
+    //
+    // The receiver name is constrained to `restTemplate` (#eq? @obj),
+    // matching the Java plugin's heuristic. This means a non-conventional
+    // field name (e.g. `userServiceTemplate`) will not be picked up;
+    // that's the same trade-off already accepted on the Java side.
+    const REST_TEMPLATE_PATTERNS = compilePatterns({
+        name: 'kotlin-rest-template',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (call_expression
+            (navigation_expression
+              (simple_identifier) @obj (#eq? @obj "restTemplate")
+              (navigation_suffix (simple_identifier) @method))
+            (call_suffix
+              (value_arguments . (value_argument . (string_literal) @path))))
+        `,
+            },
+        ],
+    });
+    // ─── Consumer: Spring WebClient (short form) ──────────────────────────
+    // Reactive WebClient exposes one-liner verb helpers:
+    //
+    //   webClient.get().uri("/x").retrieve().awaitBody<T>()
+    //   webClient.post().uri("/x")...
+    //
+    // The chain `webClient.get().uri("/x")` parses as two nested
+    // `call_expression` nodes — the OUTER call is `.uri("/x")` and the
+    // INNER call is `webClient.get()`. We anchor on the outer call and
+    // require:
+    //   - inner receiver is `webClient`
+    //   - inner suffix is one of the HTTP verbs (#match?)
+    //   - outer suffix is exactly `uri`
+    //   - outer call's first value_argument is a string literal
+    //
+    // The long-form `webClient.method(HttpMethod.GET).uri("/x")` chain
+    // uses an extra navigation hop and an enum field access — it's
+    // intentionally out of scope here (see file header).
+    const WEB_CLIENT_SHORT_PATTERNS = compilePatterns({
+        name: 'kotlin-web-client-short',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (call_expression
+            (navigation_expression
+              (call_expression
+                (navigation_expression
+                  (simple_identifier) @obj (#eq? @obj "webClient")
+                  (navigation_suffix
+                    (simple_identifier) @verb (#match? @verb "^(get|post|put|delete|patch)$")))
+                (call_suffix (value_arguments)))
+              (navigation_suffix (simple_identifier) @uri (#eq? @uri "uri")))
+            (call_suffix
+              (value_arguments . (value_argument . (string_literal) @path))))
+        `,
+            },
+        ],
+    });
+    // ─── Consumer: OkHttp Request.Builder().url("/x") ─────────────────────
+    // Kotlin parses `Request.Builder()` as a `call_expression` whose
+    // callee is a `navigation_expression` (Request → .Builder), NOT as
+    // Java's `object_creation_expression`. The chain `.url("/x")` then
+    // wraps that in another `call_expression`. The query mirrors Java's
+    // `OK_HTTP_PATTERNS` (java.ts) but adapts the node types.
+    //
+    // Receiver `Request` is constrained by name (#eq? @cls); a project
+    // that imports OkHttp's `Request` under an alias (`import okhttp3.Request as OkRequest`)
+    // would not be picked up — this matches the Java plugin's heuristic.
+    //
+    // **Known limitation — verb defaults to GET.** OkHttp encodes the
+    // verb on a *sibling* call further down the builder chain (e.g.
+    // `.post(body)` / `.get()` / `.delete()`), not on `.url(...)` itself.
+    // This query intentionally does not walk the chain to recover the
+    // verb — it emits `method: 'GET'` for every match, mirroring
+    // `java.ts:OK_HTTP_PATTERNS`. So a `Request.Builder().url("/x").post(body).build()`
+    // call becomes `http::GET::/x`, not `http::POST::/x`. This is the
+    // same trade-off Java has accepted; pinned by an anti-overreach
+    // test in `http-route-extractor.test.ts` so a future verb-walk
+    // implementation has to update this comment in lockstep.
+    const OK_HTTP_PATTERNS = compilePatterns({
+        name: 'kotlin-okhttp',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (call_expression
+            (navigation_expression
+              (call_expression
+                (navigation_expression
+                  (simple_identifier) @cls (#eq? @cls "Request")
+                  (navigation_suffix (simple_identifier) @builder (#eq? @builder "Builder")))
+                (call_suffix (value_arguments)))
+              (navigation_suffix (simple_identifier) @method (#eq? @method "url")))
+            (call_suffix
+              (value_arguments . (value_argument . (string_literal) @path))))
+        `,
+            },
+        ],
+    });
     /**
      * Find the nearest enclosing class_declaration ancestor for a node, or
      * null if the node is top-level. Mirrors the Java plugin's helper.
@@ -212,6 +383,65 @@ function buildKotlinPlugin(language) {
                     confidence: 0.8,
                 });
             }
+            // ─── Consumers: RestTemplate ────────────────────────────────────
+            for (const match of runCompiledPatterns(REST_TEMPLATE_PATTERNS, tree)) {
+                const methodNode = match.captures.method;
+                const pathNode = match.captures.path;
+                if (!methodNode || !pathNode)
+                    continue;
+                const httpMethod = REST_TEMPLATE_TO_HTTP[methodNode.text];
+                if (!httpMethod)
+                    continue;
+                const path = unquoteLiteral(pathNode.text);
+                if (path === null)
+                    continue;
+                out.push({
+                    role: 'consumer',
+                    framework: 'spring-rest-template',
+                    method: httpMethod,
+                    path,
+                    name: null,
+                    confidence: 0.7,
+                });
+            }
+            // ─── Consumers: WebClient short form (.get()/.post()/etc → .uri) ─
+            for (const match of runCompiledPatterns(WEB_CLIENT_SHORT_PATTERNS, tree)) {
+                const verbNode = match.captures.verb;
+                const pathNode = match.captures.path;
+                if (!verbNode || !pathNode)
+                    continue;
+                const httpMethod = WEB_CLIENT_SHORT_TO_HTTP[verbNode.text];
+                if (!httpMethod)
+                    continue;
+                const path = unquoteLiteral(pathNode.text);
+                if (path === null)
+                    continue;
+                out.push({
+                    role: 'consumer',
+                    framework: 'spring-web-client',
+                    method: httpMethod,
+                    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;
+                if (!pathNode)
+                    continue;
+                const path = unquoteLiteral(pathNode.text);
+                if (path === null)
+                    continue;
+                out.push({
+                    role: 'consumer',
+                    framework: 'okhttp',
+                    method: 'GET',
+                    path,
+                    name: null,
+                    confidence: 0.7,
+                });
+            }
             return out;
         },
     };

package/package.json

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