gitnexus 1.6.9-rc.23 → 1.6.9-rc.25

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

@@ -25,6 +25,9 @@ export const TYPESCRIPT_QUERIES = `
 (function_declaration
   name: (identifier) @name) @definition.function
 
+(generator_function_declaration
+  name: (identifier) @name) @definition.function
+
 ; TypeScript overload signatures (function_signature is a separate node type from function_declaration)
 (function_signature
   name: (identifier) @name) @definition.function
@@ -371,6 +374,9 @@ export const JAVASCRIPT_QUERIES = `
 (function_declaration
   name: (identifier) @name) @definition.function
 
+(generator_function_declaration
+  name: (identifier) @name) @definition.function
+
 (method_definition
   name: (property_identifier) @name) @definition.method
 

package/dist/mcp/local/local-backend.js

@@ -5157,7 +5157,7 @@ export class LocalBackend {
       RETURN n.id AS routeId, n.name AS routeName, n.filePath AS handlerFile,
              n.responseKeys AS responseKeys, n.errorKeys AS errorKeys, n.middleware AS middleware,
              consumer.name AS consumerName, consumer.filePath AS consumerFile,
-             r.reason AS fetchReason
+             r.reason AS fetchReason, n.method AS method
     `, params);
         // Strip wrapping quotes from DB array elements — CSV COPY stores ['key'] which
         // LadybugDB may return as "'key'" rather than "key"
@@ -5173,10 +5173,16 @@ export class LocalBackend {
             const consumerName = row.consumerName ?? row[6];
             const consumerFile = row.consumerFile ?? row[7];
             const fetchReason = row.fetchReason ?? row[8] ?? null;
+            // Verb is the literal '*' for method-agnostic routes (Django function
+            // views) and absent (null) for method-less routes (filesystem, Laravel
+            // resource). Appended last in RETURN so positional fallbacks for the
+            // consumer/reason columns above stay stable.
+            const method = row.method ?? row[9] ?? null;
             if (!routeMap.has(id)) {
                 routeMap.set(id, {
                     id,
                     name,
+                    method,
                     filePath,
                     responseKeys,
                     errorKeys,
@@ -5260,6 +5266,7 @@ export class LocalBackend {
         return {
             routes: routes.map((r) => ({
                 route: r.name,
+                method: r.method,
                 handler: r.filePath,
                 middleware: r.middleware || [],
                 consumers: r.consumers,
@@ -5314,6 +5321,7 @@ export class LocalBackend {
             const hasMismatches = consumers.some((c) => 'mismatched' in c && c.mismatched.length > 0);
             return {
                 route: r.name,
+                method: r.method,
                 handler: r.filePath,
                 ...(responseKeys.length > 0 ? { responseKeys } : {}),
                 ...(errorKeys.length > 0 ? { errorKeys } : {}),
@@ -5381,15 +5389,32 @@ export class LocalBackend {
             routeFilter = `AND n.filePath CONTAINS $file`;
             queryParams.file = params.file;
         }
-        const routes = await this.fetchRoutesWithConsumers(repo.lbugPath, routeFilter, queryParams);
+        // After #2302 the same URL/handler can expose one Route node per HTTP verb.
+        // An optional `method` narrows to that one verb so the response collapses to
+        // the singular shape. A method-agnostic route (method `'*'`, e.g. a Django
+        // function view) matches any selector; verbless routes (null method) never do.
+        // `method` arrives unvalidated from the MCP envelope (the JSON schema is
+        // advisory), so reject a non-string verb with a structured error instead of
+        // throwing on `.toUpperCase()`; empty/whitespace collapses to no selector.
+        const rawMethod = params.method;
+        if (rawMethod !== undefined && typeof rawMethod !== 'string') {
+            return { error: '"method" must be a string (e.g. "GET", "POST").' };
+        }
+        const wantedMethod = typeof rawMethod === 'string' ? rawMethod.trim().toUpperCase() || undefined : undefined;
+        const matched = await this.fetchRoutesWithConsumers(repo.lbugPath, routeFilter, queryParams);
+        const routes = matched.filter((r) => !wantedMethod || r.method === '*' || r.method?.toUpperCase() === wantedMethod);
         if (routes.length === 0) {
             const target = params.route || params.file;
-            return { error: `No routes found matching "${target}".` };
+            // Only append the verb when the URL/file matched routes but none used it;
+            // a non-existent URL/file gets the plain "no routes found" message.
+            const verb = wantedMethod && matched.length > 0 ? ` with method "${wantedMethod}"` : '';
+            return { error: `No routes found matching "${target}"${verb}.` };
         }
         const flowMap = await this.fetchLinkedFlowsBatch(repo.lbugPath, routes.map((r) => r.id));
-        // Count how many routes share the same handler file (for middleware partial detection)
+        // Count verbs per handler from the FULL match (before the method filter) so a
+        // method-scoped query still flags a multi-verb handler's partial middleware.
         const routeCountByHandler = new Map();
-        for (const r of routes) {
+        for (const r of matched) {
             if (r.filePath) {
                 routeCountByHandler.set(r.filePath, (routeCountByHandler.get(r.filePath) ?? 0) + 1);
             }
@@ -5459,6 +5484,7 @@ export class LocalBackend {
             const middlewarePartial = middlewareArr.length > 0 && handlerRouteCount > 1;
             return {
                 route: r.name,
+                method: r.method,
                 handler: r.filePath,
                 responseShape: {
                     success: responseKeys,
@@ -5468,7 +5494,7 @@ export class LocalBackend {
                 ...(middlewarePartial
                     ? {
                         middlewareDetection: 'partial',
-                        middlewareNote: 'Middleware captured from first HTTP method export only — other methods in this handler may use different middleware chains.',
+                        middlewareNote: 'Middleware captured from the first route export only — other route exports in this handler may use different middleware chains.',
                     }
                     : {}),
                 consumers,

package/dist/mcp/tools.d.ts

@@ -24,6 +24,14 @@ export interface ToolDefinition {
             minLength?: number;
         }>;
         required: string[];
+        /**
+         * JSON-Schema `anyOf` for cross-property constraints `required` cannot express
+         * — e.g. "at least one of route/file". Forwarded verbatim to clients by the
+         * server's ListTools handler, so MCP clients see the constraint.
+         */
+        anyOf?: Array<{
+            required: string[];
+        }>;
     };
 }
 /**

package/dist/mcp/tools.js

@@ -615,7 +615,7 @@ CONTRACT CAVEATS:
 WHEN TO USE: Understanding API consumption patterns, finding orphaned routes. For pre-change analysis, prefer \`api_impact\` which combines this data with mismatch detection and risk assessment.
 AFTER THIS: Use impact() on specific route handlers to see full blast radius.
 
-Returns: route nodes with their handlers, middleware wrapper chains (e.g., withAuth, withRateLimit), and consumers.`,
+Returns: route nodes with their handlers, middleware wrapper chains (e.g., withAuth, withRateLimit), and consumers. Each route object includes its "method" (the HTTP verb, "*" for method-agnostic routes, or null for method-less routes).`,
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
         inputSchema: {
             type: 'object',
@@ -656,7 +656,7 @@ Returns: tool nodes with their handler files and descriptions.`,
 WHEN TO USE: Detecting mismatches between what an API route returns and what consumers expect. Finding shape drift. For pre-change analysis, prefer \`api_impact\` which combines this data with mismatch detection and risk assessment.
 REQUIRES: Route nodes with responseKeys (extracted from .json({...}) calls during indexing).
 
-Returns routes that have both detected response keys AND consumers. Shows top-level keys each endpoint returns (e.g., data, pagination, error) and what keys each consumer accesses. Reports MISMATCH status when a consumer accesses keys not present in the route's response shape.`,
+Returns routes that have both detected response keys AND consumers. Shows top-level keys each endpoint returns (e.g., data, pagination, error) and what keys each consumer accesses. Reports MISMATCH status when a consumer accesses keys not present in the route's response shape. Each route object includes its "method" (the HTTP verb, "*" for method-agnostic routes, or null for method-less routes).`,
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
         inputSchema: {
             type: 'object',
@@ -681,16 +681,23 @@ WHEN TO USE: BEFORE modifying any API route handler. Shows what consumers depend
 
 Risk levels: LOW (0-3 consumers), MEDIUM (4-9 or any mismatches), HIGH (10+ consumers or mismatches with 4+ consumers). Mismatches with confidence "low" indicate the consumer file fetches multiple routes — property attribution is approximate.
 
-Returns: single route object when one match, or { routes: [...], total: N } for multiple matches. Combines route_map, shape_check, and impact data.`,
+Response shape is keyed on how many routes match, not on the data: exactly one match returns a single route object; two or more return { routes: [...], total: N }. The same URL can expose multiple HTTP verbs (e.g. GET and POST /api/orders are distinct routes that share the URL), so a bare-URL lookup may return the wrapped form — every route object carries its own "method" so verbs are distinguishable. Pass "method" to narrow to one verb; the single-object shape is returned only when exactly one route remains after filtering — a substring route/file match spanning several URLs can still return the wrapped form. A URL/file that exists but has no route for the given verb returns an error. Each route's "method" is the literal "*" for method-agnostic routes (e.g. Django function views), which match any "method" selector, or null for method-less routes (filesystem, Laravel resource), which never match a selector. Combines route_map, shape_check, and impact data.`,
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
         inputSchema: {
             type: 'object',
             properties: {
                 route: { type: 'string', description: 'Route path (e.g., "/api/grants")' },
                 file: { type: 'string', description: 'Handler file path (alternative to route)' },
+                method: {
+                    type: 'string',
+                    description: 'Optional HTTP verb — GET, POST, PUT, PATCH, DELETE, etc. — to narrow a multi-verb route or file lookup to a single method. Returns an error if no matched route uses that verb.',
+                },
                 repo: { type: 'string', description: 'Repository name or path.' },
             },
             required: [],
+            // Exactly one lookup key is needed, but either works (route wins if both
+            // are passed) — so the structural constraint is "at least one of route/file".
+            anyOf: [{ required: ['route'] }, { required: ['file'] }],
         },
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.9-rc.23",
+  "version": "1.6.9-rc.25",
   "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",