gitnexus 1.6.0 → 1.6.2-rc.1

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

@@ -0,0 +1,67 @@
+import Python from 'tree-sitter-python';
+import { compilePatterns, runCompiledPatterns, } from '../tree-sitter-scanner.js';
+/**
+ * Python gRPC plugin. Detects:
+ *   - Provider: `add_XxxServicer_to_server(...)` calls (bare identifier
+ *     or qualified attribute form `auth_pb2_grpc.add_XxxServicer_to_server`)
+ *   - Consumer: `XxxStub(channel)` calls (bare or `auth_pb2_grpc.XxxStub`)
+ */
+const ADD_SERVICER_RE = /^add_(\w+)Servicer_to_server$/;
+const STUB_RE = /^(\w+)Stub$/;
+/** Reserved names that would produce garbage service names. */
+const STUB_IGNORE = new Set(['Mock', 'Test', 'Fake', 'Stub']);
+// Any call whose target is either a bare identifier or an attribute
+// access (`obj.method`). The plugin filters the function name in JS.
+const CALL_PATTERNS = compilePatterns({
+    name: 'python-grpc-call',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call
+          function: [
+            (identifier) @fn
+            (attribute attribute: (identifier) @fn)
+          ])
+      `,
+        },
+    ],
+});
+export const PYTHON_GRPC_PLUGIN = {
+    name: 'python-grpc',
+    language: Python,
+    scan(tree) {
+        const out = [];
+        for (const match of runCompiledPatterns(CALL_PATTERNS, tree)) {
+            const fnNode = match.captures.fn;
+            if (!fnNode)
+                continue;
+            const fnText = fnNode.text;
+            const addServicer = ADD_SERVICER_RE.exec(fnText);
+            if (addServicer) {
+                out.push({
+                    role: 'provider',
+                    serviceName: addServicer[1],
+                    symbolName: fnText,
+                    source: 'python_servicer',
+                    confidenceWithProto: 0.8,
+                    confidenceWithoutProto: 0.65,
+                });
+                continue;
+            }
+            const stubMatch = STUB_RE.exec(fnText);
+            if (stubMatch && !STUB_IGNORE.has(stubMatch[1])) {
+                out.push({
+                    role: 'consumer',
+                    serviceName: stubMatch[1],
+                    symbolName: fnText,
+                    source: 'python_stub',
+                    confidenceWithProto: 0.75,
+                    confidenceWithoutProto: 0.55,
+                });
+            }
+        }
+        return out;
+    },
+};

package/dist/core/group/extractors/grpc-patterns/types.d.ts

@@ -0,0 +1,50 @@
+import type Parser from 'tree-sitter';
+/**
+ * Shared types for the grpc-extractor language plugins.
+ *
+ * Each plugin lives in its own file (java.ts, go.ts, ...) and owns the
+ * tree-sitter grammar import + query sources. The top-level
+ * `grpc-extractor.ts` orchestrator only knows about this type module
+ * and the plugin registry (`./index.ts`). It MUST NOT import any
+ * grammar or query text directly.
+ */
+export type GrpcRole = 'provider' | 'consumer';
+/**
+ * One raw gRPC detection produced by a plugin's `scan()` function. The
+ * orchestrator uses the proto map to resolve the full package-qualified
+ * contract id and choose a confidence based on whether the proto was
+ * found.
+ *
+ * Most patterns produce service-level detections; `TS @GrpcMethod` is
+ * the only pattern that captures an explicit `methodName`, producing
+ * a method-level contract (`grpc::pkg.Service/Method`).
+ */
+export interface GrpcDetection {
+    role: GrpcRole;
+    /** Short service name, e.g. `"AuthService"`. */
+    serviceName: string;
+    /** Symbol name emitted into the contract's symbolRef. */
+    symbolName: string;
+    /** Metadata source label (goes into `meta.source`). */
+    source: string;
+    /** Explicit method name; set only by TS `@GrpcMethod`. */
+    methodName?: string;
+    /** Confidence when the proto map resolves the service. */
+    confidenceWithProto: number;
+    /** Confidence when the proto map has no entry. */
+    confidenceWithoutProto: number;
+}
+/**
+ * One language-scoped gRPC plugin. Plugins own the tree-sitter grammar
+ * and a `scan(tree)` function that returns zero or more
+ * `GrpcDetection`s. The plugin is free to run multiple compiled query
+ * bundles and walk the AST to cross-reference captures.
+ *
+ * `language` is typed `unknown` for the same reason as in
+ * `tree-sitter-scanner.ts`.
+ */
+export interface GrpcLanguagePlugin {
+    name: string;
+    language: unknown;
+    scan(tree: Parser.Tree): GrpcDetection[];
+}

package/dist/core/group/extractors/grpc-patterns/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/group/extractors/http-patterns/go.d.ts

@@ -0,0 +1,2 @@
+import type { HttpLanguagePlugin } from './types.js';
+export declare const GO_HTTP_PLUGIN: HttpLanguagePlugin;

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

@@ -0,0 +1,215 @@
+import Go from 'tree-sitter-go';
+import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
+/**
+ * Go HTTP plugin. Handles:
+ *   - gin / echo / chi framework routing — `r.GET("/path", handler)`
+ *   - net/http stdlib — `http.HandleFunc("/path", handler)`
+ *   - net/http consumer — `http.Get(...)`, `http.NewRequest("METHOD", ...)`
+ *   - resty consumer — `client.R().Delete("/path")`
+ */
+// ─── Provider: framework routing ──────────────────────────────────────
+// Matches `\w+\.GET(...)` etc. (gin, echo, chi all share this shape).
+// Captures the HTTP method (field name), path literal, and handler
+// identifier passed as the second argument.
+const FRAMEWORK_ROUTE_PATTERNS = compilePatterns({
+    name: 'go-framework-route',
+    language: Go,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call_expression
+          function: (selector_expression
+            field: (field_identifier) @http_method (#match? @http_method "^(GET|POST|PUT|DELETE|PATCH)$"))
+          arguments: (argument_list
+            (interpreted_string_literal) @path
+            (identifier) @handler))
+      `,
+        },
+    ],
+});
+// ─── Provider: net/http `http.HandleFunc("/p", handler)` ─────────────
+const HANDLE_FUNC_PATTERNS = compilePatterns({
+    name: 'go-handle-func',
+    language: Go,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call_expression
+          function: (selector_expression
+            operand: (identifier) @pkg (#eq? @pkg "http")
+            field: (field_identifier) @fn (#eq? @fn "HandleFunc"))
+          arguments: (argument_list
+            (interpreted_string_literal) @path
+            (identifier) @handler))
+      `,
+        },
+    ],
+});
+// ─── Consumer: net/http stdlib Get / Post / Head ─────────────────────
+const HTTP_CLIENT_METHOD_TO_HTTP = {
+    Get: 'GET',
+    Post: 'POST',
+    Head: 'GET', // HEAD has no body semantics we care about — treat as GET for contract matching
+};
+const HTTP_CLIENT_PATTERNS = compilePatterns({
+    name: 'go-http-client',
+    language: Go,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call_expression
+          function: (selector_expression
+            operand: (identifier) @pkg (#eq? @pkg "http")
+            field: (field_identifier) @fn (#match? @fn "^(Get|Post|Head)$"))
+          arguments: (argument_list . (interpreted_string_literal) @path))
+      `,
+        },
+    ],
+});
+// ─── Consumer: net/http `http.NewRequest("METHOD", "/path", ...)` ────
+const NEW_REQUEST_PATTERNS = compilePatterns({
+    name: 'go-new-request',
+    language: Go,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call_expression
+          function: (selector_expression
+            operand: (identifier) @pkg (#eq? @pkg "http")
+            field: (field_identifier) @fn (#eq? @fn "NewRequest"))
+          arguments: (argument_list
+            .
+            (interpreted_string_literal) @http_method
+            (interpreted_string_literal) @path))
+      `,
+        },
+    ],
+});
+// ─── Consumer: resty `client.R().Delete("/path")` ─────────────────────
+// Matches any chained call whose receiver is `something.R()` and whose
+// method name is an HTTP verb. This is how go-resty's fluent API looks.
+const RESTY_PATTERNS = compilePatterns({
+    name: 'go-resty',
+    language: Go,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call_expression
+          function: (selector_expression
+            operand: (call_expression
+              function: (selector_expression
+                field: (field_identifier) @r (#eq? @r "R")))
+            field: (field_identifier) @http_method (#match? @http_method "^(Get|Post|Put|Delete|Patch)$"))
+          arguments: (argument_list . (interpreted_string_literal) @path))
+      `,
+        },
+    ],
+});
+export const GO_HTTP_PLUGIN = {
+    name: 'go-http',
+    language: Go,
+    scan(tree) {
+        const out = [];
+        // Framework providers: r.GET/POST/... with handler identifier
+        for (const match of runCompiledPatterns(FRAMEWORK_ROUTE_PATTERNS, tree)) {
+            const methodNode = match.captures.http_method;
+            const pathNode = match.captures.path;
+            const handlerNode = match.captures.handler;
+            if (!methodNode || !pathNode)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'provider',
+                framework: 'go-framework',
+                method: methodNode.text.toUpperCase(),
+                path,
+                name: handlerNode?.text ?? null,
+                confidence: 0.8,
+            });
+        }
+        // net/http HandleFunc: default method GET
+        for (const match of runCompiledPatterns(HANDLE_FUNC_PATTERNS, tree)) {
+            const pathNode = match.captures.path;
+            const handlerNode = match.captures.handler;
+            if (!pathNode)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'provider',
+                framework: 'go-stdlib',
+                method: 'GET',
+                path,
+                name: handlerNode?.text ?? null,
+                confidence: 0.8,
+            });
+        }
+        // net/http client: http.Get/Post/Head
+        for (const match of runCompiledPatterns(HTTP_CLIENT_PATTERNS, tree)) {
+            const fnNode = match.captures.fn;
+            const pathNode = match.captures.path;
+            if (!fnNode || !pathNode)
+                continue;
+            const httpMethod = HTTP_CLIENT_METHOD_TO_HTTP[fnNode.text];
+            if (!httpMethod)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'go-stdlib',
+                method: httpMethod,
+                path,
+                name: null,
+                confidence: 0.7,
+            });
+        }
+        // net/http NewRequest
+        for (const match of runCompiledPatterns(NEW_REQUEST_PATTERNS, tree)) {
+            const methodNode = match.captures.http_method;
+            const pathNode = match.captures.path;
+            if (!methodNode || !pathNode)
+                continue;
+            const method = unquoteLiteral(methodNode.text);
+            const path = unquoteLiteral(pathNode.text);
+            if (method === null || path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'go-stdlib',
+                method: method.toUpperCase(),
+                path,
+                name: null,
+                confidence: 0.7,
+            });
+        }
+        // resty
+        for (const match of runCompiledPatterns(RESTY_PATTERNS, tree)) {
+            const methodNode = match.captures.http_method;
+            const pathNode = match.captures.path;
+            if (!methodNode || !pathNode)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'go-resty',
+                method: methodNode.text.toUpperCase(),
+                path,
+                name: null,
+                confidence: 0.7,
+            });
+        }
+        return out;
+    },
+};

