feat(group): extract OpenFeign @RequestLine consumer contracts

[henry201605]

Adds Java HTTP plugin support for the native OpenFeign annotation @RequestLine("METHOD /path"). Previously only @FeignClient interfaces using Spring MVC method annotations (@GetMapping etc.) were detected; the native annotation form — required by Feign Builder users and non-Spring Feign deployments — was silently ignored.

Why

OpenFeign’s @RequestLine is the canonical annotation for the framework (https://github.com/OpenFeign/feign#interface-annotations) and is the only option for clients built without Spring Cloud OpenFeign. Real-world Java microservices that mix Spring Cloud and plain Feign Builder clients (e.g. internal client-jar libraries shared across non-Spring services) fall back to manifest-link workarounds today because GitNexus produces no consumer contract for these methods.

What changed

• FEIGN_REQUEST_LINE_PATTERNS — tree-sitter query covering both positional and named-arg (value =) forms.
• parseRequestLine() — splits the verb + path string and drops any query portion, matching how RestTemplate/WebClient inline URL consumers are normalized.
• The enclosing interface MUST carry @FeignClient; otherwise the detection is dropped to avoid false positives from same-named annotations in unrelated libraries.
• Reuses the existing feignPrefixByInterfaceId map so @FeignClient(path=) and @RequestMapping interface prefixes apply uniformly across both Spring MVC and @RequestLine methods.
• Confidence 0.75 — slightly higher than the 0.7 used for Spring MVC annotations because the verb is a string-literal value (less ambiguous than annotation-name inference).

Tests

Six new unit tests under extracts OpenFeign clients block:

Scenario	Asserts
basic two methods	both POST /ai/summarize and GET /ai/health extracted with framework: openfeign, confidence: 0.75
@FeignClient(path = "/api") prefix joining	/api/orders/{param} for both GET and DELETE
query string stripping	GET /search?q={query}&limit={limit} → http::GET::/search
no @FeignClient annotation	detection dropped (no false positive on plain interfaces)
mixed @RequestLine + @GetMapping on the same interface	both produced at their respective confidences (0.75 / 0.7)
named-argument form @RequestLine(value = "...")	extracted identically

Verification

• npx tsc --noEmit ✅
• test/unit/group/http-route-extractor.test.ts — 83/83 (77 existing + 6 new) ✅
• full test/unit/group/ — 31 files / 563 tests ✅
• npx prettier --check on touched files ✅
• npx eslint on touched files — 0 errors, 0 warnings introduced ✅

[vercel]

Someone is attempting to deploy a commit to the NexusCore Team on Vercel.

A member of the Team first needs to authorize it.

[magyargergo]

I think, we could optimise all of the annotations into one compilePatterns. It seems to me that we do this a couple of times that we don't need to. Could you please merge all of the annotation match queries into one? 🙏

[henry201605]

Done in f10854d3 — both the positional and named-argument (value =) forms now share a single tree-sitter query via [(...) (...)] alternation, so compilePatterns builds one query and runCompiledPatterns issues one matches() pass.

[magyargergo]

Can you please give a more generic name to this please? 🙏

[github-actions]

CI Report

✅ All checks passed

Pipeline Status

Stage	Status	Details
✅ Typecheck	success	tsc --noEmit
✅ Tests	success	unit tests, 3 platforms
✅ E2E	success	gitnexus-web changes only

Test Results

Tests	Passed	Failed	Skipped	Duration
10189	10182	0	7	606s

✅ All 10182 tests passed

7 test(s) skipped — expand for details

• COBOL pipeline benchmark > scales with file count
• C# pipeline benchmark > scales with file count — namespaces spread across the solution
• C# pipeline benchmark > scales with file count — all types in one (global) namespace bucket
• PHP pipeline benchmark > scales with file count (workers enabled)
• Ruby pipeline benchmark > scales with file count (workers enabled)
• Rust pipeline benchmark > scales with file count (workers enabled)
• buildTypeEnv > known limitations (documented skip tests) > Ruby block parameter: users.each { |user| } — closure param inference, different feature

Code Coverage

Tests

Metric	Coverage	Covered	Base	Delta	Status
Statements	79.98%	35812/44776	79.48%	📈 +0.5	🟢 ███████████████░░░░░
Branches	68.64%	22892/33349	68%	📈 +0.6	🟢 █████████████░░░░░░░
Functions	84.95%	3681/4333	84.56%	📈 +0.4	🟢 ████████████████░░░░
Lines	83.52%	32248/38610	82.97%	📈 +0.5	🟢 ████████████████░░░░

---

_{📋 View full run · Generated by CI}

[magyargergo]

Sorry I really meant it for all kinds of annotations that ends up as a request mapper

[henry201605]

@magyargergo Thanks for clarifying! I gave the full alternation merge a try and ran into a snag worth flagging.

The Spring @(Get|Post|Put|Delete|Patch)Mapping and @RequestMapping(path|value=...) queries rely on #match? predicates for the verb / argument-key regexes. Under our pinned tree-sitter@0.21 Node binding, #match? predicates inside [(...) (...)] alternation are silently dropped — the query compiles fine but matches() returns zero results. I confirmed it with a minimal repro:

// identical input + grammar; only the predicate differs
#eq?    alternation → 1 match  ✅
#match? alternation → 0 matches ❌

That's why the @RequestLine merge in f10854d3 worked (it only uses #eq?), and why merging the Spring/Feign-prefix queries breaks 14 tests — the verb-name guard never fires.

Two ways to land your request:

• (a) Pure alternation: expand every #match? into multiple #eq? branches (5 HTTP verbs × 2 argument shapes = up to ~15 branches per query). Behavior is correct, but the query strings grow significantly.
• (b) Single compilePatterns(...) call per area, keeping multiple patterns: [...] specs inside it (so each predicate stays in its own bounded query). Same total matches() invocations as today, much less duplicated boilerplate, no binding workaround needed.

I'd lean toward (b) — it gets the consolidation win without the binding caveat. Happy to take the (a) route if you'd prefer the pure-alternation form, or do (b) and revisit (a) once we bump tree-sitter. Let me know which way you'd like to go 🙏

[magyargergo]

Can you please give a more generic name to this please? 🙏

[magyargergo]

@henry201605 To summarise what I'm looking for on the consolidation feedback:

Goal: one compilePatterns call (and therefore one matches() pass per file) for all request-mapper annotations — Spring @GetMapping / @PostMapping / @RequestMapping, OpenFeign @RequestLine, and the related prefix patterns — instead of separate pattern blocks each doing their own pass.

How it should work:

1. A single tree-sitter query with alternation covers every annotation variant we care about.
2. Use captures in the query to tag which variant matched (e.g. verb annotation name, @RequestLine value, path argument, enclosing method/interface).
3. In the existing for-loop over matches, branch on the captured groups to build the consumer contract — no second/third runCompiledPatterns invocation.

The performance win is fewer tree-sitter passes; the behaviour should stay the same. Happy to discuss if anything in the current query shape makes a particular branch hard to capture cleanly.

[magyargergo]

@henry201605 Don't worry about this! I'll get it out today with the changes I want to see.

[henry201605]

@magyargergo Actually, I'd already taken a stab at the consolidation before seeing this — happy to push it for you to review, or just share the approach so you can take it from here, whatever's least disruptive.

One thing worth flagging that I hit: collapsing the route-mapper annotations into a single alternation with #match?/#any-of? predicates doesn't work on the pinned tree-sitter@0.21.1 binding — a predicate on any branch silently corrupts matching for the whole query (sibling #eq? branches drop their matches too). Minimal repro, same input: [positional(#eq?) | named(#match?)] → 1 match, [positional(#eq?) | named(#eq?)] → 2 matches.

How I worked around it: make the single query purely structural (class / interface / method × positional / named, zero predicates) and do all the annotation-name / key filtering in JS while iterating the matches — which lines up with your steps 2 & 3 (capture-tag + branch in the loop), just with the filtering in JS instead of query predicates. That collapses the four annotation pattern blocks (@RequestMapping prefixes, @(Get|Post|…)Mapping routes, Feign interface prefixes, @RequestLine) into one compilePatterns and one matches() pass. 84 tests green.

Scope note: the method-invocation consumers (RestTemplate / WebClient / OkHttp / Apache / Java HttpClient) stay as separate queries — they match method_invocation / object_creation_expression nodes, not annotations, so they can't fold into the same alternation. This change is scoped to the annotation-based route mappers you listed.

I can push it to this branch if useful, or leave it entirely to you — your call. 🙏