gitnexus 1.6.8-rc.55 → 1.6.8-rc.56

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

@@ -1,5 +1,29 @@
 import type { ContractExtractor, CypherExecutor } from '../contract-extractor.js';
 import type { ExtractedContract, RepoHandle } from '../types.js';
+/**
+ * Language-agnostic orchestrator for HTTP route (provider + consumer)
+ * contract extraction. Two strategies, in order of preference per role:
+ *
+ * 1. **Graph-assisted (Strategy A)** — if a per-repo LadybugDB executor
+ *    is available, read `HANDLES_ROUTE` / `FETCHES` Cypher edges that
+ *    the ingestion pipeline already produced via tree-sitter. This is
+ *    the preferred path because the graph has richer symbol metadata
+ *    (real uids, class/method structure, etc.).
+ *
+ * 2. **Source-scan supplement (Strategy B)** — parse files directly with
+ *    the per-language plugin registry in `./http-patterns/`. Used to
+ *    fill gaps when graph extraction only covers part of a polyglot repo
+ *    (e.g. Java graph routes plus Go source-scan routes). Graph entries
+ *    remain authoritative for duplicate contract IDs because they carry
+ *    richer symbol metadata. Each plugin owns its tree-sitter grammar
+ *    and query sources — this orchestrator imports NO grammars or query
+ *    strings.
+ *
+ * Adding a new language for Strategy B is a one-file edit in
+ * `http-patterns/index.ts`: register a new `HttpLanguagePlugin` and
+ * widen `HTTP_SCAN_GLOB` if needed.
+ */
+export declare const HANDLES_ROUTE_QUERY = "\nMATCH (handlerFile:File)-[r:CodeRelation {type: 'HANDLES_ROUTE'}]->(route:Route)\nRETURN handlerFile.id AS fileId, handlerFile.filePath AS filePath,\n       route.name AS routePath, route.id AS routeId,\n       route.method AS routeMethod,\n       route.responseKeys AS responseKeys,\n       r.reason AS routeSource";
 /**
  * Canonicalize a provider-side HTTP path for contract-id generation:
  *   - strip query string

package/dist/core/group/extractors/http-route-extractor.js

@@ -4,6 +4,7 @@ import Parser from 'tree-sitter';
 import { createIgnoreFilter } from '../../../config/ignore-service.js';
 import { readSafe } from './fs-utils.js';
 import { parseSourceSafe } from '../../tree-sitter/safe-parse.js';
+import { logger } from '../../logger.js';
 import { getPluginForFile, HTTP_SCAN_GLOB, } from './http-patterns/index.js';
 /**
  * Language-agnostic orchestrator for HTTP route (provider + consumer)
@@ -29,10 +30,14 @@ import { getPluginForFile, HTTP_SCAN_GLOB, } from './http-patterns/index.js';
  * widen `HTTP_SCAN_GLOB` if needed.
  */
 // ─── Graph-assisted queries ──────────────────────────────────────────
-const HANDLES_ROUTE_QUERY = `
+// Exported so integration tests can run the exact production query against a
+// real LadybugDB (guards the Route.method column contract — see
+// route-method-roundtrip.test.ts).
+export const HANDLES_ROUTE_QUERY = `
 MATCH (handlerFile:File)-[r:CodeRelation {type: 'HANDLES_ROUTE'}]->(route:Route)
 RETURN handlerFile.id AS fileId, handlerFile.filePath AS filePath,
        route.name AS routePath, route.id AS routeId,
+       route.method AS routeMethod,
        route.responseKeys AS responseKeys,
        r.reason AS routeSource`;
 const FETCHES_QUERY = `
