gitnexus 1.6.6-rc.75 → 1.6.6-rc.77

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

@@ -1,18 +1,26 @@
 import { createRequire } from 'node:module';
 import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
 /**
- * Kotlin HTTP plugin (Spring providers).
+ * Kotlin HTTP plugin (Spring providers + consumers).
  *
- * Mirrors the Java plugin for Spring `@RequestMapping` class prefixes
- * and `@(Get|Post|...)Mapping` method annotations on Kotlin Spring
- * Boot controllers. Both positional shorthand (`@GetMapping("/x")`)
- * and named annotation arguments (`@GetMapping(value = "/x")` and
+ * **Providers** (#1849) — Spring `@RequestMapping` class prefixes and
+ * `@(Get|Post|...)Mapping` method annotations on Kotlin Spring Boot
+ * controllers. Both positional shorthand (`@GetMapping("/x")`) and
+ * named annotation arguments (`@GetMapping(value = "/x")` and
  * `@GetMapping(path = "/x")`) are supported.
  *
- * Consumer detection (RestTemplate / WebClient / OkHttp) is intentionally
- * out of scope for this plugin — Kotlin call-site ASTs are sufficiently
- * different from Java's `method_invocation` shape that they warrant a
- * separate, focused follow-up.
+ * **Consumers** (this PR) — three call-site patterns common in Kotlin
+ * Spring projects:
+ *
+ *   1. `restTemplate.getForObject("/x", ...)` and friends
+ *   2. `webClient.get().uri("/x")` (short form, 1 verb hop + 1 uri hop)
+ *   3. `Request.Builder().url("/x")` (OkHttp)
+ *
+ * The long-form `webClient.method(HttpMethod.X).uri("/y")` chain is
+ * intentionally deferred to a follow-up: it requires walk-up logic
+ * to recover the verb from a sibling `call_expression`, and we can
+ * land 80% of real-world Kotlin Spring consumer coverage with the
+ * three simpler patterns above.
  *
  * tree-sitter-kotlin (fwcd) AST shapes used here:
  *   class_declaration
@@ -26,6 +34,20 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
  *               string_literal
  *     type_identifier                     ← class name
  *
+ * Consumer call shape (Kotlin chains everything via `navigation_expression`):
+ *   call_expression                       ← outer `.uri("/x")` or `.url("/x")`
+ *     navigation_expression
+ *       call_expression                   ← inner `.get()` / `Request.Builder()` / `restTemplate.x`
+ *         navigation_expression
+ *           simple_identifier             ← receiver: `webClient` / `Request` / `restTemplate`
+ *           navigation_suffix             ← `.method` / `.Builder` / `.getForObject`
+ *         call_suffix (value_arguments)
+ *       navigation_suffix                 ← `.uri` / `.url`
+ *     call_suffix
+ *       value_arguments
+ *         value_argument
+ *           string_literal                ← the path
+ *
  * tree-sitter-kotlin is an optional npm dependency — when its native
  * binding is unavailable the plugin gracefully exports `null` and
  * `http-patterns/index.ts` skips registration for `.kt`/`.kts` files.
@@ -46,6 +68,34 @@ const METHOD_ANNOTATION_TO_HTTP = {
     DeleteMapping: 'DELETE',
     PatchMapping: 'PATCH',
 };
+/**
+ * RestTemplate method-name → HTTP verb. Mirrors the Java plugin's
+ * `REST_TEMPLATE_TO_HTTP` (java.ts) so a polyglot repo emits the
+ * same contract IDs from .java and .kt sources.
+ */
+const REST_TEMPLATE_TO_HTTP = {
+    getForObject: 'GET',
+    getForEntity: 'GET',
+    postForObject: 'POST',
+    postForEntity: 'POST',
+    put: 'PUT',
+    delete: 'DELETE',
+    patchForObject: 'PATCH',
+};
+/**
+ * WebClient short-form verb → HTTP verb. The reactive WebClient API
+ * exposes `.get()`, `.post()`, `.put()`, `.delete()`, `.patch()` as
+ * one-liners that return a `RequestHeadersUriSpec` whose `.uri(...)`
+ * carries the path. We capture both pieces in a single query (see
+ * `WEB_CLIENT_SHORT_PATTERNS` below) and translate the verb here.
+ */
+const WEB_CLIENT_SHORT_TO_HTTP = {
+    get: 'GET',
+    post: 'POST',
+    put: 'PUT',
+    delete: 'DELETE',
+    patch: 'PATCH',
+};
 /**
  * Build the plugin only if the Kotlin grammar is available. Compiling
  * the queries against a null grammar would throw at module load time
@@ -144,6 +194,127 @@ function buildKotlinPlugin(language) {
             },
         ],
     });
+    // ─── Consumer: Spring RestTemplate ────────────────────────────────────
+    // Kotlin call-site shape mirrors the Java plugin's
+    // `REST_TEMPLATE_PATTERNS`, but goes through tree-sitter-kotlin's
+    // `navigation_expression` instead of Java's `method_invocation`:
+    //
+    //   restTemplate.getForObject("/x", User::class.java)
+    //
+    // becomes
+    //
+    //   call_expression
+    //     navigation_expression
+    //       simple_identifier "restTemplate"
+    //       navigation_suffix → simple_identifier "getForObject"
+    //     call_suffix
+    //       value_arguments
+    //         value_argument . string_literal "/x"   ← captured
+    //         value_argument User::class.java
+    //
+    // The receiver name is constrained to `restTemplate` (#eq? @obj),
+    // matching the Java plugin's heuristic. This means a non-conventional
+    // field name (e.g. `userServiceTemplate`) will not be picked up;
+    // that's the same trade-off already accepted on the Java side.
+    const REST_TEMPLATE_PATTERNS = compilePatterns({
+        name: 'kotlin-rest-template',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (call_expression
+            (navigation_expression
+              (simple_identifier) @obj (#eq? @obj "restTemplate")
+              (navigation_suffix (simple_identifier) @method))
+            (call_suffix
+              (value_arguments . (value_argument . (string_literal) @path))))
+        `,
+            },
+        ],
+    });
+    // ─── Consumer: Spring WebClient (short form) ──────────────────────────
+    // Reactive WebClient exposes one-liner verb helpers:
+    //
+    //   webClient.get().uri("/x").retrieve().awaitBody<T>()
+    //   webClient.post().uri("/x")...
+    //
+    // The chain `webClient.get().uri("/x")` parses as two nested
+    // `call_expression` nodes — the OUTER call is `.uri("/x")` and the
+    // INNER call is `webClient.get()`. We anchor on the outer call and
+    // require:
+    //   - inner receiver is `webClient`
+    //   - inner suffix is one of the HTTP verbs (#match?)
+    //   - outer suffix is exactly `uri`
+    //   - outer call's first value_argument is a string literal
+    //
+    // The long-form `webClient.method(HttpMethod.GET).uri("/x")` chain
+    // uses an extra navigation hop and an enum field access — it's
+    // intentionally out of scope here (see file header).
+    const WEB_CLIENT_SHORT_PATTERNS = compilePatterns({
+        name: 'kotlin-web-client-short',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (call_expression
+            (navigation_expression
+              (call_expression
+                (navigation_expression
+                  (simple_identifier) @obj (#eq? @obj "webClient")
+                  (navigation_suffix
+                    (simple_identifier) @verb (#match? @verb "^(get|post|put|delete|patch)$")))
+                (call_suffix (value_arguments)))
+              (navigation_suffix (simple_identifier) @uri (#eq? @uri "uri")))
+            (call_suffix
+              (value_arguments . (value_argument . (string_literal) @path))))
+        `,
+            },
+        ],
+    });
+    // ─── Consumer: OkHttp Request.Builder().url("/x") ─────────────────────
+    // Kotlin parses `Request.Builder()` as a `call_expression` whose
+    // callee is a `navigation_expression` (Request → .Builder), NOT as
+    // Java's `object_creation_expression`. The chain `.url("/x")` then
+    // wraps that in another `call_expression`. The query mirrors Java's
+    // `OK_HTTP_PATTERNS` (java.ts) but adapts the node types.
+    //
+    // Receiver `Request` is constrained by name (#eq? @cls); a project
+    // that imports OkHttp's `Request` under an alias (`import okhttp3.Request as OkRequest`)
+    // would not be picked up — this matches the Java plugin's heuristic.
+    //
+    // **Known limitation — verb defaults to GET.** OkHttp encodes the
+    // verb on a *sibling* call further down the builder chain (e.g.
+    // `.post(body)` / `.get()` / `.delete()`), not on `.url(...)` itself.
+    // This query intentionally does not walk the chain to recover the
+    // verb — it emits `method: 'GET'` for every match, mirroring
+    // `java.ts:OK_HTTP_PATTERNS`. So a `Request.Builder().url("/x").post(body).build()`
+    // call becomes `http::GET::/x`, not `http::POST::/x`. This is the
+    // same trade-off Java has accepted; pinned by an anti-overreach
+    // test in `http-route-extractor.test.ts` so a future verb-walk
+    // implementation has to update this comment in lockstep.
+    const OK_HTTP_PATTERNS = compilePatterns({
+        name: 'kotlin-okhttp',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (call_expression
+            (navigation_expression
+              (call_expression
+                (navigation_expression
+                  (simple_identifier) @cls (#eq? @cls "Request")
+                  (navigation_suffix (simple_identifier) @builder (#eq? @builder "Builder")))
+                (call_suffix (value_arguments)))
+              (navigation_suffix (simple_identifier) @method (#eq? @method "url")))
+            (call_suffix
+              (value_arguments . (value_argument . (string_literal) @path))))
+        `,
+            },
+        ],
+    });
     /**
      * Find the nearest enclosing class_declaration ancestor for a node, or
      * null if the node is top-level. Mirrors the Java plugin's helper.
@@ -212,6 +383,65 @@ function buildKotlinPlugin(language) {
                     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 short form (.get()/.post()/etc → .uri) ─
+            for (const match of runCompiledPatterns(WEB_CLIENT_SHORT_PATTERNS, tree)) {
+                const verbNode = match.captures.verb;
+                const pathNode = match.captures.path;
+                if (!verbNode || !pathNode)
+                    continue;
+                const httpMethod = WEB_CLIENT_SHORT_TO_HTTP[verbNode.text];
+                if (!httpMethod)
+                    continue;
+                const path = unquoteLiteral(pathNode.text);
+                if (path === null)
+                    continue;
+                out.push({
+                    role: 'consumer',
+                    framework: 'spring-web-client',
+                    method: httpMethod,
+                    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/ingestion/languages/python/captures.js

@@ -19,6 +19,7 @@ import { findNodeAtRange, nodeToCapture, syntheticCapture } from '../../utils/as
 import { splitImportStatement } from './import-decomposer.js';
 import { getPythonParser, getPythonScopeQuery } from './query.js';
 import { synthesizeReceiverTypeBinding } from './receiver-binding.js';
+import { synthesizeDependsReferences } from './depends-references.js';
 import { computePythonArityMetadata } from './arity-metadata.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
@@ -88,6 +89,8 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
                 const synth = synthesizeReceiverTypeBinding(fnNode);
                 if (synth !== null)
                     out.push(synth);
+                for (const depRef of synthesizeDependsReferences(fnNode))
+                    out.push(depRef);
             }
             continue;
         }

package/dist/core/ingestion/languages/python/depends-references.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Synthesize `@reference.call.free` captures for FastAPI `Depends(callable)`
+ * parameter defaults.
+ *
+ * `Depends(get_db)` passes `get_db` as a callable that the DI framework
+ * calls on every request. The route handler is functionally a caller of
+ * the dependency — impact analysis needs that edge.
+ *
+ * Tree-sitter can't express "the first argument of a call named Depends
+ * inside a parameter default" in a single static query, so we synthesize
+ * reference captures in code, mirroring the receiver-binding pattern.
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/**
+ * Inspect a `function_definition` node's parameters for `Depends(callable)`
+ * defaults. Returns one `@reference.call.free` CaptureMatch per dependency.
+ */
+export declare function synthesizeDependsReferences(fnNode: SyntaxNode): readonly CaptureMatch[];