package/dist/core/group/extractors/http-patterns/index.d.ts

@@ -0,0 +1,17 @@
+import type { HttpLanguagePlugin } from './types.js';
+export type { HttpDetection, HttpLanguagePlugin, HttpRole } from './types.js';
+/**
+ * Glob for files worth scanning for HTTP routes. Kept alongside the
+ * registry so adding a new language widens the glob in one edit.
+ *
+ * `.vue` / `.svelte` files are intentionally omitted for the source-scan
+ * path — they need their own grammar-aware extraction and the existing
+ * regex fallback for them was never very accurate. The graph-assisted
+ * Strategy A still handles them via the ingestion pipeline.
+ */
+export declare const HTTP_SCAN_GLOB = "**/*.{ts,tsx,js,jsx,java,go,py,php}";
+/**
+ * Return the HTTP plugin registered for the given file's extension,
+ * or `undefined` if the extension is not registered.
+ */
+export declare function getPluginForFile(rel: string): HttpLanguagePlugin | undefined;

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

@@ -0,0 +1,44 @@
+import * as path from 'node:path';
+import { JAVA_HTTP_PLUGIN } from './java.js';
+import { GO_HTTP_PLUGIN } from './go.js';
+import { PYTHON_HTTP_PLUGIN } from './python.js';
+import { PHP_HTTP_PLUGIN } from './php.js';
+import { JAVASCRIPT_HTTP_PLUGIN, TYPESCRIPT_HTTP_PLUGIN, TSX_HTTP_PLUGIN } from './node.js';
+/**
+ * File-extension → HTTP language plugin registry. The top-level
+ * orchestrator (`http-route-extractor.ts`) looks up the plugin for each
+ * file it visits and delegates the tree-sitter scanning to the plugin.
+ *
+ * Keys are lowercase extensions including the leading dot. To add a
+ * new language, drop a `http-patterns/<lang>.ts` that exports a
+ * `HttpLanguagePlugin`, import it here and register the extension(s).
+ * No edits to `http-route-extractor.ts` are required.
+ */
+const REGISTRY = {
+    '.java': JAVA_HTTP_PLUGIN,
+    '.go': GO_HTTP_PLUGIN,
+    '.py': PYTHON_HTTP_PLUGIN,
+    '.php': PHP_HTTP_PLUGIN,
+    '.js': JAVASCRIPT_HTTP_PLUGIN,
+    '.jsx': JAVASCRIPT_HTTP_PLUGIN,
+    '.ts': TYPESCRIPT_HTTP_PLUGIN,
+    '.tsx': TSX_HTTP_PLUGIN,
+};
+/**
+ * Glob for files worth scanning for HTTP routes. Kept alongside the
+ * registry so adding a new language widens the glob in one edit.
+ *
+ * `.vue` / `.svelte` files are intentionally omitted for the source-scan
+ * path — they need their own grammar-aware extraction and the existing
+ * regex fallback for them was never very accurate. The graph-assisted
+ * Strategy A still handles them via the ingestion pipeline.
+ */
+export const HTTP_SCAN_GLOB = '**/*.{ts,tsx,js,jsx,java,go,py,php}';
+/**
+ * Return the HTTP plugin registered for the given file's extension,
+ * or `undefined` if the extension is not registered.
+ */
+export function getPluginForFile(rel) {
+    const ext = path.extname(rel).toLowerCase();
+    return REGISTRY[ext];
+}