@@ -273,14 +278,26 @@ export class HttpRouteExtractor {
         try {
             rows = await db(HANDLES_ROUTE_QUERY);
         }
-        catch {
+        catch (err) {
+            // A failure here silently disables the entire graph-assisted HTTP
+            // provider path (the source-scan fallback still runs and masks most
+            // of the damage), so surface it at debug level to make a total
+            // outage observable instead of invisible.
+            logger.debug(`[http-route-extractor] HANDLES_ROUTE query failed; graph providers skipped: ${err instanceof Error ? err.message : String(err)}`);
             return [];
         }
         for (const row of rows) {
             const filePath = String(row.filePath ?? '');
             const routePath = String(row.routePath ?? '');
             const routeSource = String(row.routeSource ?? row.routeReason ?? '');
-            let method = methodFromRouteReason(routeSource);
+            // Prefer the HTTP verb persisted on the Route node by the ingestion
+            // routes phase (Spring/Laravel framework routes and decorator routes
+            // carry it). Fall back to parsing it out of the edge reason for
+            // older indexes or filesystem routes that never stored a method.
+            const graphMethod = String(row.routeMethod ?? '')
+                .trim()
+                .toUpperCase();
+            let method = (graphMethod || null) ?? methodFromRouteReason(routeSource);
             // Look up handler name (and backfill method if missing) from the
             // plugin's scan of the handler file. This replaces the old
             // regex-based `inferMethodFromFileScan` and `pickJavaHandlerName`
@@ -396,7 +413,8 @@ export class HttpRouteExtractor {
         try {
             rows = await db(FETCHES_QUERY);
         }
-        catch {
+        catch (err) {
+            logger.debug(`[http-route-extractor] FETCHES query failed; graph consumers skipped: ${err instanceof Error ? err.message : String(err)}`);
             return [];
         }
         for (const row of rows) {

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

@@ -14,6 +14,15 @@ import type { PipelinePhase } from './types.js';
 export interface RouteEntry {
     filePath: string;
     source: string;
+    /**
+     * HTTP verb for this route when ingestion knows it structurally
+     * (Spring/Laravel framework routes and decorator routes carry
+     * `httpMethod`; filesystem-derived routes — Next.js/Expo/PHP file
+     * routes — do not, so this stays undefined for them). Persisted onto
+     * the Route node so downstream contract extraction can read the verb
+     * from the graph instead of re-parsing the handler source.
+     */
+    method?: string;
 }
 export interface RoutesOutput {
     routeRegistry: Map<string, RouteEntry>;
@@ -26,4 +35,5 @@ export interface TemplateFetchCall {
 export declare const isTemplateRouteCandidate: (filePath: string) => boolean;
 export declare function extractTemplateStaticFetchCalls(filePath: string, content: string, namedRouteUrls?: ReadonlyMap<string, string>): TemplateFetchCall[];
 export declare function normalizeExtractedRoutePath(routePath: string, prefix: string | null): string;
+export declare function normalizeRouteMethod(raw: string | null | undefined): string | undefined;
 export declare const routesPhase: PipelinePhase<RoutesOutput>;

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

@@ -97,6 +97,32 @@ export function normalizeExtractedRoutePath(routePath, prefix) {
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Canonicalize a route's HTTP verb for persistence on the Route node.
+ * Returns an upper-cased standard method, or `undefined` when the value
+ * is not a real HTTP verb. Laravel `Route::resource` / `apiResource`
+ * surface `httpMethod` values like `resource` / `apiResource` (they
+ * expand to several verbs at runtime), so they must not be stored as a
+ * method — leaving them `undefined` keeps the column clean and lets the
+ * contract extractor fall back to its source-scan path for those routes.
+ */
+const VALID_HTTP_METHODS = new Set([
+    'GET',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+    'HEAD',
+    'OPTIONS',
+    'TRACE',
+    'CONNECT',
+]);
+export function normalizeRouteMethod(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const verb = raw.trim().toUpperCase();
+    return VALID_HTTP_METHODS.has(verb) ? verb : undefined;
+}
 export const routesPhase = {
     name: 'routes',
     deps: ['parse'],
@@ -166,6 +192,7 @@ export const routesPhase = {
             addRoute(routeUrl, {
                 filePath: route.filePath,
                 source: 'framework-route',
+                method: normalizeRouteMethod(route.httpMethod),
             });
             if (route.routeName && !namedRouteRegistry.has(route.routeName)) {
                 namedRouteRegistry.set(route.routeName, routeUrl);
@@ -176,6 +203,7 @@ export const routesPhase = {
             addRoute(url, {
                 filePath: dr.filePath,
                 source: `decorator-${dr.decoratorName}`,
+                method: normalizeRouteMethod(dr.httpMethod),
             });
         }
         let handlerContents;
@@ -183,7 +211,7 @@ export const routesPhase = {
             const handlerPaths = [...routeRegistry.values()].map((e) => e.filePath);
             handlerContents = await readFileContents(ctx.repoPath, handlerPaths);
             for (const [routeURL, entry] of routeRegistry) {
-                const { filePath: handlerPath, source: routeSource } = entry;
+                const { filePath: handlerPath, source: routeSource, method: routeMethod } = entry;
                 const content = handlerContents.get(handlerPath);
                 const { responseKeys, errorKeys } = content
                     ? handlerPath.endsWith('.php')
@@ -199,6 +227,7 @@ export const routesPhase = {
                     properties: {
                         name: routeURL,
                         filePath: handlerPath,
+                        ...(routeMethod ? { method: routeMethod } : {}),
                         ...(responseKeys ? { responseKeys } : {}),
                         ...(errorKeys ? { errorKeys } : {}),
                         ...(middleware && middleware.length > 0 ? { middleware } : {}),

package/dist/core/lbug/csv-generator.js

@@ -297,7 +297,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
         // Section nodes have an extra 'level' column
         const sectionWriter = new BufferedCSVWriter(path.join(csvDir, 'section.csv'), 'id,name,filePath,startLine,endLine,level,content,description');
         // Route nodes for API endpoint mapping
-        const routeWriter = new BufferedCSVWriter(path.join(csvDir, 'route.csv'), 'id,name,filePath,responseKeys,errorKeys,middleware');
+        const routeWriter = new BufferedCSVWriter(path.join(csvDir, 'route.csv'), 'id,name,filePath,responseKeys,errorKeys,middleware,method');
         // Tool nodes for MCP tool definitions
         const toolWriter = new BufferedCSVWriter(path.join(csvDir, 'tool.csv'), 'id,name,filePath,description');
         // BasicBlock nodes — taint/PDG substrate (issue #2080). No `name` column;
@@ -444,6 +444,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
                         escapeCSVField(keysStr),
                         escapeCSVField(errorKeysStr),
                         escapeCSVField(middlewareStr),
+                        escapeCSVField(String(node.properties.method ?? '')),
                     ].join(','));
                     break;
                 }

package/dist/core/lbug/lbug-adapter.js

@@ -1119,7 +1119,7 @@ export const getCopyQuery = (table, filePath) => {
         return `COPY ${t}(id, name, filePath, startLine, endLine, level, content, description) FROM "${filePath}" ${COPY_CSV_OPTS}`;
     }
     if (table === 'Route') {
-        return `COPY ${t}(id, name, filePath, responseKeys, errorKeys, middleware) FROM "${filePath}" ${COPY_CSV_OPTS}`;
+        return `COPY ${t}(id, name, filePath, responseKeys, errorKeys, middleware, method) FROM "${filePath}" ${COPY_CSV_OPTS}`;
     }
     if (table === 'Tool') {
         return `COPY ${t}(id, name, filePath, description) FROM "${filePath}" ${COPY_CSV_OPTS}`;

package/dist/core/lbug/schema.d.ts

@@ -39,7 +39,7 @@ export declare const ANNOTATION_SCHEMA: string;
 export declare const CONSTRUCTOR_SCHEMA: string;
 export declare const TEMPLATE_SCHEMA: string;
 export declare const MODULE_SCHEMA: string;
-export declare const ROUTE_SCHEMA = "\nCREATE NODE TABLE Route (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  responseKeys STRING[],\n  errorKeys STRING[],\n  middleware STRING[],\n  PRIMARY KEY (id)\n)";
+export declare const ROUTE_SCHEMA = "\nCREATE NODE TABLE Route (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  responseKeys STRING[],\n  errorKeys STRING[],\n  middleware STRING[],\n  method STRING,\n  PRIMARY KEY (id)\n)";
 export declare const TOOL_SCHEMA = "\nCREATE NODE TABLE Tool (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
 export declare const SECTION_SCHEMA = "\nCREATE NODE TABLE Section (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  level INT64,\n  content STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
 export declare const BASICBLOCK_SCHEMA = "\nCREATE NODE TABLE BasicBlock (\n  id STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  text STRING,\n  PRIMARY KEY (id)\n)";

package/dist/core/lbug/schema.js

@@ -177,6 +177,7 @@ CREATE NODE TABLE Route (
   responseKeys STRING[],
   errorKeys STRING[],
   middleware STRING[],
+  method STRING,
   PRIMARY KEY (id)
 )`;
 // MCP tool definitions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.8-rc.55",
+  "version": "1.6.8-rc.56",
   "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",