gitnexus 1.6.0 → 1.6.2-rc.1

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;

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

@@ -0,0 +1,133 @@
+import Python from 'tree-sitter-python';
+import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
+/**
+ * Python HTTP plugin. Handles:
+ *   - FastAPI `@app.get("/path")` provider decorators
+ *   - `requests.get/post/...("url")` consumer calls
+ *   - Generic `requests.request("METHOD", "url")` consumer calls
+ */
+const FASTAPI_VERBS = {
+    get: 'GET',
+    post: 'POST',
+    put: 'PUT',
+    delete: 'DELETE',
+    patch: 'PATCH',
+};
+// ─── Provider: FastAPI @app.get/... ──────────────────────────────────
+const FASTAPI_PATTERNS = compilePatterns({
+    name: 'python-fastapi',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (decorator
+          (call
+            function: (attribute
+              object: (identifier) @obj (#eq? @obj "app")
+              attribute: (identifier) @method (#match? @method "^(get|post|put|delete|patch)$"))
+            arguments: (argument_list . (string) @path)))
+      `,
+        },
+    ],
+});
+// ─── Consumer: requests.get/post/... ──────────────────────────────────
+const REQUESTS_VERB_PATTERNS = compilePatterns({
+    name: 'python-requests-verb',
+    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 . (string) @path))
+      `,
+        },
+    ],
+});
+// ─── Consumer: requests.request("METHOD", "url") ─────────────────────
+const REQUESTS_GENERIC_PATTERNS = compilePatterns({
+    name: 'python-requests-generic',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (call
+          function: (attribute
+            object: (identifier) @obj (#eq? @obj "requests")
+            attribute: (identifier) @method (#eq? @method "request"))
+          arguments: (argument_list . (string) @http_method (string) @path))
+      `,
+        },
+    ],
+});
+export const PYTHON_HTTP_PLUGIN = {
+    name: 'python-http',
+    language: Python,
+    scan(tree) {
+        const out = [];
+        // Providers: FastAPI
+        for (const match of runCompiledPatterns(FASTAPI_PATTERNS, tree)) {
+            const methodNode = match.captures.method;
+            const pathNode = match.captures.path;
+            if (!methodNode || !pathNode)
+                continue;
+            const httpMethod = FASTAPI_VERBS[methodNode.text];
+            if (!httpMethod)
+                continue;
+            const path = unquoteLiteral(pathNode.text);
+            if (path === null)
+                continue;
+            out.push({
+                role: 'provider',
+                framework: 'fastapi',
+                method: httpMethod,
+                path,
+                name: null,
+                confidence: 0.8,
+            });
+        }
+        // Consumers: requests.<verb>
+        for (const match of runCompiledPatterns(REQUESTS_VERB_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;
+            const pathNode = match.captures.path;
+            if (!methodNode || !pathNode)
+                continue;
+            const methodRaw = unquoteLiteral(methodNode.text);
+            const path = unquoteLiteral(pathNode.text);
+            if (methodRaw === null || path === null)
+                continue;
+            out.push({
+                role: 'consumer',
+                framework: 'python-requests',
+                method: methodRaw.toUpperCase(),
+                path,
+                name: null,
+                confidence: 0.7,
+            });
+        }
+        return out;
+    },
+};

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

@@ -0,0 +1,61 @@
+import type Parser from 'tree-sitter';
+/**
+ * Shared types for the http-route-extractor language plugins.
+ *
+ * Each plugin lives in its own file (java.ts, node.ts, ...) and owns
+ * the tree-sitter grammar import + queries. The top-level
+ * `http-route-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 — language-specific knowledge
+ * belongs in the plugins.
+ */
+export type HttpRole = 'provider' | 'consumer';
+/**
+ * One raw HTTP detection produced by a plugin's `scan()` function. The
+ * orchestrator converts this into a full `ExtractedContract` by running
+ * path normalization and building the contract id.
+ *
+ * `path` is the raw literal string as it appeared in source (with
+ * `${...}` template placeholders still in place); the orchestrator
+ * runs the appropriate normalizer for provider vs. consumer paths.
+ */
+export interface HttpDetection {
+    role: HttpRole;
+    /** Short framework label, e.g. `'spring'`, `'nest'`, `'express'`. */
+    framework: string;
+    /** HTTP method in upper case (`'GET'`, `'POST'`, ...). */
+    method: string;
+    /** Raw path literal as seen in source (template placeholders intact). */
+    path: string;
+    /**
+     * Symbol name of the handler (for providers) or calling function
+     * (for consumers) when the plugin can determine it structurally.
+     * Null when no good candidate is available.
+     */
+    name: string | null;
+    /** Confidence in (0, 1]. Source-scan plugins typically use 0.7–0.8. */
+    confidence: number;
+}
+/**
+ * One language-scoped HTTP plugin. The plugin owns the tree-sitter
+ * grammar and the `scan` function that translates a parsed tree into
+ * zero or more `HttpDetection`s. Plugins are free to run multiple
+ * compiled pattern bundles internally (see the shared scanner's
+ * `runCompiledPatterns` helper).
+ *
+ * `language` is typed as `unknown` for the same reason as
+ * `LanguagePatterns.language` in `tree-sitter-scanner.ts` — the
+ * grammar modules export different shapes.
+ */
+export interface HttpLanguagePlugin {
+    /** Human-readable plugin name for diagnostics. */
+    name: string;
+    /** tree-sitter grammar object (passed to the shared parser). */
+    language: unknown;
+    /**
+     * Scan a parsed tree and return zero or more HTTP detections. Plugins
+     * must not throw — they should swallow per-match errors so a single
+     * malformed construct does not abort the whole file.
+     */
+    scan(tree: Parser.Tree): HttpDetection[];
+}

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

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

package/dist/core/group/extractors/http-route-extractor.d.ts

@@ -1,24 +1,21 @@
 import type { ContractExtractor, CypherExecutor } from '../contract-extractor.js';
 import type { ExtractedContract, RepoHandle } from '../types.js';
+/**
+ * Canonicalize a provider-side HTTP path for contract-id generation:
+ *   - strip query string
+ *   - lower-case
+ *   - drop trailing slash
+ *   - collapse `:id`, `{id}`, `[id]` path params into a single `{param}`
+ */
 export declare function normalizeHttpPath(p: string): string;
 export declare class HttpRouteExtractor implements ContractExtractor {
     type: "http";
     canExtract(_repo: RepoHandle): Promise<boolean>;
-    extract(dbExecutor: CypherExecutor | null, repoPath: string, repo: RepoHandle): Promise<ExtractedContract[]>;
+    extract(dbExecutor: CypherExecutor | null, repoPath: string, _repo: RepoHandle): Promise<ExtractedContract[]>;
+    private scanFiles;
     private extractProvidersGraph;
-    private inferMethodFromFileScan;
     private extractProvidersSourceScan;
-    private dedupeContracts;
-    private scanSpringProviders;
-    private scanExpressProviders;
-    private scanLaravelProviders;
-    private scanFastApiProviders;
-    private makeProvider;
     private extractConsumersGraph;
-    private inferFetchMethod;
     private extractConsumersSourceScan;
-    private scanFetchConsumers;
-    private templateToPattern;
-    private scanAxiosConsumers;
-    private makeConsumer;
+    private dedupeContracts;
 }