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

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

@@ -3,6 +3,7 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
 /**
  * Python HTTP plugin. Handles:
  *   - FastAPI `@app.get("/path")` provider decorators
+ *   - Django `path("route/", view)` provider calls
  *   - `requests.get/post/...("url")` consumer calls
  *   - Generic `requests.request("METHOD", "url")` consumer calls
  *   - `httpx.AsyncClient` instances calling `.get/.post/...("url")`, including
@@ -41,6 +42,13 @@ const FASTAPI_APP_PATTERNS = compilePatterns({
         },
     ],
 });
+// NOTE: Django providers are NOT extracted by this per-file source scan.
+// A standalone scan of `path()`/`re_path()` calls cannot tell a route from an
+// `include()` mount point, nor compose the include() prefix across files, so it
+// emitted bogus fragments (e.g. `/api` for a mount and `/items` un-prefixed
+// instead of the real `/api/items`). Django provider contracts come from the
+// graph Route nodes, which the ingestion route extractor builds with the
+// includes already composed.
 const FASTAPI_ROUTER_PATTERNS = compilePatterns({
     name: 'python-fastapi-router',
     language: Python,
@@ -168,7 +176,7 @@ const FROM_IMPORT_MODULE_PATTERNS = compilePatterns({
         },
     ],
 });
-// ─── Consumer: requests.get/post/... ──────────────────────────────────
+// ─── Consumer: requests.get/post/...("literal") ──────────────────────
 const REQUESTS_VERB_PATTERNS = compilePatterns({
     name: 'python-requests-verb',
     language: Python,
@@ -185,6 +193,26 @@ const REQUESTS_VERB_PATTERNS = compilePatterns({
         },
     ],
 });
+// ─── Consumer: requests.get/post/...(url=VALUE) keyword ──────────────
+const REQUESTS_KEYWORD_URL_PATTERNS = compilePatterns({
+    name: 'python-requests-keyword-url',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call
+          function: (attribute
+            object: (identifier) @obj (#eq? @obj "requests")
+            attribute: (identifier) @method (#match? @method "^(get|post|put|delete|patch)$"))
+          arguments: (argument_list
+            (keyword_argument
+              name: (identifier) @kw (#eq? @kw "url")
+              value: (string) @path)))
+      `,
+        },
+    ],
+});
 // ─── Consumer: requests.request("METHOD", "url") ─────────────────────
 const REQUESTS_GENERIC_PATTERNS = compilePatterns({
     name: 'python-requests-generic',
@@ -202,6 +230,97 @@ const REQUESTS_GENERIC_PATTERNS = compilePatterns({
         },
     ],
 });
+// ─── Consumer: wrapper classes with uri= or url= keyword argument ──────
+// Common pattern: wrapper classes like RequestFetch that accept URL via
+// named argument instead of positional argument:
+//   obj.fetch(uri="api/v1/camera/info/")
+//   obj.get(url="api/v1/camera/info/")
+//   obj.post(uri="api/v1/config/update/")
+const WRAPPER_URI_PATTERNS = compilePatterns({
+    name: 'python-http-wrapper-uri',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            // Match any method call where keyword argument is `uri` or `url`
+            query: `
+        (call
+          function: (attribute
+            object: (_) @client
+            attribute: (identifier) @method)
+          arguments: (argument_list
+            (keyword_argument
+              name: (identifier) @kw (#match? @kw "^(uri|url)$")
+              value: (string) @path)))
+      `,
+        },
+    ],
+});
+// Map wrapper method names to HTTP verbs
+const WRAPPER_METHOD_TO_HTTP = {
+    get: 'GET',
+    post: 'POST',
+    put: 'PUT',
+    delete: 'DELETE',
+    patch: 'PATCH',
+    fetch: 'GET',
+    request: 'GET',
+};
+// ─── Variable-to-string propagation patterns ─────────────────────────
+// Many repos assign URL paths to local variables then pass them as
+// keyword arguments: uri = "api/v1/endpoint/"; obj.fetch(uri=uri, body)
+// These patterns + buildLocalStringMap resolve the variable → literal chain.
+// Track local string constants: uri = "api/v1/endpoint/"
+const LOCAL_STRING_ASSIGNMENTS = compilePatterns({
+    name: 'python-local-string-assign',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (assignment
+          left: (identifier) @var_name
+          right: (string) @var_value)
+      `,
+        },
+    ],
+});
+// Match method calls where uri=/url= value is a variable that was previously
+// assigned a string literal
+const WRAPPER_URI_VAR_PATTERNS = compilePatterns({
+    name: 'python-http-wrapper-uri-var',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call
+          function: (attribute
+            object: (_) @client
+            attribute: (identifier) @method)
+          arguments: (argument_list
+            (keyword_argument
+              name: (identifier) @kw (#match? @kw "^(uri|url)$")
+              value: (identifier) @path_var)))
+      `,
+        },
+    ],
+});
+// Pre-scan: collect local string assignments (uri = "api/v1/endpoint/")
+function buildLocalStringMap(tree) {
+    const map = new Map();
+    for (const match of runCompiledPatterns(LOCAL_STRING_ASSIGNMENTS, tree)) {
+        const varNode = match.captures.var_name;
+        const valNode = match.captures.var_value;
+        if (!varNode || !valNode)
+            continue;
+        const val = unquoteLiteral(valNode.text);
+        if (val === null)
+            continue;
+        map.set(varNode.text, val);
+    }
+    return map;
+}
 // ─── Consumer: httpx.AsyncClient assignments ────────────────────────
 // Module-scope clients are only matched
 // at module scope; calls inside functions require a function/class-local tracked
@@ -734,6 +853,9 @@ export const PYTHON_HTTP_PLUGIN = {
                 confidence: 0.8,
             });
         }
+        // Django providers come from the graph Route nodes (includes composed by
+        // the ingestion route extractor), not a per-file source scan — see the note
+        // at the top of this file.
         // Providers: FastAPI @router.<verb>("/path") — must be joined
         // with the prefix(es) declared at the include_router site. When
         // no prefix is found we still emit the unprefixed path so this
@@ -791,6 +913,24 @@ export const PYTHON_HTTP_PLUGIN = {
                 confidence: 0.7,
             });
         }
+        // Consumers: requests.<verb>(url="literal") keyword
+        for (const match of runCompiledPatterns(REQUESTS_KEYWORD_URL_PATTERNS, tree)) {
+            const methodNode = match.captures.method;
+            const pathNode = match.captures.path;
+            if (!methodNode || !pathNode)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'python-requests',
+                method: methodNode.text.toUpperCase(),
+                path,
+                name: null,
+                confidence: 0.7,
+            });
+        }
         // Consumers: requests.request("METHOD", "url")
         for (const match of runCompiledPatterns(REQUESTS_GENERIC_PATTERNS, tree)) {
             const methodNode = match.captures.http_method;
@@ -853,6 +993,86 @@ export const PYTHON_HTTP_PLUGIN = {
                 confidence: 0.7,
             });
         }
+        // Consumers: wrapper classes with uri= or url= keyword argument
+        //   obj.fetch(uri="api/v1/camera/info/")
+        //   obj.post(url="api/v1/config/update/")
+        const seenUriDetections = new Set(); // node byte ranges, to avoid duplicates
+        for (const match of runCompiledPatterns(WRAPPER_URI_PATTERNS, tree)) {
+            const methodNode = match.captures.method;
+            const pathNode = match.captures.path;
+            if (!methodNode || !pathNode)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            // Deduplicate: the two pattern branches can match the same call. Key on
+            // node byte offsets, not line arithmetic (lineNum*1000+row can collide in
+            // files over 1000 lines, and miss a real dup when a node straddles a line).
+            const dedupKey = `${pathNode.startIndex}:${methodNode.startIndex}`;
+            if (seenUriDetections.has(dedupKey))
+                continue;
+            seenUriDetections.add(dedupKey);
+            const methodName = methodNode.text.toLowerCase();
+            // Map wrapper method name to HTTP verb (fetch, request → GET)
+            const httpMethod = WRAPPER_METHOD_TO_HTTP[methodName] ?? 'GET';
+            out.push({
+                role: 'consumer',
+                framework: 'python-http-wrapper',
+                method: httpMethod,
+                path,
+                name: null,
+                confidence: 0.65,
+            });
+        }
+        // Variable propagation: uri = "api/v1/endpoint/"; obj.fetch(uri=uri)
+        // Many repos assign URL paths to local vars then pass as keyword args.
+        const localStrings = buildLocalStringMap(tree);
+        const seenVarDetections = new Set();
+        for (const match of runCompiledPatterns(WRAPPER_URI_VAR_PATTERNS, tree)) {
+            const methodNode = match.captures.method;
+            const pathVarNode = match.captures.path_var;
+            if (!methodNode || !pathVarNode)
+                continue;
+            const dedupKey = `${pathVarNode.startPosition.row}:${methodNode.startPosition.row}`;
+            if (seenVarDetections.has(dedupKey))
+                continue;
+            seenVarDetections.add(dedupKey);
+            const resolved = localStrings.get(pathVarNode.text);
+            if (!resolved)
+                continue;
+            const normalized = normalizeConsumerPath(resolved);
+            if (normalized === '/')
+                continue;
+            const httpMethod = WRAPPER_METHOD_TO_HTTP[methodNode.text.toLowerCase()] ?? 'GET';
+            out.push({
+                role: 'consumer',
+                framework: 'python-http-wrapper',
+                method: httpMethod,
+                path: normalized,
+                name: null,
+                confidence: 0.6,
+            });
+        }
         return out;
     },
 };
+/** Normalize consumer path: strip host, template literals, numeric segments → {param} */
+function normalizeConsumerPath(url) {
+    let s = url.replace(/\$\{[^}]+\}/g, '{param}').trim();
+    if (/^https?:\/\//i.test(s)) {
+        try {
+            s = new URL(s).pathname;
+        }
+        catch {
+            s = s.replace(/^https?:\/\/[^/]+/i, '');
+        }
+    }
+    if (!s.startsWith('/'))
+        s = '/' + s;
+    const segments = s
+        .split('/')
+        .filter(Boolean)
+        .map((seg) => (/^\d+$/.test(seg) ? '{param}' : seg));
+    s = '/' + segments.join('/');
+    return s.replace(/\/+$/, '') || '/';
+}