package/dist/core/ingestion/languages/python/depends-references.js

@@ -0,0 +1,65 @@
+/**
+ * Synthesize `@reference.call.free` captures for FastAPI `Depends(callable)`
+ * parameter defaults.
+ *
+ * `Depends(get_db)` passes `get_db` as a callable that the DI framework
+ * calls on every request. The route handler is functionally a caller of
+ * the dependency — impact analysis needs that edge.
+ *
+ * Tree-sitter can't express "the first argument of a call named Depends
+ * inside a parameter default" in a single static query, so we synthesize
+ * reference captures in code, mirroring the receiver-binding pattern.
+ */
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+/**
+ * Inspect a `function_definition` node's parameters for `Depends(callable)`
+ * defaults. Returns one `@reference.call.free` CaptureMatch per dependency.
+ */
+export function synthesizeDependsReferences(fnNode) {
+    const params = fnNode.childForFieldName('parameters');
+    if (params === null)
+        return [];
+    const results = [];
+    for (let i = 0; i < params.namedChildCount; i++) {
+        const param = params.namedChild(i);
+        if (param === null)
+            continue;
+        if (param.type !== 'typed_default_parameter' && param.type !== 'default_parameter') {
+            continue;
+        }
+        const defaultValue = param.childForFieldName('value') ?? param.childForFieldName('default');
+        if (defaultValue === null)
+            continue;
+        const callNode = defaultValue.type === 'call' ? defaultValue : null;
+        if (callNode === null)
+            continue;
+        const fnIdent = callNode.childForFieldName('function');
+        if (fnIdent === null || fnIdent.type !== 'identifier' || fnIdent.text !== 'Depends')
+            continue;
+        const args = callNode.childForFieldName('arguments');
+        if (args === null || args.namedChildCount === 0)
+            continue;
+        const firstArg = args.namedChild(0);
+        if (firstArg === null)
+            continue;
+        if (firstArg.type === 'identifier') {
+            results.push({
+                '@reference.call.free': nodeToCapture('@reference.call.free', firstArg),
+                '@reference.name': nodeToCapture('@reference.name', firstArg),
+            });
+            continue;
+        }
+        if (firstArg.type === 'attribute') {
+            const attrName = firstArg.childForFieldName('attribute');
+            const obj = firstArg.childForFieldName('object');
+            if (attrName !== null && obj !== null) {
+                results.push({
+                    '@reference.call.member': nodeToCapture('@reference.call.member', attrName),
+                    '@reference.name': nodeToCapture('@reference.name', attrName),
+                    '@reference.receiver': nodeToCapture('@reference.receiver', obj),
+                });
+            }
+        }
+    }
+    return results;
+}

