gitnexus 1.6.9-rc.11 → 1.6.9-rc.12

package/dist/core/group/cross-trace.js

@@ -732,18 +732,20 @@ async function stitchCrossRepo(deps, p, fromEp, toEp, groupDir, notes) {
 const FILE_BASENAME_RE = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|php|java|kt|kts|rb|cs|rs|swift|dart|scala|c|cc|cpp|cxx|h|hpp|m|mm)$/i;
 /**
  * A provider endpoint's display label. A resolved handler has a real function
- * name; the source-scan fallbacks leave a generic token (`'handler'`/`'fetch'`)
- * or a file basename. Those are treated as anonymous and shown as
+ * name; the source-scan fallbacks leave a generic token (`'handler'`/`'fetch'`,
+ * or `'route'` for an unresolved named-controller / closure Laravel route) or a
+ * file basename. Those are treated as anonymous and shown as
  * `<METHOD /path handler>` so the endpoint is still identifiable by route. When
  * the bridge row carries a resolved `providerUid`, the name IS a real symbol —
- * the `'handler'`/`'fetch'` sentinel check is suppressed so a function genuinely
- * named `handler` is not mislabeled anonymous.
+ * the sentinel check is suppressed so a function genuinely named `handler` (or,
+ * hypothetically, `route`) is not mislabeled anonymous.
  */
 function providerLabel(providerName, contractId, providerUid) {
     const resolved = providerUid !== '';
     const generic = providerName === '' ||
         FILE_BASENAME_RE.test(providerName) ||
-        (!resolved && (providerName === 'handler' || providerName === 'fetch'));
+        (!resolved &&
+            (providerName === 'handler' || providerName === 'fetch' || providerName === 'route'));
     return generic
         ? { label: `<${contractId} handler>`, anon: true }
         : { label: providerName, anon: false };

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

@@ -9,8 +9,11 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
  */
 // ─── Provider: framework routing ──────────────────────────────────────
 // Matches `\w+\.GET(...)` etc. (gin, echo, chi all share this shape).
-// Captures the HTTP method (field name), path literal, and handler
-// identifier passed as the second argument.
+// Captures the HTTP method (field name), path literal, and the handler —
+// anchored to the LAST argument (`@handler .`) so a variadic middleware
+// chain (`r.GET("/x", mw, handler)`, gin/echo/chi style) binds the real
+// handler, not a middleware identifier (which would otherwise over-match
+// and attach the route to the wrong symbol — see #2276 review).
 const FRAMEWORK_ROUTE_PATTERNS = compilePatterns({
     name: 'go-framework-route',
     language: Go,
@@ -23,7 +26,8 @@ const FRAMEWORK_ROUTE_PATTERNS = compilePatterns({
             field: (field_identifier) @http_method (#match? @http_method "^(GET|POST|PUT|DELETE|PATCH)$"))
           arguments: (argument_list
             (interpreted_string_literal) @path
-            (identifier) @handler))
+            [(identifier) (func_literal)] @handler
+            .))
       `,
         },
     ],
@@ -42,7 +46,8 @@ const HANDLE_FUNC_PATTERNS = compilePatterns({
             field: (field_identifier) @fn (#eq? @fn "HandleFunc"))
           arguments: (argument_list
             (interpreted_string_literal) @path
-            (identifier) @handler))
+            [(identifier) (func_literal)] @handler
+            .))
       `,
         },
     ],
@@ -125,12 +130,18 @@ export const GO_HTTP_PLUGIN = {
             const path = unquoteLiteral(pathNode.text);
             if (path === null)
                 continue;
+            // An inline `func(){…}` handler has no name → emit `name: null` and a
+            // `line` so it resolves to its containing/closure symbol by line-span
+            // containment (like a consumer). A named identifier handler keeps its
+            // name and resolves by name; `line` is harmless there.
+            const isInlineHandler = handlerNode?.type === 'func_literal';
             out.push({
                 role: 'provider',
                 framework: 'go-framework',
                 method: methodNode.text.toUpperCase(),
                 path,
-                name: handlerNode?.text ?? null,
+                name: isInlineHandler ? null : (handlerNode?.text ?? null),
+                line: (handlerNode ?? pathNode).startPosition.row + 1,
                 confidence: 0.8,
             });
         }
@@ -143,12 +154,16 @@ export const GO_HTTP_PLUGIN = {
             const path = unquoteLiteral(pathNode.text);
             if (path === null)
                 continue;
+            // Inline `func(){…}` handler → resolve by containment (see go-framework
+            // note above); a named handler resolves by name.
+            const isInlineHandler = handlerNode?.type === 'func_literal';
             out.push({
                 role: 'provider',
                 framework: 'go-stdlib',
                 method: 'GET',
                 path,
-                name: handlerNode?.text ?? null,
+                name: isInlineHandler ? null : (handlerNode?.text ?? null),
+                line: (handlerNode ?? pathNode).startPosition.row + 1,
                 confidence: 0.8,
             });
         }

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

@@ -634,6 +634,13 @@ export const JAVA_HTTP_PLUGIN = {
                     method: route.httpMethod,
                     path: joinPath(prefix, route.rawPath),
                     name: route.methodName,
+                    // Spring providers are named controller methods resolved BY NAME, so
+                    // `line` is inert — a named provider never falls through to line-span
+                    // containment. Gate it on a present name so a (grammar-impossible)
+                    // nameless provider degrades to file-level rather than resolving by
+                    // containment to the enclosing class. Wired for consumer-emit parity
+                    // and a future inline DSL.
+                    line: route.methodName ? route.methodNode.startPosition.row + 1 : undefined,
                     confidence: 0.8,
                 });
             }

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

