gitnexus 1.5.3 → 1.6.1

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;

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

@@ -0,0 +1,354 @@
+import JavaScript from 'tree-sitter-javascript';
+import TypeScript from 'tree-sitter-typescript';
+import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
+/**
+ * Node.js / TypeScript HTTP plugin family. Handles:
+ *   - NestJS `@Controller('prefix')` classes with `@Get(':id')` methods
+ *   - Express `router.get(...)` / `app.post(...)` providers
+ *   - `fetch(url)` / `fetch(url, { method: 'POST' })` consumers
+ *   - `axios.get(url)` / `axios.delete(url)` consumers
+ *
+ * Because the JavaScript and TypeScript tree-sitter grammars share
+ * node type names for every construct we query, pattern sources are
+ * defined once and compiled against each grammar variant. The plugin
+ * exports three `HttpLanguagePlugin`s (JS, TS, TSX) that share the
+ * same `scan` function but bind to different grammars.
+ */
+// ─── Provider: NestJS — class-level @Controller('prefix') ────────────
+// In tree-sitter-typescript decorators are NOT children of
+// class_declaration / method_definition — they're siblings in the
+// surrounding class_body / program node. We therefore match the
+// decorator standalone and walk to its related class/method in JS.
+const NEST_CONTROLLER_SPEC = {
+    meta: {},
+    query: `
+    (decorator
+      (call_expression
+        function: (identifier) @dec (#eq? @dec "Controller")
+        arguments: (arguments . [(string) (template_string)] @prefix))) @ctrl_decorator
+  `,
+};
+// ─── Provider: NestJS — method-level @Get/@Post/... decorators ───────
+// Matches either `@Get('path')` or `@Get()`. The `@path` capture is
+// optional — when the first argument isn't a string, the plugin falls
+// back to '/' for the method-level path.
+const NEST_METHOD_SPEC = {
+    meta: {},
+    query: `
+    (decorator
+      (call_expression
+        function: (identifier) @dec (#match? @dec "^(Get|Post|Put|Delete|Patch)$")
+        arguments: (arguments) @args)) @method_decorator
+  `,
+};
+// ─── Provider: Express — router.get/app.post/... ─────────────────────
+const EXPRESS_SPEC = {
+    meta: {},
+    query: `
+    (call_expression
+      function: (member_expression
+        object: (identifier) @obj (#match? @obj "^(router|app)$")
+        property: (property_identifier) @http_method (#match? @http_method "^(get|post|put|delete|patch)$"))
+      arguments: (arguments . [(string) (template_string)] @path))
+  `,
+};
+// ─── Consumer: fetch(url) with NO options ─────────────────────────────
+const FETCH_NO_OPTIONS_SPEC = {
+    meta: {},
+    query: `
+    (call_expression
+      function: (identifier) @fn (#eq? @fn "fetch")
+      arguments: (arguments . [(string) (template_string)] @path .))
+  `,
+};
+// ─── Consumer: fetch(url, { method: 'X', ... }) ──────────────────────
+const FETCH_WITH_OPTIONS_SPEC = {
+    meta: {},
+    query: `
+    (call_expression
+      function: (identifier) @fn (#eq? @fn "fetch")
+      arguments: (arguments
+        . [(string) (template_string)] @path
+        (object
+          (pair
+            key: (property_identifier) @key (#eq? @key "method")
+            value: (string) @http_method))))
+  `,
+};
+// ─── Consumer: axios.get/post/... ────────────────────────────────────
+const AXIOS_SPEC = {
+    meta: {},
+    query: `
+    (call_expression
+      function: (member_expression
+        object: (identifier) @obj (#eq? @obj "axios")
+        property: (property_identifier) @http_method (#match? @http_method "^(get|post|put|delete|patch)$"))
+      arguments: (arguments . [(string) (template_string)] @path))
+  `,
+};
+function compileBundle(language, name) {
+    const mk = (spec, suffix) => compilePatterns({
+        name: `${name}-${suffix}`,
+        language,
+        patterns: [spec],
+    });
+    return {
+        controller: mk(NEST_CONTROLLER_SPEC, 'nest-controller'),
+        methodDecorator: mk(NEST_METHOD_SPEC, 'nest-method-decorator'),
+        express: mk(EXPRESS_SPEC, 'express'),
+        fetchNoOptions: mk(FETCH_NO_OPTIONS_SPEC, 'fetch-no-options'),
+        fetchWithOptions: mk(FETCH_WITH_OPTIONS_SPEC, 'fetch-with-options'),
+        axios: mk(AXIOS_SPEC, 'axios'),
+    };
+}
+const JAVASCRIPT_BUNDLE = compileBundle(JavaScript, 'javascript-http');
+const TYPESCRIPT_BUNDLE = compileBundle(TypeScript.typescript, 'typescript-http');
+const TSX_BUNDLE = compileBundle(TypeScript.tsx, 'tsx-http');
+const NEST_DECORATOR_TO_HTTP = {
+    Get: 'GET',
+    Post: 'POST',
+    Put: 'PUT',
+    Delete: 'DELETE',
+    Patch: 'PATCH',
+};
+/**
+ * Find the nearest enclosing class_declaration for a node, or null.
+ */
+function findEnclosingClass(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'class_declaration')
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
+}
+function joinPath(prefix, sub) {
+    const cleanPrefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
+    const cleanSub = sub.replace(/^\/+/, '');
+    if (!cleanPrefix)
+        return `/${cleanSub}`;
+    return `/${cleanPrefix}/${cleanSub}`;
+}
+/**
+ * For a standalone `decorator` node (child of class_body / program),
+ * find the related `class_declaration` node that it decorates. In
+ * tree-sitter-typescript the decorator is placed before the class
+ * declaration as a sibling (when decorating a class) or inside the
+ * class_body before a method_definition (when decorating a method);
+ * we walk the parent chain until we find the enclosing class.
+ */
+function findDecoratedClass(decoratorNode) {
+    const parent = decoratorNode.parent;
+    if (!parent)
+        return null;
+    // Case 1: decorator is a sibling of the class_declaration at program /
+    // export_statement level. Walk forward through siblings until we find
+    // the class_declaration this decorator belongs to.
+    for (let i = 0; i < parent.namedChildCount; i++) {
+        const child = parent.namedChild(i);
+        if (child && child.id === decoratorNode.id) {
+            for (let j = i + 1; j < parent.namedChildCount; j++) {
+                const next = parent.namedChild(j);
+                if (!next)
+                    continue;
+                if (next.type === 'decorator')
+                    continue; // adjacent decorators stack
+                if (next.type === 'class_declaration')
+                    return next;
+                if (next.type === 'export_statement') {
+                    // `export class Foo { ... }` wraps the declaration.
+                    for (let k = 0; k < next.namedChildCount; k++) {
+                        const inner = next.namedChild(k);
+                        if (inner?.type === 'class_declaration')
+                            return inner;
+                    }
+                }
+                break;
+            }
+            break;
+        }
+    }
+    // Case 2: decorator is inside a class_body (decorating a method) —
+    // walk up to the enclosing class_declaration.
+    return findEnclosingClass(decoratorNode);
+}
+/**
+ * For a method-level decorator node (child of class_body before a
+ * method_definition), find the method_definition it decorates.
+ */
+function findDecoratedMethod(decoratorNode) {
+    const parent = decoratorNode.parent;
+    if (!parent || parent.type !== 'class_body')
+        return null;
+    for (let i = 0; i < parent.namedChildCount; i++) {
+        const child = parent.namedChild(i);
+        if (child && child.id === decoratorNode.id) {
+            for (let j = i + 1; j < parent.namedChildCount; j++) {
+                const next = parent.namedChild(j);
+                if (!next)
+                    continue;
+                if (next.type === 'decorator')
+                    continue;
+                if (next.type === 'method_definition')
+                    return next;
+                return null;
+            }
+            return null;
+        }
+    }
+    return null;
+}
+function scanBundle(bundle, tree) {
+    const out = [];
+    // NestJS: collect `@Controller('prefix')` class decorators, keyed by
+    // the `class_declaration` they decorate.
+    const prefixByClassId = new Map();
+    for (const match of runCompiledPatterns(bundle.controller, tree)) {
+        const prefixNode = match.captures.prefix;
+        const decoratorNode = match.captures.ctrl_decorator;
+        if (!prefixNode || !decoratorNode)
+            continue;
+        const prefix = unquoteLiteral(prefixNode.text);
+        if (prefix === null)
+            continue;
+        const classNode = findDecoratedClass(decoratorNode);
+        if (!classNode)
+            continue;
+        prefixByClassId.set(classNode.id, prefix);
+    }
+    // NestJS: method-level @Get/@Post/... decorators. The decorator's
+    // arguments list may be empty (`@Get()`), a string (`@Get('path')`),
+    // or something else (which we skip).
+    for (const match of runCompiledPatterns(bundle.methodDecorator, tree)) {
+        const decNode = match.captures.dec;
+        const argsNode = match.captures.args;
+        const decoratorNode = match.captures.method_decorator;
+        if (!decNode || !argsNode || !decoratorNode)
+            continue;
+        const httpMethod = NEST_DECORATOR_TO_HTTP[decNode.text];
+        if (!httpMethod)
+            continue;
+        const methodNode = findDecoratedMethod(decoratorNode);
+        if (!methodNode)
+            continue;
+        const enclosingClass = findEnclosingClass(methodNode);
+        // Only emit NestJS detections when the class actually has a
+        // @Controller decorator — without it, the match is almost certainly
+        // something else (e.g. an unrelated library using similar names).
+        if (!enclosingClass || !prefixByClassId.has(enclosingClass.id))
+            continue;
+        const prefix = prefixByClassId.get(enclosingClass.id) ?? '';
+        let rawPath = '/';
+        const firstArg = argsNode.namedChild(0);
+        if (firstArg && (firstArg.type === 'string' || firstArg.type === 'template_string')) {
+            const unquoted = unquoteLiteral(firstArg.text);
+            if (unquoted !== null)
+                rawPath = unquoted;
+        }
+        // Get the method name from the decorated method_definition.
+        const methodNameNode = methodNode.childForFieldName('name');
+        const name = methodNameNode?.text ?? null;
+        out.push({
+            role: 'provider',
+            framework: 'nest',
+            method: httpMethod,
+            path: joinPath(prefix, rawPath),
+            name,
+            confidence: 0.8,
+        });
+    }
+    // Express: router/app.<verb>(...)
+    for (const match of runCompiledPatterns(bundle.express, 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: 'provider',
+            framework: 'express',
+            method: methodNode.text.toUpperCase(),
+            path,
+            name: 'handler',
+            confidence: 0.8,
+        });
+    }
+    // Consumer: fetch with options { method: 'X' }
+    const fetchSeen = new Set();
+    for (const match of runCompiledPatterns(bundle.fetchWithOptions, tree)) {
+        const pathNode = match.captures.path;
+        const methodNode = match.captures.http_method;
+        if (!pathNode || !methodNode)
+            continue;
+        const path = unquoteLiteral(pathNode.text);
+        const method = unquoteLiteral(methodNode.text);
+        if (path === null || method === null)
+            continue;
+        fetchSeen.add(pathNode.id);
+        out.push({
+            role: 'consumer',
+            framework: 'fetch',
+            method: method.toUpperCase(),
+            path,
+            name: null,
+            confidence: 0.7,
+        });
+    }
+    // Consumer: plain fetch(path) — default GET. Skip path nodes we already
+    // matched with the options variant so we don't double-emit.
+    for (const match of runCompiledPatterns(bundle.fetchNoOptions, tree)) {
+        const pathNode = match.captures.path;
+        if (!pathNode)
+            continue;
+        if (fetchSeen.has(pathNode.id))
+            continue;
+        const path = unquoteLiteral(pathNode.text);
+        if (path === null)
+            continue;
+        out.push({
+            role: 'consumer',
+            framework: 'fetch',
+            method: 'GET',
+            path,
+            name: null,
+            confidence: 0.7,
+        });
+    }
+    // Consumer: axios.<verb>(url)
+    for (const match of runCompiledPatterns(bundle.axios, 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: 'axios',
+            method: methodNode.text.toUpperCase(),
+            path,
+            name: null,
+            confidence: 0.7,
+        });
+    }
+    return out;
+}
+export const JAVASCRIPT_HTTP_PLUGIN = {
+    name: 'javascript-http',
+    language: JavaScript,
+    scan: (tree) => scanBundle(JAVASCRIPT_BUNDLE, tree),
+};
+export const TYPESCRIPT_HTTP_PLUGIN = {
+    name: 'typescript-http',
+    language: TypeScript.typescript,
+    scan: (tree) => scanBundle(TYPESCRIPT_BUNDLE, tree),
+};
+export const TSX_HTTP_PLUGIN = {
+    name: 'tsx-http',
+    language: TypeScript.tsx,
+    scan: (tree) => scanBundle(TSX_BUNDLE, tree),
+};

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

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

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