package/dist/core/group/extractors/http-patterns/java.d.ts

@@ -0,0 +1,2 @@
+import type { HttpLanguagePlugin } from './types.js';
+export declare const JAVA_HTTP_PLUGIN: HttpLanguagePlugin;

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

@@ -0,0 +1,253 @@
+import Java from 'tree-sitter-java';
+import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
+/**
+ * Java HTTP plugin. Handles:
+ *   - Spring `@RequestMapping` class prefixes + `@(Get|Post|...)Mapping` method annotations
+ *   - Spring `RestTemplate.getForObject/...`, `WebClient.method(HttpMethod.X, ...)`
+ *   - OkHttp `new Request.Builder().url("...")`
+ *
+ * The plugin runs two pattern bundles: one to collect class-level
+ * `@RequestMapping` prefixes keyed by the enclosing class node, and a
+ * second to match method-level annotations. The `scan` function walks
+ * up from each matched annotation to find its enclosing class and
+ * combines the prefix with the method path.
+ */
+const METHOD_ANNOTATION_TO_HTTP = {
+    GetMapping: 'GET',
+    PostMapping: 'POST',
+    PutMapping: 'PUT',
+    DeleteMapping: 'DELETE',
+    PatchMapping: 'PATCH',
+};
+// ─── Provider: Spring class-level @RequestMapping prefix ──────────────
+const SPRING_CLASS_PREFIX_PATTERNS = compilePatterns({
+    name: 'java-spring-class-prefix',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (class_declaration
+          (modifiers
+            (annotation
+              name: (identifier) @ann (#eq? @ann "RequestMapping")
+              arguments: (annotation_argument_list (string_literal) @prefix)))) @class
+      `,
+        },
+    ],
+});
+// ─── Provider: Spring @(Get|Post|...)Mapping method annotations ───────
+const SPRING_METHOD_ROUTE_PATTERNS = compilePatterns({
+    name: 'java-spring-method-route',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (method_declaration
+          (modifiers
+            (annotation
+              name: (identifier) @ann (#match? @ann "^(Get|Post|Put|Delete|Patch)Mapping$")
+              arguments: (annotation_argument_list (string_literal) @path)))
+          name: (identifier) @method_name) @method
+      `,
+        },
+    ],
+});
+// ─── Consumer: Spring RestTemplate (object-named + method-named) ──────
+// RestTemplate.getForObject / getForEntity → GET
+// RestTemplate.postForObject / postForEntity → POST
+// RestTemplate.put → PUT
+// RestTemplate.delete → DELETE
+// RestTemplate.patchForObject → PATCH
+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,
+    patterns: [
+        {
+            meta: { framework: 'spring-rest-template' },
+            query: `
+        (method_invocation
+          object: (identifier) @obj (#eq? @obj "restTemplate")
+          name: (identifier) @method
+          arguments: (argument_list . (string_literal) @path))
+      `,
+        },
+    ],
+});
+// ─── Consumer: Spring WebClient — webClient.method(HttpMethod.X, "path") ─
+const WEB_CLIENT_PATTERNS = compilePatterns({
+    name: 'java-web-client',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (method_invocation
+          object: (identifier) @obj (#eq? @obj "webClient")
+          name: (identifier) @method (#eq? @method "method")
+          arguments: (argument_list
+            (field_access
+              object: (identifier) @httpMethodCls (#eq? @httpMethodCls "HttpMethod")
+              field: (identifier) @http_method)
+            (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
+// to escape a regex dot).
+const OK_HTTP_PATTERNS = compilePatterns({
+    name: 'java-okhttp',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (method_invocation
+          object: (object_creation_expression
+            type: (scoped_type_identifier) @type (#eq? @type "Request.Builder"))
+          name: (identifier) @method (#eq? @method "url")
+          arguments: (argument_list . (string_literal) @path))
+      `,
+        },
+    ],
+});
+/**
+ * Find the nearest enclosing class_declaration ancestor for a node, or
+ * null if the node is top-level. Tree-sitter's SyntaxNode.parent walks
+ * one level at a time.
+ */
+function findEnclosingClass(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'class_declaration')
+            return cur;
+        cur = cur.parent;
+    }
+    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}`;
+}
+export const JAVA_HTTP_PLUGIN = {
+    name: 'java-http',
+    language: Java,
+    scan(tree) {
+        const out = [];
+        // ─── Providers: Spring class prefix + method annotations ────────
+        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)
+                prefixByClassId.set(classNode.id, prefix);
+        }
+        for (const match of runCompiledPatterns(SPRING_METHOD_ROUTE_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 = METHOD_ANNOTATION_TO_HTTP[annNode.text];
+            if (!httpMethod)
+                continue;
+            const rawPath = unquoteLiteral(pathNode.text);
+            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,
+            });
+        }
+        // ─── 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.method(HttpMethod.X, "path") ──────────
+        for (const match of runCompiledPatterns(WEB_CLIENT_PATTERNS, tree)) {
+            const httpMethodNode = match.captures.http_method;
+            const pathNode = match.captures.path;
+            if (!httpMethodNode || !pathNode)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'spring-web-client',
+                method: httpMethodNode.text.toUpperCase(),
+                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/dist/core/group/extractors/http-patterns/node.d.ts

@@ -0,0 +1,4 @@
+import type { HttpLanguagePlugin } from './types.js';
+export declare const JAVASCRIPT_HTTP_PLUGIN: HttpLanguagePlugin;
+export declare const TYPESCRIPT_HTTP_PLUGIN: HttpLanguagePlugin;
+export declare const TSX_HTTP_PLUGIN: HttpLanguagePlugin;