@@ -977,6 +977,13 @@ function buildKotlinPlugin(language) {
                         method: httpMethod,
                         path: joinPath(prefix, rawPath),
                         name: nameNode?.text ?? null,
+                        // Spring providers are named controller methods resolved BY NAME, so
+                        // `line` is inert — a named provider never falls through to line-span
+                        // containment. Gate it on a present name so a (grammar-impossible)
+                        // nameless provider degrades to file-level rather than resolving by
+                        // containment to the enclosing class. Wired for consumer-emit parity
+                        // and a future inline DSL.
+                        line: nameNode?.text ? methodNode.startPosition.row + 1 : undefined,
                         confidence: 0.8,
                     });
                 }

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

@@ -27,7 +27,9 @@ const LARAVEL_ROUTE_SPEC = {
     (scoped_call_expression
       scope: (name) @scope (#eq? @scope "Route")
       name: (name) @method (#match? @method "^(get|post|put|delete|patch)$")
-      arguments: (arguments . (argument (string) @path)))
+      arguments: (arguments
+        . (argument (string) @path)
+        (argument [(anonymous_function) (arrow_function)] @closure)?))
   `,
 };
 const HTTP_FACADE_SPEC = {
@@ -125,12 +127,22 @@ export const PHP_HTTP_PLUGIN = {
             const path = phpStringText(pathNode);
             if (path === null)
                 continue;
+            // A closure handler (`Route::get('/x', function(){…})` / `fn() => …`) has
+            // no name → emit `name: null` + the registration line so it resolves to
+            // its containing symbol (e.g. a service-provider `boot()` or controller
+            // method) by line-span containment. A named-controller route keeps the
+            // `'route'` label — resolving its array/string handler to a real method is
+            // a separate, graph-backed concern. NOTE: a closure at FILE scope
+            // (routes/web.php) has no enclosing function and PHP closures are not yet
+            // indexed as symbols, so it still degrades to file-level (see #2276).
+            const closureNode = match.captures.closure;
             out.push({
                 role: 'provider',
                 framework: 'laravel',
                 method: methodNode.text.toUpperCase(),
                 path,
-                name: 'route',
+                name: closureNode ? null : 'route',
+                line: (closureNode ?? pathNode).startPosition.row + 1,
                 confidence: 0.8,
             });
         }

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

@@ -967,6 +967,12 @@ export const PYTHON_HTTP_PLUGIN = {
                 method: httpMethod,
                 path,
                 name: null,
+                // The decorated handler has no captured name → resolve by line-span
+                // containment. Best-effort fallback: FastAPI routes are graph-backed
+                // (ingestion decorator routes) and the function span starts at `def`
+                // (decorators excluded), so this lands the single-decorator case and
+                // degrades to file-level for multi-decorator stacks.
+                line: pathNode.startPosition.row + 1,
                 confidence: 0.8,
             });
         }
@@ -1008,6 +1014,8 @@ export const PYTHON_HTTP_PLUGIN = {
                     method: httpMethod,
                     path: p,
                     name: null,
+                    // Best-effort containment fallback — see the @app provider note above.
+                    line: pathNode.startPosition.row + 1,
                     confidence: 0.8,
                 });
             }

package/package.json

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