package/dist/core/group/extractors/http-patterns/spring-consumer-shared.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Shared, language-agnostic primitives for Spring / OpenFeign / Spring-HTTP-Interface
+ * HTTP *consumer* extraction, used by BOTH the Java (`java.ts`) and Kotlin
+ * (`kotlin.ts`) group-layer HTTP plugins so the two cannot drift apart.
+ *
+ * These are pure value maps + string helpers — no tree-sitter AST knowledge.
+ * Each language plugin keeps its own grammar-specific queries and walkers and
+ * funnels the extracted (verb, path, prefix) facts through these helpers, so a
+ * polyglot repo emits byte-identical contract IDs from `.java` and `.kt`.
+ *
+ * The provider-side annotation→verb map (`METHOD_ANNOTATION_TO_HTTP`),
+ * `isRouteMemberKey`, and `findEnclosingClass` live in the lower
+ * `ingestion/route-extractors/spring-shared.ts` (shared with the ingestion
+ * route extractor). This module is the consumer-side counterpart and lives in
+ * the group layer beside the plugins that use it.
+ */
+import type { HttpFileDetections } from './types.js';
+/**
+ * RestTemplate method-name → HTTP verb. Source-scan only: the receiver must be
+ * named exactly `restTemplate` (the per-language query enforces that).
+ */
+export declare const REST_TEMPLATE_TO_HTTP: Record<string, string>;
+/**
+ * Reactive WebClient short-form verb helper → HTTP verb
+ * (`webClient.get().uri("/x")`, `.post()`, ...). HEAD/OPTIONS/TRACE are
+ * intentionally excluded for symmetry across the plugins.
+ */
+export declare const WEB_CLIENT_SHORT_TO_HTTP: Record<string, string>;
+/**
+ * Accepted HTTP verbs for the WebClient long form
+ * `webClient.method(HttpMethod.X).uri("/y")`. The verb is captured as the
+ * literal `HttpMethod.X` field name (`GET`, `POST`, …); HEAD/OPTIONS/TRACE are
+ * intentionally excluded for symmetry with the short form
+ * (`WEB_CLIENT_SHORT_TO_HTTP`). Shared so the Java and Kotlin long-form scans
+ * gate verbs identically.
+ */
+export declare const WEB_CLIENT_LONG_VERB_RE: RegExp;
+/**
+ * Spring 6 declarative HTTP Interface shortcut annotation → HTTP verb.
+ *
+ * `@GetExchange`/`@PostExchange`/… on a service interface proxied by
+ * `HttpServiceProxyFactory` (over RestClient / WebClient / RestTemplate)
+ * describe an OUTBOUND call — i.e. a CONSUMER, the modern analogue of an
+ * OpenFeign `@(Get|Post|...)Mapping` interface method. The path lives in the
+ * annotation's `url` (or `value`) attribute, or positionally.
+ *
+ * The base `@HttpExchange(method = "GET", url = "...")` form carries its verb
+ * in an attribute rather than the annotation name; the shortcut annotations
+ * above are the overwhelmingly common case and the only ones mapped here.
+ */
+export declare const EXCHANGE_ANNOTATION_TO_HTTP: Record<string, string>;
+/**
+ * Accumulate a route prefix (de-duped) under a class/interface declaration node
+ * id. A Spring route attribute is `String[]`; a multi-element array (`["/a","/b"]`,
+ * `arrayOf("/a","/b")`, `{"/a","/b"}`) yields one query match per element, so
+ * prefixes accumulate rather than overwrite. Shared by the Java and Kotlin plugins
+ * so both build their prefix maps identically.
+ */
+export declare const pushPrefix: (map: Map<number, string[]>, id: number, prefix: string) => void;
+/** Framework tags emitted on consumer detections (stable contract metadata). */
+export declare const OPENFEIGN_FRAMEWORK = "openfeign";
+export declare const HTTP_INTERFACE_FRAMEWORK = "spring-http-interface";
+/** Consumer-detection confidences, shared so `.java` and `.kt` agree. */
+export declare const FEIGN_CONFIDENCE = 0.7;
+export declare const REQUEST_LINE_CONFIDENCE = 0.75;
+export declare const EXCHANGE_CONFIDENCE = 0.75;
+/**
+ * OpenFeign's native `@RequestLine("METHOD /path[?query]")` packs an HTTP
+ * method and path in a single string literal — see
+ * https://github.com/OpenFeign/feign#interface-annotations. This regex splits
+ * the verb from the path of that literal.
+ */
+export declare const REQUEST_LINE_VERB_RE: RegExp;
+/**
+ * Parse a Feign `@RequestLine` value into a method + path pair. The query
+ * portion is dropped because contract IDs are method+path only (consistent
+ * with how RestTemplate/WebClient consumers drop inline query strings).
+ *
+ * Returns null if the value is not a recognized HTTP verb followed by a path
+ * beginning with `/`.
+ */
+export declare function parseRequestLine(raw: string): {
+    method: string;
+    path: string;
+} | null;
+/**
+ * Join a class/interface-level prefix and a method-level path into a single
+ * URL path: strip leading/trailing slashes on the prefix and leading slashes
+ * on the method path, then ensure exactly one slash between them.
+ */
+export declare function joinPath(prefix: string, methodPath: string): string;
+/**
+ * Join a controller's own class prefix with a route inherited from an interface
+ * (interface-based controllers, #1743). The inherited path already has the
+ * interface's own class prefix (`inheritedOwnerPrefix`) baked in; when the
+ * controller repeats that same prefix we must NOT prepend it twice (#2057).
+ * Shared by both plugins' `scanProject` so Java and Kotlin agree.
+ */
+export declare function joinInheritedSpringPath(controllerPrefix: string, inheritedPath: string, inheritedOwnerPrefix?: string): string;
+/**
+ * Language-agnostic view of a Spring class/interface that each plugin's
+ * grammar-specific collector produces. The interface-based-controller
+ * inheritance algorithm (`scanSpringInheritanceProject`) operates only on this
+ * shape, so the Java and Kotlin plugins share one algorithm and cannot drift.
+ *
+ * `methods[].routes` carry only `{ method, path }` — the interface's own class
+ * prefix is applied *inside* `scanSpringInheritanceProject` (it is not part of
+ * the collector's output).
+ */
+export interface SharedSpringType {
+    filePath: string;
+    kind: 'class' | 'interface';
+    name: string;
+    /** Class-level `@RequestMapping` prefixes — one per array element. */
+    classPrefixes: string[];
+    implementedInterfaces: string[];
+    isController: boolean;
+    methods: Array<{
+        name: string;
+        routes: Array<{
+            method: string;
+            path: string;
+        }>;
+    }>;
+}
+/**
+ * Resolve interface-based-controller provider routes (#1743): a concrete
+ * `@RestController`/`@Controller` class inherits the `@(Get|...)Mapping` routes
+ * declared on the interface it implements. Shared by the Java and Kotlin plugins
+ * so both emit byte-identical provider contracts.
+ *
+ * An interface name that resolves to two distinct interfaces is ambiguous and
+ * its routes are dropped (the `null` marker). The controller's own class
+ * prefix(es) cross-product the inherited routes; `joinInheritedSpringPath`
+ * avoids doubling a prefix the interface already baked in (#2057).
+ */
+export declare function scanSpringInheritanceProject(types: SharedSpringType[]): HttpFileDetections[];