package/dist/core/ingestion/parsing-processor.d.ts

@@ -3,7 +3,7 @@ import type { SymbolTableWriter, ExtractedHeritage } from './model/index.js';
 import { ASTCache } from './ast-cache.js';
 import type { ParsedFile } from '../../_shared/index.js';
 import { WorkerPool } from './workers/worker-pool.js';
-import type { ParseWorkerResult, ExtractedImport, ExtractedCall, ExtractedAssignment, ExtractedRoute, ExtractedFetchCall, ExtractedDecoratorRoute, ExtractedToolDef, FileConstructorBindings, FileScopeBindings, ExtractedORMQuery } from './workers/parse-worker.js';
+import type { ParseWorkerResult, ExtractedImport, ExtractedCall, ExtractedAssignment, ExtractedRoute, ExtractedFetchCall, ExtractedDecoratorRoute, ExtractedToolDef, FileConstructorBindings, FileScopeBindings, ExtractedORMQuery, FetchWrapperDef } from './workers/parse-worker.js';
 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
 export interface WorkerExtractedData {
     imports: ExtractedImport[];
@@ -12,6 +12,7 @@ export interface WorkerExtractedData {
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
     fetchCalls: ExtractedFetchCall[];
+    fetchWrapperDefs: FetchWrapperDef[];
     decoratorRoutes: ExtractedDecoratorRoute[];
     toolDefs: ExtractedToolDef[];
     ormQueries: ExtractedORMQuery[];

package/dist/core/ingestion/parsing-processor.js

@@ -35,6 +35,7 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults) => {
     const allHeritage = [];
     const allRoutes = [];
     const allFetchCalls = [];
+    const allFetchWrapperDefs = [];
     const allDecoratorRoutes = [];
     const allToolDefs = [];
     const allORMQueries = [];
@@ -77,6 +78,8 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults) => {
             allRoutes.push(item);
         for (const item of result.fetchCalls)
             allFetchCalls.push(item);
+        for (const item of result.fetchWrapperDefs ?? [])
+            allFetchWrapperDefs.push(item);
         for (const item of result.decoratorRoutes)
             allDecoratorRoutes.push(item);
         for (const item of result.toolDefs)
@@ -100,6 +103,7 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults) => {
         heritage: allHeritage,
         routes: allRoutes,
         fetchCalls: allFetchCalls,
+        fetchWrapperDefs: allFetchWrapperDefs,
         decoratorRoutes: allDecoratorRoutes,
         toolDefs: allToolDefs,
         ormQueries: allORMQueries,
@@ -132,6 +136,7 @@ outRawResults) => {
             heritage: [],
             routes: [],
             fetchCalls: [],
+            fetchWrapperDefs: [],
             decoratorRoutes: [],
             toolDefs: [],
             ormQueries: [],

package/dist/core/ingestion/pipeline-phases/parse-impl.d.ts

@@ -16,7 +16,7 @@ import { type ExportedTypeMap } from '../call-processor.js';
 import { createResolutionContext } from '../model/resolution-context.js';
 import { ASTCache } from '../ast-cache.js';
 import { type PipelineProgress } from '../../../_shared/index.js';
-import type { ExtractedDecoratorRoute, ExtractedFetchCall, ExtractedORMQuery, ExtractedRoute, ExtractedToolDef } from '../workers/parse-worker.js';
+import type { ExtractedDecoratorRoute, ExtractedFetchCall, ExtractedORMQuery, ExtractedRoute, ExtractedToolDef, FetchWrapperDef } from '../workers/parse-worker.js';
 import type { KnowledgeGraph } from '../../graph/types.js';
 import type { PipelineOptions } from '../pipeline.js';
 type ScannedFile = {
@@ -38,6 +38,7 @@ type ProgressFn = (progress: PipelineProgress) => void;
 export declare function runChunkedParseAndResolve(graph: KnowledgeGraph, scannedFiles: ScannedFile[], allPaths: string[], totalFiles: number, repoPath: string, pipelineStart: number, onProgress: ProgressFn, options?: PipelineOptions): Promise<{
     exportedTypeMap: ExportedTypeMap;
     allFetchCalls: ExtractedFetchCall[];
+    allFetchWrapperDefs: FetchWrapperDef[];
     allExtractedRoutes: ExtractedRoute[];
     allDecoratorRoutes: ExtractedDecoratorRoute[];
     allToolDefs: ExtractedToolDef[];

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -234,6 +234,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     // it, and later wildcard chunks re-run it themselves.
     let hasSynthesized = false;
     const allFetchCalls = [];
+    const allFetchWrapperDefs = [];
     const allExtractedRoutes = [];
     const allDecoratorRoutes = [];
     const allToolDefs = [];
@@ -530,6 +531,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     for (const item of chunkWorkerData.fetchCalls)
                         allFetchCalls.push(item);
                 }
+                if (chunkWorkerData.fetchWrapperDefs?.length) {
+                    for (const item of chunkWorkerData.fetchWrapperDefs)
+                        allFetchWrapperDefs.push(item);
+                }
                 if (chunkWorkerData.routes?.length) {
                     for (const item of chunkWorkerData.routes)
                         allExtractedRoutes.push(item);
@@ -876,6 +881,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     return {
         exportedTypeMap,
         allFetchCalls,
+        allFetchWrapperDefs,
         allExtractedRoutes,
         allDecoratorRoutes,
         allToolDefs,

package/dist/core/ingestion/pipeline-phases/parse.d.ts

@@ -18,7 +18,7 @@
 import type { PipelinePhase } from './types.js';
 import type { BindingAccumulator } from '../binding-accumulator.js';
 import type { ParsedFile } from '../../../_shared/index.js';
-import type { ExtractedFetchCall, ExtractedRoute, ExtractedDecoratorRoute, ExtractedToolDef, ExtractedORMQuery } from '../workers/parse-worker.js';
+import type { ExtractedFetchCall, ExtractedRoute, ExtractedDecoratorRoute, ExtractedToolDef, ExtractedORMQuery, FetchWrapperDef } from '../workers/parse-worker.js';
 import type { createResolutionContext } from '../model/resolution-context.js';
 import type { ASTCache } from '../ast-cache.js';
 export interface ParseOutput {
@@ -34,6 +34,7 @@ export interface ParseOutput {
      */
     readonly exportedTypeMap: ReadonlyMap<string, ReadonlyMap<string, string>>;
     readonly allFetchCalls: readonly ExtractedFetchCall[];
+    readonly allFetchWrapperDefs: readonly FetchWrapperDef[];
     readonly allExtractedRoutes: readonly ExtractedRoute[];
     readonly allDecoratorRoutes: readonly ExtractedDecoratorRoute[];
     readonly allToolDefs: readonly ExtractedToolDef[];

package/dist/core/ingestion/pipeline-phases/routes.js

@@ -94,11 +94,14 @@ export function normalizeExtractedRoutePath(routePath, prefix) {
     const joined = prefixPart ? `/${prefixPart}${pathPart ? `/${pathPart}` : ''}` : `/${pathPart}`;
     return joined.replace(/\/+/g, '/') || '/';
 }
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 export const routesPhase = {
     name: 'routes',
     deps: ['parse'],
     async execute(ctx, deps) {
-        const { allPaths, allFetchCalls: parseFetchCalls, allExtractedRoutes, allDecoratorRoutes, } = getPhaseOutput(deps, 'parse');
+        const { allPaths, allFetchCalls: parseFetchCalls, allFetchWrapperDefs, allExtractedRoutes, allDecoratorRoutes, } = getPhaseOutput(deps, 'parse');
         // Local copy — routes phase must not mutate upstream ParseOutput
         const allFetchCalls = [...parseFetchCalls];
         const routeRegistry = new Map();
@@ -289,6 +292,31 @@ export const routesPhase = {
                 }
             }
         }
+        // ── Cross-file fetch wrapper consumer extraction ──
+        // When the parse phase discovered functions that internally call fetch(),
+        // scan JS/TS consumer files for calls to those wrapper functions with
+        // URL-like string arguments and add them to allFetchCalls so
+        // processNextjsFetchRoutes can create FETCHES edges.
+        if (allFetchWrapperDefs && allFetchWrapperDefs.length > 0 && routeRegistry.size > 0) {
+            const wrapperNames = new Set(allFetchWrapperDefs.map((d) => d.functionName));
+            const jsFiles = allPaths.filter((p) => /\.[jt]sx?$/.test(p));
+            if (jsFiles.length > 0 && wrapperNames.size > 0) {
+                const jsContents = await readFileContents(ctx.repoPath, jsFiles);
+                for (const [filePath, content] of jsContents) {
+                    for (const name of wrapperNames) {
+                        const regex = new RegExp(`\\b${escapeRegex(name)}\\s*\\(\\s*['"\`](/[^'"\`\\s)]+)['"\`]`, 'g');
+                        let match;
+                        while ((match = regex.exec(content)) !== null) {
+                            allFetchCalls.push({
+                                filePath,
+                                fetchURL: match[1],
+                                lineNumber: content.substring(0, match.index).split('\n').length,
+                            });
+                        }
+                    }
+                }
+            }
+        }
         if (routeRegistry.size > 0 && allFetchCalls.length > 0) {
             const routeURLToFile = new Map();
             for (const [url, entry] of routeRegistry)

package/dist/core/ingestion/tree-sitter-queries.d.ts

@@ -1,5 +1,5 @@
-export declare const TYPESCRIPT_QUERIES = "\n(class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(abstract_class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(interface_declaration\n  name: (type_identifier) @name) @definition.interface\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n; TypeScript overload signatures (function_signature is a separate node type from function_declaration)\n(function_signature\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n; ES2022 #private methods (private_property_identifier not matched by property_identifier)\n(method_definition\n  name: (private_property_identifier) @name) @definition.method\n\n; Abstract method signatures in abstract classes\n(abstract_method_signature\n  name: (property_identifier) @name) @definition.method\n\n; Interface method signatures\n(method_signature\n  name: (property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n; Object-property arrows / function expressions: `{ addItem: () => ... }`.\n; The pair's key field carries the meaningful name. Without these patterns,\n; calls inside the arrow are attributed to the file (issue #1166), and the\n; arrow itself is invisible to context() / impact() despite carrying real\n; behaviour (Zustand actions, TanStack queryFn, React Context providers).\n; String-key variant covers `\"add-item\": () => ...`; computed keys\n; (`[K]: () => ...`) intentionally fall through anonymous.\n(pair\n  key: (property_identifier) @name\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (property_identifier) @name\n  value: (function_expression)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (function_expression)) @definition.function\n\n; HOC-wrapped variable declarations: `const X = HOC((args) => { ... })`.\n; Mirrors the registry-primary patterns in `languages/typescript/query.ts`\n; so the legacy Call-Resolution DAG and the registry-primary pipeline\n; produce the same set of `Function` nodes \u2014 required for the CI parity\n; gate. Covers React.forwardRef / memo / useCallback / useMemo / observer\n; / debounce / user-defined HOC factories. The `var X = HOC(...)` form is\n; mirrored too (registry-primary has it) so that codebases mixing `var` and\n; `const` see identical attribution on both pipelines. See\n; `tsExtractFunctionName` for the resolution logic and the `query.ts`\n; comment for the full anchor-discipline rationale and the chained-\n; array-method trade-off.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (arrow_function)))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (function_expression)))))) @definition.function\n\n; `var X = HOC(...)` parity with registry-primary. Legacy code (and any\n; transpiler output that downlevels `const` to `var`) hits this shape.\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n; Variable/constant declarations (non-function values).\n; Overlap with @definition.function patterns is handled by parse-worker dedup.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name))) @definition.const\n\n; var declarations (mutable, function-scoped)\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Generic awaited free call: await fn<T>(args)\n; tree-sitter-typescript parses \"await fn<T>(args)\" as a call_expression whose\n; \"function\" field is an await_expression (not a bare identifier), because the\n; grammar resolves the ambiguity between generics and comparisons by consuming\n; \"await fn\" as an expression before attaching <T> as type_arguments.\n(call_expression\n  function: (await_expression\n    (identifier) @call.name)\n  (type_arguments)) @call\n\n; Generic awaited member call: await obj.fn<T>(args)\n(call_expression\n  function: (await_expression\n    (member_expression\n      property: (property_identifier) @call.name))\n  (type_arguments)) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Class properties \u2014 public_field_definition covers most TS class fields\n(public_field_definition\n  name: (property_identifier) @name) @definition.property\n\n; Private class fields: #address: Address\n(public_field_definition\n  name: (private_property_identifier) @name) @definition.property\n\n; Constructor parameter properties: constructor(public address: Address)\n(required_parameter\n  (accessibility_modifier)\n  pattern: (identifier) @name) @definition.property\n\n; Heritage queries - class extends\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (extends_clause\n      value: (identifier) @heritage.extends))) @heritage\n\n; Heritage queries - class implements interface\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (implements_clause\n      (type_identifier) @heritage.implements))) @heritage.impl\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; HTTP consumers: fetch('/path'), axios.get('/path'), $.get('/path'), etc.\n; fetch() \u2014 global function\n(call_expression\n  function: (identifier) @_fetch_fn (#eq? @_fetch_fn \"fetch\")\n  arguments: (arguments\n    [(string (string_fragment) @route.url)\n     (template_string) @route.template_url])) @route.fetch\n\n; axios.get/post/put/delete/patch('/path'), $.get/post/ajax({url:'/path'})\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @http_client.method)\n  arguments: (arguments\n    (string (string_fragment) @http_client.url))) @http_client\n\n; Decorators: @Controller, @Get, @Post, etc.\n(decorator\n  (call_expression\n    function: (identifier) @decorator.name\n    arguments: (arguments (string (string_fragment) @decorator.arg)?))) @decorator\n\n; Express/Hono route registration: app.get('/path', handler), router.post('/path', fn)\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @express_route.method)\n  arguments: (arguments\n    (string (string_fragment) @express_route.path))) @express_route\n";
-export declare const JAVASCRIPT_QUERIES = "\n(class_declaration\n  name: (identifier) @name) @definition.class\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n; ES2022 #private methods\n(method_definition\n  name: (private_property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n; Object-property arrows / function expressions: `{ addItem: () => ... }`.\n; See TYPESCRIPT_QUERIES for rationale (issue #1166).\n(pair\n  key: (property_identifier) @name\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (property_identifier) @name\n  value: (function_expression)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (function_expression)) @definition.function\n\n; HOC-wrapped variable declarations: `const X = HOC((args) => { ... })`.\n; See TYPESCRIPT_QUERIES section above for the full rationale (issue #1166\n; follow-up \u2014 covers forwardRef / memo / useCallback / useMemo / observer\n; / debounce / user-defined HOC factories). Both `const` and `var` forms\n; are mirrored so JS code that uses `var` (or transpiler output) gets the\n; same attribution as the registry-primary path.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (arrow_function)))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (function_expression)))))) @definition.function\n\n; `var X = HOC(...)` parity with registry-primary.\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n; Variable/constant declarations (non-function values).\n; Overlap with @definition.function patterns is handled by parse-worker dedup.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name))) @definition.const\n\n; var declarations (mutable, function-scoped)\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Class fields \u2014 field_definition captures JS class fields (class User { address = ... })\n(field_definition\n  property: (property_identifier) @name) @definition.property\n\n; Heritage queries - class extends (JavaScript uses different AST than TypeScript)\n; In tree-sitter-javascript, class_heritage directly contains the parent identifier\n(class_declaration\n  name: (identifier) @heritage.class\n  (class_heritage\n    (identifier) @heritage.extends)) @heritage\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; HTTP consumers: fetch('/path'), axios.get('/path'), $.get('/path'), etc.\n(call_expression\n  function: (identifier) @_fetch_fn (#eq? @_fetch_fn \"fetch\")\n  arguments: (arguments\n    [(string (string_fragment) @route.url)\n     (template_string) @route.template_url])) @route.fetch\n\n; axios.get/post, $.get/post/ajax\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @http_client.method)\n  arguments: (arguments\n    (string (string_fragment) @http_client.url))) @http_client\n\n; Express/Hono route registration\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @express_route.method)\n  arguments: (arguments\n    (string (string_fragment) @express_route.path))) @express_route\n";
+export declare const TYPESCRIPT_QUERIES = "\n(class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(abstract_class_declaration\n  name: (type_identifier) @name) @definition.class\n\n(interface_declaration\n  name: (type_identifier) @name) @definition.interface\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n; TypeScript overload signatures (function_signature is a separate node type from function_declaration)\n(function_signature\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n; ES2022 #private methods (private_property_identifier not matched by property_identifier)\n(method_definition\n  name: (private_property_identifier) @name) @definition.method\n\n; Abstract method signatures in abstract classes\n(abstract_method_signature\n  name: (property_identifier) @name) @definition.method\n\n; Interface method signatures\n(method_signature\n  name: (property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n; Object-property arrows / function expressions: `{ addItem: () => ... }`.\n; The pair's key field carries the meaningful name. Without these patterns,\n; calls inside the arrow are attributed to the file (issue #1166), and the\n; arrow itself is invisible to context() / impact() despite carrying real\n; behaviour (Zustand actions, TanStack queryFn, React Context providers).\n; String-key variant covers `\"add-item\": () => ...`; computed keys\n; (`[K]: () => ...`) intentionally fall through anonymous.\n(pair\n  key: (property_identifier) @name\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (property_identifier) @name\n  value: (function_expression)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (function_expression)) @definition.function\n\n; HOC-wrapped variable declarations: `const X = HOC((args) => { ... })`.\n; Mirrors the registry-primary patterns in `languages/typescript/query.ts`\n; so the legacy Call-Resolution DAG and the registry-primary pipeline\n; produce the same set of `Function` nodes \u2014 required for the CI parity\n; gate. Covers React.forwardRef / memo / useCallback / useMemo / observer\n; / debounce / user-defined HOC factories. The `var X = HOC(...)` form is\n; mirrored too (registry-primary has it) so that codebases mixing `var` and\n; `const` see identical attribution on both pipelines. See\n; `tsExtractFunctionName` for the resolution logic and the `query.ts`\n; comment for the full anchor-discipline rationale and the chained-\n; array-method trade-off.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (arrow_function)))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (function_expression)))))) @definition.function\n\n; `var X = HOC(...)` parity with registry-primary. Legacy code (and any\n; transpiler output that downlevels `const` to `var`) hits this shape.\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n; Variable/constant declarations (non-function values).\n; Overlap with @definition.function patterns is handled by parse-worker dedup.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name))) @definition.const\n\n; var declarations (mutable, function-scoped)\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Generic awaited free call: await fn<T>(args)\n; tree-sitter-typescript parses \"await fn<T>(args)\" as a call_expression whose\n; \"function\" field is an await_expression (not a bare identifier), because the\n; grammar resolves the ambiguity between generics and comparisons by consuming\n; \"await fn\" as an expression before attaching <T> as type_arguments.\n(call_expression\n  function: (await_expression\n    (identifier) @call.name)\n  (type_arguments)) @call\n\n; Generic awaited member call: await obj.fn<T>(args)\n(call_expression\n  function: (await_expression\n    (member_expression\n      property: (property_identifier) @call.name))\n  (type_arguments)) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Class properties \u2014 public_field_definition covers most TS class fields\n(public_field_definition\n  name: (property_identifier) @name) @definition.property\n\n; Private class fields: #address: Address\n(public_field_definition\n  name: (private_property_identifier) @name) @definition.property\n\n; Constructor parameter properties: constructor(public address: Address)\n(required_parameter\n  (accessibility_modifier)\n  pattern: (identifier) @name) @definition.property\n\n; Heritage queries - class extends\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (extends_clause\n      value: (identifier) @heritage.extends))) @heritage\n\n; Heritage queries - class implements interface\n(class_declaration\n  name: (type_identifier) @heritage.class\n  (class_heritage\n    (implements_clause\n      (type_identifier) @heritage.implements))) @heritage.impl\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; HTTP consumers: fetch('/path'), axios.get('/path'), $.get('/path'), etc.\n; fetch() \u2014 global function\n(call_expression\n  function: (identifier) @_fetch_fn (#eq? @_fetch_fn \"fetch\")\n  arguments: (arguments\n    [(string (string_fragment) @route.url)\n     (template_string) @route.template_url])) @route.fetch\n\n; Custom fetch wrappers: apiFetch('/path'), fetchJSON('/api/data'), httpGet('/users'), etc.\n(call_expression\n  function: (identifier) @_wrapper_fn (#match? @_wrapper_fn \"^(api(Fetch|Get|Post|Put|Delete|Patch|Request)|fetch(API|JSON|Data|Endpoint|Resource|Url)|http(Fetch|Get|Post|Put|Delete|Patch|Request))$\")\n  arguments: (arguments\n    (string (string_fragment) @route.url))) @route.fetch\n\n; axios.get/post/put/delete/patch('/path'), $.get/post/ajax({url:'/path'})\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @http_client.method)\n  arguments: (arguments\n    (string (string_fragment) @http_client.url))) @http_client\n\n; Decorators: @Controller, @Get, @Post, etc.\n(decorator\n  (call_expression\n    function: (identifier) @decorator.name\n    arguments: (arguments (string (string_fragment) @decorator.arg)?))) @decorator\n\n; Express/Hono route registration: app.get('/path', handler), router.post('/path', fn)\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @express_route.method)\n  arguments: (arguments\n    (string (string_fragment) @express_route.path))) @express_route\n";
+export declare const JAVASCRIPT_QUERIES = "\n(class_declaration\n  name: (identifier) @name) @definition.class\n\n(function_declaration\n  name: (identifier) @name) @definition.function\n\n(method_definition\n  name: (property_identifier) @name) @definition.method\n\n; ES2022 #private methods\n(method_definition\n  name: (private_property_identifier) @name) @definition.method\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (arrow_function))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (function_expression))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (arrow_function)))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (function_expression)))) @definition.function\n\n; Object-property arrows / function expressions: `{ addItem: () => ... }`.\n; See TYPESCRIPT_QUERIES for rationale (issue #1166).\n(pair\n  key: (property_identifier) @name\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (property_identifier) @name\n  value: (function_expression)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (arrow_function)) @definition.function\n\n(pair\n  key: (string (string_fragment) @name)\n  value: (function_expression)) @definition.function\n\n; HOC-wrapped variable declarations: `const X = HOC((args) => { ... })`.\n; See TYPESCRIPT_QUERIES section above for the full rationale (issue #1166\n; follow-up \u2014 covers forwardRef / memo / useCallback / useMemo / observer\n; / debounce / user-defined HOC factories). Both `const` and `var` forms\n; are mirrored so JS code that uses `var` (or transpiler output) gets the\n; same attribution as the registry-primary path.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (arrow_function)))))) @definition.function\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name\n      value: (call_expression\n        arguments: (arguments\n          (function_expression)))))) @definition.function\n\n; `var X = HOC(...)` parity with registry-primary.\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (arrow_function))))) @definition.function\n\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name\n    value: (call_expression\n      arguments: (arguments\n        (function_expression))))) @definition.function\n\n; Variable/constant declarations (non-function values).\n; Overlap with @definition.function patterns is handled by parse-worker dedup.\n(lexical_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.const\n\n(export_statement\n  declaration: (lexical_declaration\n    (variable_declarator\n      name: (identifier) @name))) @definition.const\n\n; var declarations (mutable, function-scoped)\n(variable_declaration\n  (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n(import_statement\n  source: (string) @import.source) @import\n\n; Re-export statements: export { X } from './y'\n(export_statement\n  source: (string) @import.source) @import\n\n(call_expression\n  function: (identifier) @call.name) @call\n\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @call.name)) @call\n\n; Constructor calls: new Foo()\n(new_expression\n  constructor: (identifier) @call.name) @call\n\n; Class fields \u2014 field_definition captures JS class fields (class User { address = ... })\n(field_definition\n  property: (property_identifier) @name) @definition.property\n\n; Heritage queries - class extends (JavaScript uses different AST than TypeScript)\n; In tree-sitter-javascript, class_heritage directly contains the parent identifier\n(class_declaration\n  name: (identifier) @heritage.class\n  (class_heritage\n    (identifier) @heritage.extends)) @heritage\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment_expression\n  left: (member_expression\n    object: (_) @assignment.receiver\n    property: (property_identifier) @assignment.property)\n  right: (_)) @assignment\n\n; HTTP consumers: fetch('/path'), axios.get('/path'), $.get('/path'), etc.\n(call_expression\n  function: (identifier) @_fetch_fn (#eq? @_fetch_fn \"fetch\")\n  arguments: (arguments\n    [(string (string_fragment) @route.url)\n     (template_string) @route.template_url])) @route.fetch\n\n; Custom fetch wrappers: apiFetch('/path'), fetchJSON('/api/data'), httpGet('/users'), etc.\n(call_expression\n  function: (identifier) @_wrapper_fn (#match? @_wrapper_fn \"^(api(Fetch|Get|Post|Put|Delete|Patch|Request)|fetch(API|JSON|Data|Endpoint|Resource|Url)|http(Fetch|Get|Post|Put|Delete|Patch|Request))$\")\n  arguments: (arguments\n    (string (string_fragment) @route.url))) @route.fetch\n\n; axios.get/post, $.get/post/ajax\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @http_client.method)\n  arguments: (arguments\n    (string (string_fragment) @http_client.url))) @http_client\n\n; Express/Hono route registration\n(call_expression\n  function: (member_expression\n    property: (property_identifier) @express_route.method)\n  arguments: (arguments\n    (string (string_fragment) @express_route.path))) @express_route\n";
 export declare const PYTHON_QUERIES = "\n(class_definition\n  name: (identifier) @name) @definition.class\n\n(function_definition\n  name: (identifier) @name) @definition.function\n\n(import_statement\n  name: (dotted_name) @import.source) @import\n\n; import numpy as np  \u2192  aliased_import captures the module name so the\n; import path is resolved and named-binding extraction stores \"np\" \u2192 \"numpy\".\n(import_statement\n  name: (aliased_import\n    name: (dotted_name) @import.source)) @import\n\n(import_from_statement\n  module_name: (dotted_name) @import.source) @import\n\n(import_from_statement\n  module_name: (relative_import) @import.source) @import\n\n(call\n  function: (identifier) @call.name) @call\n\n(call\n  function: (attribute\n    attribute: (identifier) @call.name)) @call\n\n; Class attribute type annotations \u2014 PEP 526: address: Address or address: Address = Address()\n; Both bare annotations (address: Address) and annotated assignments (name: str = \"test\")\n; are parsed as (assignment left: ... type: ...) in tree-sitter-python.\n(expression_statement\n  (assignment\n    left: (identifier) @name\n    type: (type)) @definition.property)\n\n; Plain variable assignments without type annotation: x = 5, MAX_SIZE = 100\n; Overlap with @definition.property (typed) is handled by parse-worker dedup.\n(expression_statement\n  (assignment\n    left: (identifier) @name)) @definition.variable\n\n; Heritage queries - Python class inheritance\n(class_definition\n  name: (identifier) @heritage.class\n  superclasses: (argument_list\n    (identifier) @heritage.extends)) @heritage\n\n; Write access: obj.field = value\n(assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Python HTTP clients: requests.get('/path'), httpx.post('/path'), session.get('/path')\n(call\n  function: (attribute\n    attribute: (identifier) @http_client.method)\n  arguments: (argument_list\n    (string (string_content) @http_client.url))) @http_client\n\n; Python decorators: @app.route, @router.get, etc.\n(decorator\n  (call\n    function: (attribute\n      object: (identifier) @decorator.receiver\n      attribute: (identifier) @decorator.name)\n    arguments: (argument_list\n      (string (string_content) @decorator.arg)?))) @decorator\n";
 export declare const JAVA_QUERIES = "\n; Classes, Interfaces, Enums, Annotations\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(enum_declaration name: (identifier) @name) @definition.enum\n(annotation_type_declaration name: (identifier) @name) @definition.annotation\n\n; Methods & Constructors\n(method_declaration name: (identifier) @name) @definition.method\n(constructor_declaration name: (identifier) @name) @definition.constructor\n\n; Fields \u2014 typed field declarations inside class bodies\n(field_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.property\n\n; Imports - capture any import declaration child as source\n(import_declaration (_) @import.source) @import\n\n; Calls\n(method_invocation name: (identifier) @call.name) @call\n(method_invocation object: (_) name: (identifier) @call.name) @call\n(method_reference) @call\n\n; Constructor calls: new Foo()\n(object_creation_expression type: (type_identifier) @call.name) @call\n\n; Local variable declarations inside method bodies\n(local_variable_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n; Heritage - extends class\n(class_declaration name: (identifier) @heritage.class\n  (superclass (type_identifier) @heritage.extends)) @heritage\n\n; Heritage - implements interfaces\n(class_declaration name: (identifier) @heritage.class\n  (super_interfaces (type_list (type_identifier) @heritage.implements))) @heritage.impl\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_access\n    object: (_) @assignment.receiver\n    field: (identifier) @assignment.property)\n  right: (_)) @assignment\n";
 export declare const C_QUERIES = "\n; Functions (direct declarator)\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n\n; Functions returning pointers (pointer_declarator wraps function_declarator)\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n\n; Functions returning double pointers (nested pointer_declarator)\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function\n\n; Structs, Unions, Enums, Typedefs\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(union_specifier name: (type_identifier) @name) @definition.union\n(enum_specifier name: (type_identifier) @name) @definition.enum\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n\n; Variable declarations: int x = 5; or int x;\n(declaration\n  declarator: (init_declarator\n    declarator: (identifier) @name)) @definition.variable\n";

package/dist/core/ingestion/tree-sitter-queries.js

@@ -240,6 +240,12 @@ export const TYPESCRIPT_QUERIES = `
     [(string (string_fragment) @route.url)
      (template_string) @route.template_url])) @route.fetch
 
+; Custom fetch wrappers: apiFetch('/path'), fetchJSON('/api/data'), httpGet('/users'), etc.
+(call_expression
+  function: (identifier) @_wrapper_fn (#match? @_wrapper_fn "^(api(Fetch|Get|Post|Put|Delete|Patch|Request)|fetch(API|JSON|Data|Endpoint|Resource|Url)|http(Fetch|Get|Post|Put|Delete|Patch|Request))$")
+  arguments: (arguments
+    (string (string_fragment) @route.url))) @route.fetch
+
 ; axios.get/post/put/delete/patch('/path'), $.get/post/ajax({url:'/path'})
 (call_expression
   function: (member_expression
@@ -432,6 +438,12 @@ export const JAVASCRIPT_QUERIES = `
     [(string (string_fragment) @route.url)
      (template_string) @route.template_url])) @route.fetch
 
+; Custom fetch wrappers: apiFetch('/path'), fetchJSON('/api/data'), httpGet('/users'), etc.
+(call_expression
+  function: (identifier) @_wrapper_fn (#match? @_wrapper_fn "^(api(Fetch|Get|Post|Put|Delete|Patch|Request)|fetch(API|JSON|Data|Endpoint|Resource|Url)|http(Fetch|Get|Post|Put|Delete|Patch|Request))$")
+  arguments: (arguments
+    (string (string_fragment) @route.url))) @route.fetch
+
 ; axios.get/post, $.get/post/ajax
 (call_expression
   function: (member_expression

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -101,6 +101,10 @@ export interface ExtractedFetchCall {
     fetchURL: string;
     lineNumber: number;
 }
+export interface FetchWrapperDef {
+    filePath: string;
+    functionName: string;
+}
 export interface ExtractedDecoratorRoute {
     filePath: string;
     routePath: string;
@@ -166,6 +170,7 @@ export interface ParseWorkerResult {
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
     fetchCalls: ExtractedFetchCall[];
+    fetchWrapperDefs: FetchWrapperDef[];
     decoratorRoutes: ExtractedDecoratorRoute[];
     toolDefs: ExtractedToolDef[];
     ormQueries: ExtractedORMQuery[];

package/dist/core/ingestion/workers/parse-worker.js

@@ -432,6 +432,7 @@ const processBatch = (files, onProgress) => {
         heritage: [],
         routes: [],
         fetchCalls: [],
+        fetchWrapperDefs: [],
         decoratorRoutes: [],
         toolDefs: [],
         ormQueries: [],
@@ -539,6 +540,25 @@ const EXPRESS_ROUTE_METHODS = new Set([
     'use',
     'route',
 ]);
+/**
+ * Walk a tree-sitter AST subtree looking for a call to the global `fetch()` function.
+ * Returns `true` if found within `maxDepth` levels of nesting — keeps the check
+ * lightweight so it doesn't slow down parse-worker on large function bodies.
+ */
+const checkForFetchCall = (node, depth = 0, maxDepth = 5) => {
+    if (depth > maxDepth)
+        return false;
+    if (node.type === 'call_expression') {
+        const fn = node.childForFieldName('function');
+        if (fn?.type === 'identifier' && fn.text === 'fetch')
+            return true;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+        if (checkForFetchCall(node.child(i), depth + 1, maxDepth))
+            return true;
+    }
+    return false;
+};
 // HTTP client methods that are ONLY used by clients, not Express route registration.
 // Methods like get/post/put/delete/patch overlap with Express — those are captured by
 // the express_route handler as route definitions, not consumers. The fetch() global
@@ -1505,6 +1525,18 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         : '',
                 });
             }
+            // ── Fetch wrapper detection: record functions that call fetch() internally ──
+            if (nodeLabel === 'Function' &&
+                definitionNode &&
+                nameNode &&
+                (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript)) {
+                if (checkForFetchCall(definitionNode)) {
+                    result.fetchWrapperDefs.push({
+                        filePath: file.path,
+                        functionName: nameNode.text,
+                    });
+                }
+            }
         }
         // Extract framework routes via provider detection (e.g., Laravel routes.php)
         if (provider.isRouteFile?.(file.path)) {
@@ -1542,6 +1574,7 @@ let accumulated = {
     heritage: [],
     routes: [],
     fetchCalls: [],
+    fetchWrapperDefs: [],
     decoratorRoutes: [],
     toolDefs: [],
     ormQueries: [],
@@ -1569,6 +1602,7 @@ const mergeResult = (target, src) => {
     appendAll(target.heritage, src.heritage);
     appendAll(target.routes, src.routes);
     appendAll(target.fetchCalls, src.fetchCalls);
+    appendAll(target.fetchWrapperDefs, src.fetchWrapperDefs);
     appendAll(target.decoratorRoutes, src.decoratorRoutes);
     appendAll(target.toolDefs, src.toolDefs);
     appendAll(target.ormQueries, src.ormQueries);
@@ -1651,6 +1685,7 @@ parentPort.on('message', (msg) => {
                 heritage: [],
                 routes: [],
                 fetchCalls: [],
+                fetchWrapperDefs: [],
                 decoratorRoutes: [],
                 toolDefs: [],
                 ormQueries: [],

package/dist/storage/parse-cache.js

@@ -41,7 +41,7 @@ import { fileURLToPath } from 'url';
  * On version mismatch, `loadParseCache` returns an empty cache and the
  * next save overwrites the on-disk file with the new version baked in.
  */
-const SCHEMA_BUMP = 1;
+const SCHEMA_BUMP = 2;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.75",
+  "version": "1.6.6-rc.77",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",