gitnexus 1.6.9-rc.11 → 1.6.9-rc.13

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/dist/core/logger.d.ts

@@ -36,6 +36,12 @@ export interface CreateLoggerOptions {
     debugEnvVar?: string;
     /** Override destination stream — primarily for tests. */
     destination?: DestinationStream;
+    /**
+     * Explicit level for the destination-override path — primarily for tests that
+     * need to capture below the default `info` (e.g. asserting a `debug` record).
+     * Ignored unless `destination` is set; `debugEnvVar` still wins when truthy.
+     */
+    level?: string;
 }
 /**
  * Flush any buffered records on the default destination. Entry-point
@@ -114,7 +120,10 @@ export interface LoggerCapture {
  *     expect(cap.records().some(r => r.msg?.includes('clamping'))).toBe(true);
  *   });
  *
+ * Pass `level` (e.g. 'debug') to capture below the default 'info' — needed to
+ * assert that a record was emitted at debug rather than merely absent.
+ *
  * Not a public API; underscore-prefixed and called only from test code.
  * Throws if a previous capture is still active — see the body for context.
  */
-export declare function _captureLogger(): LoggerCapture;
+export declare function _captureLogger(level?: string): LoggerCapture;

package/dist/core/logger.js

@@ -202,7 +202,7 @@ function buildBaseOptions() {
 export function createLogger(name, opts) {
     const debugRequested = opts?.debugEnvVar ? isTruthyEnv(process.env[opts.debugEnvVar]) : false;
     if (opts?.destination) {
-        return pino({ level: debugRequested ? 'debug' : 'info', base: undefined, name }, opts.destination);
+        return pino({ level: debugRequested ? 'debug' : (opts.level ?? 'info'), base: undefined, name }, opts.destination);
     }
     const base = buildBaseOptions();
     // When using a transport (pino-pretty), pino manages the destination
@@ -226,6 +226,7 @@ export function createLogger(name, opts) {
 /*  Default singleton (Proxy-backed for test capture)                  */
 /* ------------------------------------------------------------------ */
 let _activeDestination;
+let _activeLevel;
 let _cached;
 function _getInner() {
     if (_cached)
@@ -233,7 +234,7 @@ function _getInner() {
     // Always go through createLogger so future defaults (serializers, redaction,
     // formatters) apply uniformly. The destination override is honored when set
     // by `_captureLogger()` below.
-    _cached = createLogger('gitnexus', _activeDestination ? { destination: _activeDestination } : undefined);
+    _cached = createLogger('gitnexus', _activeDestination ? { destination: _activeDestination, level: _activeLevel } : undefined);
     return _cached;
 }
 /**
@@ -293,10 +294,13 @@ export class MemoryWritable extends Writable {
  *     expect(cap.records().some(r => r.msg?.includes('clamping'))).toBe(true);
  *   });
  *
+ * Pass `level` (e.g. 'debug') to capture below the default 'info' — needed to
+ * assert that a record was emitted at debug rather than merely absent.
+ *
  * Not a public API; underscore-prefixed and called only from test code.
  * Throws if a previous capture is still active — see the body for context.
  */
-export function _captureLogger() {
+export function _captureLogger(level) {
     // Guard against double-capture: forgetting `restore()` between two
     // `_captureLogger()` calls silently abandoned the previous capture and
     // corrupted logger state for the rest of the vitest worker. Throwing here
@@ -307,6 +311,7 @@ export function _captureLogger() {
     }
     const w = new MemoryWritable();
     _activeDestination = w;
+    _activeLevel = level;
     _cached = undefined;
     return {
         records: () => w.chunks
@@ -317,6 +322,7 @@ export function _captureLogger() {
         text: () => w.chunks.join(''),
         restore: () => {
             _activeDestination = undefined;
+            _activeLevel = undefined;
             _cached = undefined;
         },
     };

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

@@ -193,10 +193,39 @@ export const IMPACT_RELATION_CONFIDENCE = {
  * Falls back to 0.5 for unknown types so they are not silently elevated.
  */
 const confidenceForRelType = (relType) => IMPACT_RELATION_CONFIDENCE[relType ?? ''] ?? 0.5;
-/** Structured error logging for query failures — replaces empty catch blocks */
+/**
+ * Structured logging for *swallowed* query failures — replaces empty catch
+ * blocks. The level reflects telemetry severity, NOT a promise about the
+ * caller: most callers catch the failure and degrade to a genuinely safe
+ * fallback (a usable result, usually with a caller-visible `partial`/`ftsUsed`
+ * flag), so these are not operation-level errors and must not log at `error`:
+ *
+ *  - A benign missing optional table/label/column — a repo analyzed without
+ *    processes/communities, or a pre-v3 PDG index lacking the `calleeIds`
+ *    column — is a normal configuration, not a failure. Logged at `debug`
+ *    (suppressed at the default `info` level; surfaced only when troubleshooting).
+ *  - Any other swallowed failure is an unexpected-but-handled degradation:
+ *    logged at `warn` so it stays observable without raising a false `error`
+ *    alarm that would drown genuine, operation-aborting failures.
+ *
+ * `error` is intentionally NOT used here — it is reserved for failures that
+ * actually abort an operation, which log directly rather than through this
+ * best-effort-degradation helper.
+ *
+ * Contract for callers (#2283 review): only route a failure here when the
+ * caller ALSO surfaces the degradation in its result (a `partial` flag,
+ * `failed_files`, `traversalComplete:false`, …). A mutating or safety-critical
+ * path that would otherwise report success/clean (e.g. `rename` apply, the
+ * `detect_changes` safety gate) MUST set that result-level signal — `warn`
+ * alone is not a substitute for an honest result.
+ */
 function logQueryError(context, err) {
     const msg = err instanceof Error ? err.message : String(err);
-    logger.error({ context, err: msg }, 'GitNexus query failed');
+    if (isBenignMissingTableError(err)) {
+        logger.debug({ context, err: msg }, 'GitNexus query skipped (missing optional data)');
+        return;
+    }
+    logger.warn({ context, err: msg }, 'GitNexus query failed (degraded)');
 }
 /**
  * A "missing table/label/relation" prepare error is benign for the query tool's
@@ -208,7 +237,12 @@ function logQueryError(context, err) {
  */
 function isBenignMissingTableError(err) {
     const msg = err instanceof Error ? err.message : String(err ?? '');
-    return /does not exist|no such (table|label|rel)|unknown (table|label)|not (defined|found)/i.test(msg);
+    // The `not (defined|found)` arm is scoped to a schema object (table/label/
+    // rel/column/property), mirroring lbug-adapter's isMissingColumnError
+    // (`/(table|column|property).*not found/i`): an unscoped "not found" matched
+    // operation failures like `rg: not found` (ripgrep absent) or `Symbol not
+    // found`, which this helper would then silently demote to `debug` (#2283).
+    return /does not exist|no such (table|label|rel)|unknown (table|label)|(table|label|rel|column|property)[^\n]*\bnot (defined|found)\b/i.test(msg);
 }
 const isReadOnlyDbError = (err) => {
     // Walk the `cause` chain (bounded) so a wrapped read-only error (e.g. the
@@ -1574,7 +1608,12 @@ export class LocalBackend {
             ftsResponse = await searchFTSFromLbug(query, limit, repo.lbugPath);
         }
         catch (err) {
-            logger.error({ err: err.message }, 'GitNexus: BM25/FTS search failed (FTS indexes may not exist) -');
+            // Swallowed, gracefully-degraded failure: the search falls back to
+            // semantic-only (a valid result), and the most common cause is simply an
+            // un-indexed FTS extension — a normal configuration, not an operation
+            // error. Logged at warn (matching the sibling import-failure fallback
+            // above), never error, so it does not raise a false alarm.
+            logger.warn({ err: err.message }, 'GitNexus: BM25/FTS search failed (FTS indexes may not exist) — falling back to semantic-only');
             return { results: [], ftsUsed: false };
         }
         // Guard against unexpected response shape (#1489) — ftsResponse.results
@@ -3115,6 +3154,9 @@ export class LocalBackend {
         }
         // Map diff hunks to indexed symbols via range overlap
         const changedSymbols = [];
+        // Set if a swallowed graph query fails below — surfaces `partial:true` so a
+        // degraded run cannot report a false-clean `risk_level:'low'` (#2283).
+        let queryDegraded = false;
         for (const fileDiff of fileDiffs) {
             if (fileDiff.hunks.length === 0)
                 continue;
@@ -3160,6 +3202,12 @@ export class LocalBackend {
             }
             catch (e) {
                 logQueryError('detect-changes:file-symbols', e);
+                // The symbol query failed: changedSymbols stays empty and the result
+                // would otherwise look like a clean no-op (`changed_count:0`,
+                // `risk_level:'low'`). detect_changes is the pre-commit safety gate, so
+                // flag the result `partial` rather than let a swallowed failure
+                // masquerade as "nothing changed" (#2283).
+                queryDegraded = true;
             }
         }
         // Find affected processes -- single batched query instead of N+1
@@ -3194,6 +3242,7 @@ export class LocalBackend {
             }
             catch (e) {
                 logQueryError('detect-changes:process-lookup', e);
+                queryDegraded = true;
             }
         }
         const processCount = affectedProcesses.size;
@@ -3213,6 +3262,9 @@ export class LocalBackend {
             },
             changed_symbols: changedSymbols,
             affected_processes: Array.from(affectedProcesses.values()),
+            // A swallowed query failure makes the counts/risk above incomplete — tell
+            // the caller so the safety gate isn't trusted as a clean result (#2283).
+            ...(queryDegraded && { partial: true }),
         };
     }
     /**
@@ -3358,6 +3410,7 @@ export class LocalBackend {
         // Step 4: Apply or preview
         const allChanges = Array.from(changes.values());
         const totalEdits = allChanges.reduce((sum, c) => sum + c.edits.length, 0);
+        const failedFiles = [];
         if (!dry_run) {
             // Apply edits to files
             for (const change of allChanges) {
@@ -3369,12 +3422,16 @@ export class LocalBackend {
                     await fs.writeFile(fullPath, content, 'utf-8');
                 }
                 catch (e) {
+                    // A swallowed write failure must not be reported as a full success
+                    // (#2283): record the file so the result can degrade to 'partial'
+                    // with the unwritten files listed, rather than masquerading as done.
                     logQueryError('rename:apply-edit', e);
+                    failedFiles.push(change.file_path);
                 }
             }
         }
         return {
-            status: 'success',
+            status: failedFiles.length > 0 ? 'partial' : 'success',
             old_name: oldName,
             new_name,
             files_affected: allChanges.length,
@@ -3383,6 +3440,7 @@ export class LocalBackend {
             text_search_edits: astSearchEdits,
             changes: allChanges,
             applied: !dry_run,
+            ...(failedFiles.length > 0 && { failed_files: failedFiles }),
         };
     }
     async trace(repo, params) {
@@ -3655,9 +3713,20 @@ export class LocalBackend {
             };
         }
         const mode = modeResult.mode;
+        // #2279: some MCP client/agent adapters serialize an *omitted* optional
+        // numeric field as `0` rather than dropping it, so callgraph calls arrive
+        // carrying a spurious `line: 0`. `line` is meaningless on the callgraph path
+        // (the symbol→symbol BFS has no statement notion), so treat a literal `0`
+        // there as omitted and let the normal traversal run. The coercion is
+        // deliberately narrow — only the literal `0`, only when mode !== 'pdg':
+        // a genuine positive `line` on callgraph still errors (real mode mistake),
+        // negative/fractional values still error, and pdg mode is untouched (the
+        // normalization is an identity there, so `line: 0` is still rejected below —
+        // there is no 1-based source line `0` to anchor on).
+        const effectiveLine = mode !== 'pdg' && params.line === 0 ? undefined : params.line;
         // `line` is a PDG-only statement anchor. Reject it on the callgraph path
         // rather than silently ignore (the symbol→symbol BFS has no statement notion).
-        if (params.line !== undefined && mode !== 'pdg') {
+        if (effectiveLine !== undefined && mode !== 'pdg') {
             return {
                 error: `Parameter 'line' is only supported with mode:'pdg' (it anchors the dependence slice on a statement). Remove it or set mode:'pdg'.`,
                 target: { name: params.target },
@@ -3667,8 +3736,8 @@ export class LocalBackend {
             };
         }
         // A provided `line` must be a positive integer.
-        if (params.line !== undefined &&
-            (!Number.isInteger(params.line) || params.line < 1)) {
+        if (effectiveLine !== undefined &&
+            (!Number.isInteger(effectiveLine) || effectiveLine < 1)) {
             // Line param fails validation before target resolution → partial-but-typed
             // target on the pdg path (typed PdgImpactTarget, not an inline literal).
             const badLineTarget = { name: params.target };
@@ -3965,7 +4034,11 @@ export class LocalBackend {
                 symType,
                 direction,
                 maxDepth,
-                line: params.line,
+                // Use the normalized line, not raw params.line, so the gate and the
+                // engine share one source of truth (#2283). Identity in pdg mode today
+                // — effectiveLine === params.line when mode === 'pdg' — but this stays
+                // correct if the normalization ever stops being an identity here.
+                line: effectiveLine,
                 limit: Number.isFinite(params.limit) ? params.limit : 100,
                 // KTD2 extraction-seam discipline: hand the engine its DB dependency
                 // explicitly rather than `this.`-binding it. LocalBackend owns repo

package/dist/mcp/tools.js

@@ -425,8 +425,13 @@ SERVICE: optional monorepo path prefix (case-sensitive path segments). When "rep
                 },
                 line: {
                     type: 'integer',
-                    minimum: 1,
-                    description: "1-based source line — PDG statement anchor (mode:'pdg'). Seeds affectedStatements on the statement at this line; inter-procedural symbols are still returned in interproceduralByDepth/pdgInterprocedural and the compatibility byDepth bucket.",
+                    // `minimum: 0` (not 1) so strict client/agent adapters that materialize
+                    // an omitted optional numeric field as `0` do not reject the request
+                    // before sending (#2279). A positive line is still required for a real
+                    // pdg anchor — the backend enforces that — but `0`/omitted means "no
+                    // statement anchor" and is tolerated on the callgraph path.
+                    minimum: 0,
+                    description: "1-based source line — PDG statement anchor (mode:'pdg'). Seeds affectedStatements on the statement at this line; inter-procedural symbols are still returned in interproceduralByDepth/pdgInterprocedural and the compatibility byDepth bucket. Omit line for whole-symbol pdg (whole-symbol reach + diagnostics); a positive line anchors a statement slice. Literal 0 is tolerated only as an omitted-line compatibility sentinel on the callgraph path and is rejected for mode:'pdg'.",
                 },
                 file_path: {
                     type: 'string',

package/package.json

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