@@ -0,0 +1,70 @@
+import PHP from 'tree-sitter-php';
+import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
+/**
+ * PHP HTTP plugin — Laravel `Route::get/post/...` declarations.
+ *
+ * The pipeline already uses `PHP.php_only` for ingesting plain `.php`
+ * files (see `core/tree-sitter/parser-loader.ts`), and we do the same
+ * here so Laravel route files are parsed with the right grammar dialect.
+ */
+const LARAVEL_PATTERNS = compilePatterns({
+    name: 'php-laravel',
+    language: PHP.php_only,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (scoped_call_expression
+          scope: (name) @scope (#eq? @scope "Route")
+          name: (name) @method (#match? @method "^(get|post|put|delete|patch)$")
+          arguments: (arguments . (argument (string) @path)))
+      `,
+        },
+    ],
+});
+/**
+ * Extract the inner text of a PHP `string` node. The tree-sitter-php
+ * grammar wraps single / double-quoted literals differently depending
+ * on content; we try both the raw `text` (with quotes) through
+ * `unquoteLiteral`, and a fallback via the `string_value` / `string_content`
+ * child nodes.
+ */
+function phpStringText(node) {
+    // Most single-quoted strings expose their inner content through the
+    // full node text (including quotes), which unquoteLiteral strips.
+    const direct = unquoteLiteral(node.text);
+    if (direct !== null && direct !== node.text)
+        return direct;
+    // Fall back to child string_content / string_value node if present.
+    for (const child of node.children) {
+        if (child.type === 'string_content' || child.type === 'string_value') {
+            return child.text;
+        }
+    }
+    return direct;
+}
+export const PHP_HTTP_PLUGIN = {
+    name: 'php-http',
+    language: PHP.php_only,
+    scan(tree) {
+        const out = [];
+        for (const match of runCompiledPatterns(LARAVEL_PATTERNS, tree)) {
+            const methodNode = match.captures.method;
+            const pathNode = match.captures.path;
+            if (!methodNode || !pathNode)
+                continue;
+            const path = phpStringText(pathNode);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'provider',
+                framework: 'laravel',
+                method: methodNode.text.toUpperCase(),
+                path,
+                name: 'route',
+                confidence: 0.8,
+            });
+        }
+        return out;
+    },
+};

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

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