package/dist/core/group/extractors/http-patterns/spring-consumer-shared.js

@@ -0,0 +1,230 @@
+/**
+ * Shared, language-agnostic primitives for Spring / OpenFeign / Spring-HTTP-Interface
+ * HTTP *consumer* extraction, used by BOTH the Java (`java.ts`) and Kotlin
+ * (`kotlin.ts`) group-layer HTTP plugins so the two cannot drift apart.
+ *
+ * These are pure value maps + string helpers — no tree-sitter AST knowledge.
+ * Each language plugin keeps its own grammar-specific queries and walkers and
+ * funnels the extracted (verb, path, prefix) facts through these helpers, so a
+ * polyglot repo emits byte-identical contract IDs from `.java` and `.kt`.
+ *
+ * The provider-side annotation→verb map (`METHOD_ANNOTATION_TO_HTTP`),
+ * `isRouteMemberKey`, and `findEnclosingClass` live in the lower
+ * `ingestion/route-extractors/spring-shared.ts` (shared with the ingestion
+ * route extractor). This module is the consumer-side counterpart and lives in
+ * the group layer beside the plugins that use it.
+ */
+/**
+ * RestTemplate method-name → HTTP verb. Source-scan only: the receiver must be
+ * named exactly `restTemplate` (the per-language query enforces that).
+ */
+export const REST_TEMPLATE_TO_HTTP = {
+    getForObject: 'GET',
+    getForEntity: 'GET',
+    postForObject: 'POST',
+    postForEntity: 'POST',
+    put: 'PUT',
+    delete: 'DELETE',
+    patchForObject: 'PATCH',
+};
+/**
+ * Reactive WebClient short-form verb helper → HTTP verb
+ * (`webClient.get().uri("/x")`, `.post()`, ...). HEAD/OPTIONS/TRACE are
+ * intentionally excluded for symmetry across the plugins.
+ */
+export const WEB_CLIENT_SHORT_TO_HTTP = {
+    get: 'GET',
+    post: 'POST',
+    put: 'PUT',
+    delete: 'DELETE',
+    patch: 'PATCH',
+};
+/**
+ * Accepted HTTP verbs for the WebClient long form
+ * `webClient.method(HttpMethod.X).uri("/y")`. The verb is captured as the
+ * literal `HttpMethod.X` field name (`GET`, `POST`, …); HEAD/OPTIONS/TRACE are
+ * intentionally excluded for symmetry with the short form
+ * (`WEB_CLIENT_SHORT_TO_HTTP`). Shared so the Java and Kotlin long-form scans
+ * gate verbs identically.
+ */
+export const WEB_CLIENT_LONG_VERB_RE = /^(GET|POST|PUT|DELETE|PATCH)$/;
+/**
+ * Spring 6 declarative HTTP Interface shortcut annotation → HTTP verb.
+ *
+ * `@GetExchange`/`@PostExchange`/… on a service interface proxied by
+ * `HttpServiceProxyFactory` (over RestClient / WebClient / RestTemplate)
+ * describe an OUTBOUND call — i.e. a CONSUMER, the modern analogue of an
+ * OpenFeign `@(Get|Post|...)Mapping` interface method. The path lives in the
+ * annotation's `url` (or `value`) attribute, or positionally.
+ *
+ * The base `@HttpExchange(method = "GET", url = "...")` form carries its verb
+ * in an attribute rather than the annotation name; the shortcut annotations
+ * above are the overwhelmingly common case and the only ones mapped here.
+ */
+export const EXCHANGE_ANNOTATION_TO_HTTP = {
+    GetExchange: 'GET',
+    PostExchange: 'POST',
+    PutExchange: 'PUT',
+    DeleteExchange: 'DELETE',
+    PatchExchange: 'PATCH',
+};
+/**
+ * Accumulate a route prefix (de-duped) under a class/interface declaration node
+ * id. A Spring route attribute is `String[]`; a multi-element array (`["/a","/b"]`,
+ * `arrayOf("/a","/b")`, `{"/a","/b"}`) yields one query match per element, so
+ * prefixes accumulate rather than overwrite. Shared by the Java and Kotlin plugins
+ * so both build their prefix maps identically.
+ */
+export const pushPrefix = (map, id, prefix) => {
+    const arr = map.get(id) ?? [];
+    if (!arr.includes(prefix))
+        arr.push(prefix);
+    map.set(id, arr);
+};
+/** Framework tags emitted on consumer detections (stable contract metadata). */
+export const OPENFEIGN_FRAMEWORK = 'openfeign';
+export const HTTP_INTERFACE_FRAMEWORK = 'spring-http-interface';
+/** Consumer-detection confidences, shared so `.java` and `.kt` agree. */
+export const FEIGN_CONFIDENCE = 0.7;
+export const REQUEST_LINE_CONFIDENCE = 0.75;
+export const EXCHANGE_CONFIDENCE = 0.75;
+/**
+ * OpenFeign's native `@RequestLine("METHOD /path[?query]")` packs an HTTP
+ * method and path in a single string literal — see
+ * https://github.com/OpenFeign/feign#interface-annotations. This regex splits
+ * the verb from the path of that literal.
+ */
+export 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. The query
+ * portion is dropped because contract IDs are method+path only (consistent
+ * with how RestTemplate/WebClient consumers drop inline query strings).
+ *
+ * Returns null if the value is not a recognized HTTP verb followed by a path
+ * beginning with `/`.
+ */
+export 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 };
+}
+/**
+ * Join a class/interface-level prefix and a method-level path into a single
+ * URL path: strip leading/trailing slashes on the prefix and leading slashes
+ * on the method path, then ensure exactly one slash between them.
+ */
+export function joinPath(prefix, methodPath) {
+    const cleanPrefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
+    const cleanSub = methodPath.replace(/^\/+/, '');
+    if (!cleanPrefix)
+        return `/${cleanSub}`;
+    return `/${cleanPrefix}/${cleanSub}`;
+}
+/**
+ * Join a controller's own class prefix with a route inherited from an interface
+ * (interface-based controllers, #1743). The inherited path already has the
+ * interface's own class prefix (`inheritedOwnerPrefix`) baked in; when the
+ * controller repeats that same prefix we must NOT prepend it twice (#2057).
+ * Shared by both plugins' `scanProject` so Java and Kotlin agree.
+ */
+export 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;
+}
+/**
+ * Resolve interface-based-controller provider routes (#1743): a concrete
+ * `@RestController`/`@Controller` class inherits the `@(Get|...)Mapping` routes
+ * declared on the interface it implements. Shared by the Java and Kotlin plugins
+ * so both emit byte-identical provider contracts.
+ *
+ * An interface name that resolves to two distinct interfaces is ambiguous and
+ * its routes are dropped (the `null` marker). The controller's own class
+ * prefix(es) cross-product the inherited routes; `joinInheritedSpringPath`
+ * avoids doubling a prefix the interface already baked in (#2057).
+ */
+export function scanSpringInheritanceProject(types) {
+    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 prefixes = type.classPrefixes.length ? type.classPrefixes : [''];
+        const methodMap = new Map();
+        for (const method of type.methods) {
+            // Cross-product the interface's class prefixes with each method route, so a
+            // multi-element `@RequestMapping(["/a","/b"])` interface yields N bindings.
+            const routes = method.routes.flatMap((route) => prefixes.map((prefix) => ({
+                method: route.method,
+                path: prefix ? joinPath(prefix, route.path) : route.path,
+                ownerPrefix: prefix,
+            })));
+            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;
+        // Cross-product the controller's own class prefixes with each inherited
+        // route; `['']` keeps the common no-prefix controller emitting the
+        // interface path unchanged.
+        const controllerPrefixes = type.classPrefixes.length ? type.classPrefixes : [''];
+        for (const method of type.methods) {
+            if (method.routes.length > 0)
+                continue; // own @*Mapping → already a provider via scan()
+            const inherited = type.implementedInterfaces.flatMap((iface) => {
+                const routeMap = interfaceRoutes.get(iface);
+                if (!routeMap)
+                    return [];
+                const routes = routeMap.get(method.name) ?? [];
+                return routes.flatMap((route) => controllerPrefixes.map((controllerPrefix) => ({
+                    method: route.method,
+                    path: joinInheritedSpringPath(controllerPrefix, route.path, route.ownerPrefix),
+                })));
+            });
+            const seen = new Set();
+            for (const route of inherited) {
+                const key = `${route.method} ${route.path}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                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,
+    }));
+}