gitnexus 1.6.7-rc.4 → 1.6.7-rc.6

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.d.ts

@@ -47,7 +47,7 @@ import type { ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 /** Subset of `ScopeResolver` consumed by this pass. Accepting the
  *  subset rather than the full provider keeps tests and partial
  *  refactors lighter — callers only need to populate what we read. */
-type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'constraintCompatibility' | 'isStaticOnly'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'constraintCompatibility' | 'isStaticOnly'>;
 export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, handledSites: Set<string>, provider: ReceiverBoundProviderSubset, index: WorkspaceResolutionIndex, model: SemanticModel, options?: {
     readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
 }): number;

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -274,6 +274,34 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             if (provider.resolveThisViaEnclosingClass === true && receiverName === 'this') {
                 const enclosingClass = findEnclosingClassDef(site.inScope, scopes);
                 if (enclosingClass !== undefined) {
+                    const languageResolution = provider.resolveReceiverMember?.(enclosingClass, memberName, site, scopes, model);
+                    if (languageResolution?.kind === 'ambiguous') {
+                        options.recordResolutionOutcome?.({
+                            kind: 'suppressed',
+                            phase: 'receiver-bound-calls',
+                            filePath: parsed.filePath,
+                            name: site.name,
+                            range: site.atRange,
+                            reason: 'member-lookup-ambiguous',
+                            candidateIds: languageResolution.candidateIds,
+                        });
+                        handledSites.add(siteKey);
+                        continue;
+                    }
+                    if (languageResolution?.kind === 'resolved') {
+                        const memberDef = languageResolution.definition;
+                        const reason = site.kind === 'write' || site.kind === 'read'
+                            ? site.kind
+                            : memberDef.filePath !== parsed.filePath
+                                ? 'import-resolved'
+                                : 'global';
+                        const confidence = site.kind === 'write' || site.kind === 'read' ? 1.0 : 0.85;
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse);
+                        if (ok)
+                            emitted++;
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     const chain = [
                         enclosingClass.nodeId,
                         ...scopes.methodDispatch.mroFor(enclosingClass.nodeId),
@@ -530,6 +558,34 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     ownerDef = resolveCompoundReceiverClass(receiverName, site.inScope, scopes, index, compoundOpts);
                 }
                 if (ownerDef !== undefined) {
+                    const languageResolution = provider.resolveReceiverMember?.(ownerDef, memberName, site, scopes, model);
+                    if (languageResolution?.kind === 'ambiguous') {
+                        options.recordResolutionOutcome?.({
+                            kind: 'suppressed',
+                            phase: 'receiver-bound-calls',
+                            filePath: parsed.filePath,
+                            name: site.name,
+                            range: site.atRange,
+                            reason: 'member-lookup-ambiguous',
+                            candidateIds: languageResolution.candidateIds,
+                        });
+                        handledSites.add(siteKey);
+                        continue;
+                    }
+                    if (languageResolution?.kind === 'resolved') {
+                        const memberDef = languageResolution.definition;
+                        const reason = site.kind === 'write' || site.kind === 'read'
+                            ? site.kind
+                            : memberDef.filePath !== parsed.filePath
+                                ? 'import-resolved'
+                                : 'global';
+                        const confidence = site.kind === 'write' || site.kind === 'read' ? 1.0 : 0.85;
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse);
+                        if (ok)
+                            emitted++;
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     const chain = [ownerDef.nodeId, ...scopes.methodDispatch.mroFor(ownerDef.nodeId)];
                     let memberDef;
                     let ambiguous = false;

package/dist/core/ingestion/scope-resolution/resolution-outcome.d.ts

@@ -1,5 +1,5 @@
 import type { Range } from '../../../_shared/index.js';
-export type ResolutionSuppressionReason = 'adl-ordinary-lookup-blocked' | 'conversion-rank-tied' | 'inline-ns-ambiguous' | 'overload-ambiguous' | 'overload-ambiguous-normalization';
+export type ResolutionSuppressionReason = 'adl-ordinary-lookup-blocked' | 'conversion-rank-tied' | 'inline-ns-ambiguous' | 'member-lookup-ambiguous' | 'overload-ambiguous' | 'overload-ambiguous-normalization';
 export type ResolutionOutcome = {
     readonly kind: 'resolved';
     readonly targetId: string;

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

@@ -39,6 +39,17 @@ const MAX_POOL_SIZE = 5;
 const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 /** Max connections per repo (caps concurrent queries per repo) */
 const MAX_CONNS_PER_REPO = 8;
+// Behavior-neutral RSS tracing for the FTS evict→reload memory repro
+// (gitnexus/scripts/bench/fts-evict-reload-rss.mjs). Two invariants keep it safe
+// in the pool init/close hot path: it writes ONLY to stderr (stdout is the MCP
+// JSON-RPC channel), and the GITNEXUS_POOL_RSS_TRACE gate makes it a no-op — one
+// env-var compare per call, nothing else — unless a harness explicitly enables it.
+function traceRss(event, repoId) {
+    if (process.env.GITNEXUS_POOL_RSS_TRACE !== '1')
+        return;
+    const rssMb = Math.round(process.memoryUsage().rss / (1024 * 1024));
+    process.stderr.write(`[pool-rss] ${event} repo=${repoId} pool=${pool.size} dbCache=${dbCache.size} rssMB=${rssMb}\n`);
+}
 let idleTimer = null;
 // Stdout-capture state lives in `gitnexus/src/mcp/stdio-capture.ts` — a leaf
 // module with zero non-`node:` imports. We re-export the same symbols here
@@ -166,6 +177,7 @@ function closeOne(repoId) {
             // Isolate listener failures — teardown must complete.
         }
     }
+    traceRss('close', repoId);
 }
 /**
  * Create a new Connection from a repo's Database.
@@ -511,6 +523,7 @@ async function doInitLbug(repoId, dbPath) {
         closed: false,
     });
     ensureIdleTimer();
+    traceRss('init', repoId);
 }
 /**
  * Initialize a pool entry from a pre-existing Database object.
@@ -565,6 +578,7 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
         closed: false,
     });
     ensureIdleTimer();
+    traceRss('init', repoId);
 }
 /**
  * Checkout a connection from the pool.

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

@@ -143,6 +143,18 @@ function logQueryError(context, err) {
     const msg = err instanceof Error ? err.message : String(err);
     logger.error({ context, err: msg }, 'GitNexus query failed');
 }
+/**
+ * A "missing table/label/relation" prepare error is benign for the query tool's
+ * best-effort enrichment: a repo analyzed without processes or communities simply
+ * has no `Process`/`Community` tables, so the `STEP_IN_PROCESS` / `MEMBER_OF`
+ * enrichment queries fail to prepare. That is a normal configuration, NOT a
+ * degraded result — it must not raise the `partial` flag (which callers would
+ * then learn to ignore). Real failures (timeouts, locks, native faults) do.
+ */
+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);
+}
 const isReadOnlyDbError = (err) => {
     // Walk the `cause` chain (bounded) so a wrapped read-only error (e.g. the
     // pool adapter's `{ cause }` wrapper) is still detected here — this is the
@@ -925,61 +937,117 @@ export class LocalBackend {
         timer.start('symbol_lookup');
         const processMap = new Map();
         const definitions = []; // standalone symbols not in any process
-        for (const [_, item] of merged) {
-            const sym = item.data;
-            if (!sym.nodeId) {
-                // File-level results go to definitions
-                definitions.push({
-                    name: sym.name,
-                    type: sym.type || 'File',
-                    filePath: sym.filePath,
-                });
-                continue;
-            }
-            // Find processes this symbol participates in
-            let processRows = [];
+        // Batch-fetch process participation, cohesion, and (optionally) content for
+        // ALL matched symbols in 2-3 graph queries instead of 2-3 *per symbol*. The
+        // previous per-symbol loop issued up to 3N sequential pool round-trips
+        // (searchLimit symbols × {STEP_IN_PROCESS, MEMBER_OF, content}); on a warm
+        // repo the IPC + query-setup overhead of those round-trips dominated query
+        // latency. Collapsing to `WHERE n.id IN $nodeIds` preserves identical output
+        // (the aggregation loop below is unchanged) while cutting the round-trips.
+        // Array params bind through the pool exactly as bm25Search's
+        // `WHERE n.id IN $nodeIds` already does. (Ported from gitnexus-enterprise
+        // PR #222 — N+1 → 2-3 batched queries.)
+        const nodeIds = merged.map(([, m]) => m.data?.nodeId).filter((id) => !!id);
+        const processRowsByNode = new Map();
+        const cohesionByNode = new Map();
+        const contentByNode = new Map();
+        // Set when a batched enrichment query throws a REAL failure (timeout, lock,
+        // native fault) — NOT the benign "no Process/Community table" case, which is
+        // a normal config (a repo analyzed without processes/communities) and must
+        // not raise a `partial` flag callers would learn to ignore. See
+        // isBenignMissingTableError + the response build below.
+        let enrichmentDegraded = false;
+        // Chunk the IN-list like the impact path (CHUNK_SIZE=100) so a large result
+        // set never builds an unbounded `IN` parameter. Default batch is
+        // processLimit*maxSymbolsPerProcess (≤ one chunk), but chunk for robustness.
+        const QUERY_CHUNK_SIZE = 100;
+        for (let i = 0; i < nodeIds.length; i += QUERY_CHUNK_SIZE) {
+            const ids = nodeIds.slice(i, i + QUERY_CHUNK_SIZE);
+            // Processes each symbol participates in. `n.id AS nodeId` is prepended as
+            // column 0 so rows from many symbols can be re-associated to their symbol.
             try {
-                processRows = await executeParameterized(repo.lbugPath, `
-          MATCH (n {id: $nodeId})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-          RETURN p.id AS pid, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount, r.step AS step
-        `, { nodeId: sym.nodeId });
+                const rows = await executeParameterized(repo.lbugPath, `
+          MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+          WHERE n.id IN $nodeIds
+          RETURN n.id AS nodeId, p.id AS pid, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount, r.step AS step
+        `, { nodeIds: ids });
+                for (const row of rows) {
+                    const nid = row.nodeId ?? row[0];
+                    let list = processRowsByNode.get(nid);
+                    if (!list)
+                        processRowsByNode.set(nid, (list = []));
+                    list.push(row);
+                }
             }
             catch (e) {
                 logQueryError('query:process-lookup', e);
+                if (!isBenignMissingTableError(e))
+                    enrichmentDegraded = true;
             }
-            // Get cluster membership + cohesion (cohesion used as internal ranking signal)
-            let cohesion = 0;
-            let module;
+            // Cluster membership + cohesion. Keep the FIRST community row per node to
+            // mirror the prior per-symbol `LIMIT 1` (each symbol keeps ITS community,
+            // not one community for the whole batch).
             try {
-                const cohesionRows = await executeParameterized(repo.lbugPath, `
-          MATCH (n {id: $nodeId})-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-          RETURN c.cohesion AS cohesion, c.heuristicLabel AS module
-          LIMIT 1
-        `, { nodeId: sym.nodeId });
-                if (cohesionRows.length > 0) {
-                    cohesion = (cohesionRows[0].cohesion ?? cohesionRows[0][0]) || 0;
-                    module = cohesionRows[0].module ?? cohesionRows[0][1];
+                const rows = await executeParameterized(repo.lbugPath, `
+          MATCH (n)-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
+          WHERE n.id IN $nodeIds
+          RETURN n.id AS nodeId, c.cohesion AS cohesion, c.heuristicLabel AS module
+        `, { nodeIds: ids });
+                for (const row of rows) {
+                    const nid = row.nodeId ?? row[0];
+                    if (!cohesionByNode.has(nid)) {
+                        cohesionByNode.set(nid, {
+                            cohesion: (row.cohesion ?? row[1]) || 0,
+                            module: row.module ?? row[2],
+                        });
+                    }
                 }
             }
             catch (e) {
                 logQueryError('query:cluster-info', e);
+                if (!isBenignMissingTableError(e))
+                    enrichmentDegraded = true;
             }
-            // Optionally fetch content
-            let content;
+            // Optionally fetch content for every matched symbol.
             if (includeContent) {
                 try {
-                    const contentRows = await executeParameterized(repo.lbugPath, `
-            MATCH (n {id: $nodeId})
-            RETURN n.content AS content
-          `, { nodeId: sym.nodeId });
-                    if (contentRows.length > 0) {
-                        content = contentRows[0].content ?? contentRows[0][0];
+                    const rows = await executeParameterized(repo.lbugPath, `
+            MATCH (n)
+            WHERE n.id IN $nodeIds
+            RETURN n.id AS nodeId, n.content AS content
+          `, { nodeIds: ids });
+                    for (const row of rows) {
+                        const nid = row.nodeId ?? row[0];
+                        contentByNode.set(nid, row.content ?? row[1]);
                     }
                 }
                 catch (e) {
                     logQueryError('query:content-fetch', e);
+                    if (!isBenignMissingTableError(e))
+                        enrichmentDegraded = true;
                 }
             }
+        }
+        // Aggregation is unchanged from the per-symbol version — it now reads the
+        // pre-fetched maps instead of issuing a query per symbol. Iterating `merged`
+        // in the same (sorted) order preserves processMap insertion order, the
+        // definitions order, and the item.score association exactly.
+        for (const [_, item] of merged) {
+            const sym = item.data;
+            if (!sym.nodeId) {
+                // File-level results go to definitions
+                definitions.push({
+                    name: sym.name,
+                    type: sym.type || 'File',
+                    filePath: sym.filePath,
+                });
+                continue;
+            }
+            const processRows = processRowsByNode.get(sym.nodeId) ?? [];
+            const coh = cohesionByNode.get(sym.nodeId);
+            const cohesion = coh?.cohesion ?? 0;
+            const module = coh?.module;
+            const content = includeContent ? contentByNode.get(sym.nodeId) : undefined;
             const symbolEntry = {
                 id: sym.nodeId,
                 name: sym.name,
@@ -997,12 +1065,13 @@ export class LocalBackend {
             else {
                 // Add to each process it belongs to
                 for (const row of processRows) {
-                    const pid = row.pid ?? row[0];
-                    const label = row.label ?? row[1];
-                    const hLabel = row.heuristicLabel ?? row[2];
-                    const pType = row.processType ?? row[3];
-                    const stepCount = row.stepCount ?? row[4];
-                    const step = row.step ?? row[5];
+                    // Positional fallbacks shift +1 because `n.id AS nodeId` is column 0.
+                    const pid = row.pid ?? row[1];
+                    const label = row.label ?? row[2];
+                    const hLabel = row.heuristicLabel ?? row[3];
+                    const pType = row.processType ?? row[4];
+                    const stepCount = row.stepCount ?? row[5];
+                    const step = row.step ?? row[6];
                     if (!processMap.has(pid)) {
                         processMap.set(pid, {
                             id: pid,
@@ -1066,14 +1135,24 @@ export class LocalBackend {
         timer.mark('wall', performance.now() - wallStart);
         const timing = timer.summary();
         logQueryTiming(searchQuery, timing);
+        // Compose a single `warning` from all degraded conditions (FTS-missing
+        // and/or a real enrichment failure) so neither overwrites the other, and
+        // flag `partial` when enrichment was lost. Both are omitted on the clean
+        // path, leaving the success-path response shape byte-identical.
+        const warnings = [];
+        if (!ftsUsed) {
+            warnings.push('FTS indexes missing — keyword search degraded. Run: gitnexus analyze --repair-fts (or gitnexus analyze --force) to rebuild indexes.');
+        }
+        if (enrichmentDegraded) {
+            warnings.push('Symbol enrichment partially failed — some process/cohesion/content data may be missing from these results (see server logs).');
+        }
         return {
             processes,
             process_symbols: dedupedSymbols,
             definitions: definitions.slice(0, 20), // cap standalone definitions
             timing,
-            ...(!ftsUsed && {
-                warning: 'FTS indexes missing — keyword search degraded. Run: gitnexus analyze --repair-fts (or gitnexus analyze --force) to rebuild indexes.',
-            }),
+            ...(warnings.length > 0 && { warning: warnings.join(' ') }),
+            ...(enrichmentDegraded && { partial: true }),
         };
     }
     /**

package/package.json

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