gitnexus 1.6.6-rc.79 → 1.6.6-rc.80

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

@@ -2371,6 +2371,7 @@ export class LocalBackend {
      */
     async _runImpactBFS(repo, sym, symType, direction, opts) {
         const { maxDepth, relationTypes, includeTests, minConfidence } = opts;
+        const skipPerSymbolEnrichment = opts.skipPerSymbolEnrichment ?? false;
         const hasExplicitLimit = typeof opts.limit === 'number' && Number.isFinite(opts.limit);
         const paginationLimit = hasExplicitLimit
             ? Math.max(1, Math.min(Math.trunc(opts.limit), 10000))
@@ -2501,11 +2502,20 @@ export class LocalBackend {
         const directCount = (grouped[1] || []).length;
         let affectedProcesses = [];
         let affectedModules = [];
+        // Per-symbol process membership: maps impacted symbol id -> list of processes
+        // it participates in. Populated by a second chunked Cypher pass below when
+        // any process is affected at all. Surfaced as `processes: [...]` on each
+        // byDepth item so consumers can tell which caller belongs to which cron/
+        // webhook/route without a follow-up query.
+        const perSymbolProcesses = new Map();
+        // Chunking bounds for batched DB round-trips. Declared at function scope so
+        // both the in-block enrichment passes and the post-pagination per-symbol
+        // process enrichment can reference them.
+        const CHUNK_SIZE = 100;
+        // Max number of chunks to process to avoid unbounded DB round-trips.
+        // Configurable via env IMPACT_MAX_CHUNKS, default 10 => max items = 1000
+        const MAX_CHUNKS = parseInt(process.env.IMPACT_MAX_CHUNKS || '10', 10);
         if (impacted.length > 0) {
-            const CHUNK_SIZE = 100;
-            // Max number of chunks to process to avoid unbounded DB round-trips.
-            // Configurable via env IMPACT_MAX_CHUNKS, default 10 => max items = 1000
-            const MAX_CHUNKS = parseInt(process.env.IMPACT_MAX_CHUNKS || '10', 10);
             // ── Process enrichment: batched chunking (bounded by MAX_CHUNKS) ─
             // Uses merged Cypher query (WITH + OPTIONAL MATCH) to fetch
             // process + entry point info in 1 round-trip per chunk. Converted to
@@ -2620,6 +2630,9 @@ export class LocalBackend {
                 earliest_broken_step: ep.earliest_broken_step === Infinity ? null : ep.earliest_broken_step,
             }))
                 .sort((a, b) => b.total_hits - a.total_hits);
+            // Per-symbol process membership is populated post-pagination (see below)
+            // so it covers exactly the symbols returned in byDepth, not a pre-capped
+            // flat slice that could miss depth-2+ symbols when depth-1 is large.
             // ── Module enrichment: use same cap as process enrichment and parameterized queries
             const maxItems = Math.min(impacted.length, MAX_CHUNKS * CHUNK_SIZE);
             const cappedImpacted = impacted.slice(0, maxItems);
@@ -2746,7 +2759,7 @@ export class LocalBackend {
         if (summaryOnly) {
             return base;
         }
-        // Apply limit/offset pagination per depth level
+        // Apply limit/offset pagination per depth level.
         const paginatedGrouped = {};
         let anyTruncated = false;
         for (const [depth, items] of Object.entries(grouped)) {
@@ -2757,8 +2770,81 @@ export class LocalBackend {
                 anyTruncated = true;
             }
         }
+        // ── Per-symbol process membership enrichment (post-pagination) ───────
+        // Runs after paginatedGrouped is built so we enrich only the IDs that
+        // actually appear in the response. This eliminates the false-empty
+        // processes:[] case where a depth-2+ symbol's flat position in `impacted`
+        // exceeded MAX_CHUNKS*CHUNK_SIZE even though it is returned by byDepth.
+        // Also uses DISTINCT + MIN(r.step) per (symbol, process) pair to avoid
+        // duplicate entries when a symbol has multiple STEP_IN_PROCESS edges.
+        // Skipped entirely when `skipPerSymbolEnrichment` is set (group cross-repo
+        // fan-out, which consumes byDepth but not byDepth[].processes); the
+        // attach-loop below still stamps an empty processes:[] for shape stability.
+        let perSymbolEnrichmentCapped = false;
+        if (affectedProcesses.length > 0 && !skipPerSymbolEnrichment) {
+            // Collect unique IDs from the paginated result in one pass.
+            const pageIds = new Set();
+            for (const items of Object.values(paginatedGrouped)) {
+                for (const it of items) {
+                    const id = String(it.id ?? '');
+                    if (id)
+                        pageIds.add(id);
+                }
+            }
+            // Bound the enrichment to the same ceiling as the aggregation pass
+            // (MAX_CHUNKS * CHUNK_SIZE) so a large paginated page cannot trigger
+            // unbounded DB round-trips (DoD 2.6). When capped, mark the result
+            // partial so callers know some returned symbols may carry an empty
+            // processes:[] that is a cap artifact, not a true absence.
+            const maxPageIds = MAX_CHUNKS * CHUNK_SIZE;
+            let pageIdArr = Array.from(pageIds);
+            if (pageIdArr.length > maxPageIds) {
+                pageIdArr = pageIdArr.slice(0, maxPageIds);
+                perSymbolEnrichmentCapped = true;
+            }
+            for (let i = 0; i < pageIdArr.length; i += CHUNK_SIZE) {
+                const chunkIds = pageIdArr.slice(i, i + CHUNK_SIZE);
+                try {
+                    const rows = await executeParameterized(repo.id, `
+            MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+            WHERE s.id IN $ids
+            RETURN s.id AS sid, p.id AS pid, p.heuristicLabel AS pName,
+                   p.processType AS pType, MIN(r.step) AS step
+          `, { ids: chunkIds }).catch(() => []);
+                    for (const row of rows) {
+                        const sid = row.sid ?? row[0];
+                        if (!sid)
+                            continue;
+                        const procEntry = {
+                            id: String(row.pid ?? row[1] ?? ''),
+                            label: String(row.pName ?? row[2] ?? ''),
+                            processType: String(row.pType ?? row[3] ?? ''),
+                            step: Number(row.step ?? row[4] ?? -1),
+                        };
+                        const list = perSymbolProcesses.get(String(sid));
+                        if (list)
+                            list.push(procEntry);
+                        else
+                            perSymbolProcesses.set(String(sid), [procEntry]);
+                    }
+                }
+                catch (e) {
+                    logQueryError('impact:per-symbol-process-chunk', e);
+                }
+            }
+        }
+        // Attach processes field to each paginated item.
+        for (const items of Object.values(paginatedGrouped)) {
+            for (const it of items) {
+                it.processes = perSymbolProcesses.get(String(it.id)) ?? [];
+            }
+        }
         return {
             ...base,
+            // Surface partial if the per-symbol enrichment was capped, even when the
+            // BFS traversal itself completed — some returned symbols may carry an
+            // empty processes:[] that is a cap artifact rather than a true absence.
+            ...(perSymbolEnrichmentCapped && { partial: true }),
             ...(anyTruncated && {
                 pagination: {
                     ...(Number.isFinite(paginationLimit) && { limit: paginationLimit }),
@@ -2830,11 +2916,20 @@ export class LocalBackend {
                 'METHOD_IMPLEMENTS',
             ];
         try {
+            // skipPerSymbolEnrichment suppresses ONLY the per-symbol STEP_IN_PROCESS
+            // enrichment pass while preserving byDepth. Group-mode cross-repo fan-out
+            // may fan across many repos; the per-symbol pass adds up to MAX_CHUNKS
+            // extra round-trips per repo, which is unacceptable at group scale. But
+            // cross-impact fan-out DOES consume byDepth (cross-impact.ts reads
+            // fan.byDepth to populate group by_depth), so summaryOnly would wrongly
+            // drop it. Group callers do not consume byDepth[].processes, so skipping
+            // only that enrichment is the correct, targeted suppression.
             return await this._runImpactBFS(repo, sym, symType, dir, {
                 maxDepth: opts.maxDepth,
                 relationTypes,
                 includeTests: opts.includeTests,
                 minConfidence: opts.minConfidence,
+                skipPerSymbolEnrichment: true,
             });
         }
         catch {

package/dist/mcp/tools.js

@@ -299,7 +299,7 @@ Output includes:
 - summary: direct callers, processes affected, modules affected
 - affected_processes: which execution flows break and at which step
 - affected_modules: which functional areas are hit (direct vs indirect)
-- byDepth: affected symbols grouped by traversal depth (paginated by limit/offset; omitted when summaryOnly:true — use byDepthCounts for totals per depth, pagination object when truncated)
+- byDepth: affected symbols grouped by traversal depth (paginated by limit/offset; omitted when summaryOnly:true — use byDepthCounts for totals per depth, pagination object when truncated). Each item includes a processes:[{id,label,processType,step}] field listing the execution flows that symbol participates in. Empty when the symbol has no process membership. Can ALSO be empty when partial:true is set — either the process-aggregation pass hit its cap before detecting affected processes, or per-symbol enrichment was capped on a very large page. When partial:true, do NOT treat processes:[] as proof of no participation; cross-check the top-level affected_processes list.
 
 Depth groups:
 - d=1: WILL BREAK (direct callers/importers)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.79",
+  "version": "1.6.6-rc.80",
   "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",