gitnexus 1.6.11-rc.28 → 1.6.11-rc.29

package/dist/cli/analyze.js

@@ -524,6 +524,8 @@ const ANALYZE_CLI_ENV_KEYS = [
     'GITNEXUS_EMBEDDING_SUB_BATCH_SIZE',
     'GITNEXUS_EMBEDDING_DEVICE',
     'GITNEXUS_ANALYZE_PROGRESS_ACTIVE',
+    'GITNEXUS_ANALYZER_IDENTITY_IN_PROCESS_GUARDS',
+    'GITNEXUS_RESOLVE_DEF_GRAPH_ID_MEMO',
     'GITNEXUS_EMBEDDING_URL',
     'GITNEXUS_EMBEDDING_MODEL',
     'GITNEXUS_EMBEDDING_API_KEY',

package/dist/core/analyzer-identity.js

@@ -13,12 +13,13 @@
  * different entry files inside the same build tree; alternating between them
  * must not make an otherwise identical index stale.
  */
-import { closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { accessSync, closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { createHash, randomBytes } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { isDeepStrictEqual } from 'node:util';
 import os from 'node:os';
 import path from 'node:path';
+import { parseTruthyEnv } from './ingestion/utils/env.js';
 import { fileURLToPath } from 'node:url';
 export const ANALYZER_RUNNER_IDENTITY_SCHEMA_VERSION = 4;
 const BUILD_CANONICALIZATION = 'gitnexus-analyzer-build-v2';
@@ -1754,9 +1755,26 @@ function snapshotCacheGuardDirect(request) {
         return null;
     }
 }
-function snapshotCacheGuards(requests) {
+function installTreeUnwritable(packageRoot, buildRoot) {
+    for (const dir of [packageRoot, buildRoot]) {
+        try {
+            accessSync(dir, fsConstants.W_OK);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'EACCES' || code === 'EROFS')
+                return true;
+        }
+    }
+    return false;
+}
+function snapshotCacheGuards(requests, packageRoot, buildRoot) {
     if (requests.length < 128)
         return requests.map(snapshotCacheGuardDirect);
+    if (parseTruthyEnv(process.env.GITNEXUS_ANALYZER_IDENTITY_IN_PROCESS_GUARDS) ||
+        installTreeUnwritable(packageRoot, buildRoot)) {
+        return requests.map(snapshotCacheGuardDirect);
+    }
     try {
         const probe = spawnSync(process.execPath, ['--input-type=commonjs', '-e', CACHE_GUARD_PROBE_SCRIPT], {
             input: JSON.stringify(requests),
@@ -1857,7 +1875,7 @@ function validateIdentityCache(cache, options) {
         return { mode, absolutePath };
     });
     options.onCacheValidationPass?.({ guardCount: requests.length });
-    const actual = snapshotCacheGuards(requests);
+    const actual = snapshotCacheGuards(requests, cache.packageRoot, cache.buildRoot);
     const mismatch = actual.findIndex((result, index) => !isDeepStrictEqual(result, entries[index][1]));
     if (mismatch !== -1) {
         const [mode, absolutePath] = JSON.parse(entries[mismatch][0]);

package/dist/core/ingestion/model/field-registry.d.ts

@@ -2,9 +2,9 @@
  * Field Registry
  *
  * Owner-scoped field/property index extracted from SymbolTable.
- * Stores Property / Variable / Const / Static symbols keyed by
- * `ownerNodeId\0fieldName` for O(1) lookup. Supports multiple defs
- * under the same (owner, name) — e.g. legacy Property plus a
+ * Stores Property / Variable / Const / Static symbols in a nested
+ * `Map<ownerNodeId, Map<fieldName, defs[]>>` for O(1) lookup. Supports
+ * multiple defs under the same (owner, name) — e.g. legacy Property plus a
  * scope-resolution Variable reconciliation entry.
  */
 import type { SymbolDefinition } from '../../../_shared/index.js';

package/dist/core/ingestion/model/field-registry.js

@@ -2,9 +2,9 @@
  * Field Registry
  *
  * Owner-scoped field/property index extracted from SymbolTable.
- * Stores Property / Variable / Const / Static symbols keyed by
- * `ownerNodeId\0fieldName` for O(1) lookup. Supports multiple defs
- * under the same (owner, name) — e.g. legacy Property plus a
+ * Stores Property / Variable / Const / Static symbols in a nested
+ * `Map<ownerNodeId, Map<fieldName, defs[]>>` for O(1) lookup. Supports
+ * multiple defs under the same (owner, name) — e.g. legacy Property plus a
  * scope-resolution Variable reconciliation entry.
  */
 const EMPTY = Object.freeze([]);
@@ -14,20 +14,24 @@ const EMPTY = Object.freeze([]);
 export const createFieldRegistry = () => {
     const fieldByOwner = new Map();
     const lookupAllByOwner = (ownerNodeId, fieldName) => {
-        return fieldByOwner.get(`${ownerNodeId}\0${fieldName}`) ?? EMPTY;
+        return fieldByOwner.get(ownerNodeId)?.get(fieldName) ?? EMPTY;
     };
     const lookupFieldByOwner = (ownerNodeId, fieldName) => {
         const pool = lookupAllByOwner(ownerNodeId, fieldName);
         return pool.length === 0 ? undefined : pool[0];
     };
     const register = (ownerNodeId, fieldName, def) => {
-        const key = `${ownerNodeId}\0${fieldName}`;
-        const existing = fieldByOwner.get(key);
+        let byName = fieldByOwner.get(ownerNodeId);
+        if (!byName) {
+            byName = new Map();
+            fieldByOwner.set(ownerNodeId, byName);
+        }
+        const existing = byName.get(fieldName);
         if (existing) {
             existing.push(def);
         }
         else {
-            fieldByOwner.set(key, [def]);
+            byName.set(fieldName, [def]);
         }
     };
     const clear = () => {

package/dist/core/ingestion/model/method-registry.d.ts

@@ -2,9 +2,9 @@
  * Method Registry
  *
  * Owner-scoped method index extracted from SymbolTable.
- * Stores Method/Constructor/Function-with-ownerId symbols keyed by
- * `ownerNodeId\0methodName` for O(1) lookup. Supports overloads
- * (array values) and arity-based filtering.
+ * Stores Method/Constructor/Function-with-ownerId symbols in a nested
+ * `Map<ownerNodeId, Map<methodName, defs[]>>` for O(1) lookup. Supports
+ * overloads (array values) and arity-based filtering.
  */
 import type { SymbolDefinition } from '../../../_shared/index.js';
 export interface MethodRegistry {

package/dist/core/ingestion/model/method-registry.js

@@ -2,9 +2,9 @@
  * Method Registry
  *
  * Owner-scoped method index extracted from SymbolTable.
- * Stores Method/Constructor/Function-with-ownerId symbols keyed by
- * `ownerNodeId\0methodName` for O(1) lookup. Supports overloads
- * (array values) and arity-based filtering.
+ * Stores Method/Constructor/Function-with-ownerId symbols in a nested
+ * `Map<ownerNodeId, Map<methodName, defs[]>>` for O(1) lookup. Supports
+ * overloads (array values) and arity-based filtering.
  */
 // ---------------------------------------------------------------------------
 // Factory
@@ -19,8 +19,9 @@ export const createMethodRegistry = () => {
     // Set once when a Function+ownerId def lands here, powers the Tier 3
     // dedup fast-path. Monotonic: never unset except on `clear()`.
     let hasFunctionMethodsFlag = false;
+    const ownerDefs = (ownerNodeId, methodName) => methodByOwner.get(ownerNodeId)?.get(methodName);
     const lookupMethodByOwner = (ownerNodeId, methodName, argCount) => {
-        const defs = methodByOwner.get(`${ownerNodeId}\0${methodName}`);
+        const defs = ownerDefs(ownerNodeId, methodName);
         if (!defs || defs.length === 0)
             return undefined;
         // Arity narrowing: when an argCount is provided and there are multiple
@@ -89,16 +90,20 @@ export const createMethodRegistry = () => {
         return methodsByName.get(name) ?? EMPTY;
     };
     const lookupAllByOwner = (ownerNodeId, methodName) => {
-        return methodByOwner.get(`${ownerNodeId}\0${methodName}`) ?? EMPTY;
+        return ownerDefs(ownerNodeId, methodName) ?? EMPTY;
     };
     const register = (ownerNodeId, methodName, def) => {
-        const key = `${ownerNodeId}\0${methodName}`;
-        const existing = methodByOwner.get(key);
+        let owned = methodByOwner.get(ownerNodeId);
+        if (!owned) {
+            owned = new Map();
+            methodByOwner.set(ownerNodeId, owned);
+        }
+        const existing = owned.get(methodName);
         if (existing) {
             existing.push(def);
         }
         else {
-            methodByOwner.set(key, [def]);
+            owned.set(methodName, [def]);
         }
         const byName = methodsByName.get(methodName);
         if (byName) {

package/dist/core/ingestion/model/type-registry.js

@@ -24,7 +24,7 @@ export const createTypeRegistry = () => {
         return implByName.get(name) ?? [];
     };
     const lookupAllByOwner = (ownerNodeId, simpleName) => {
-        return nestedByOwner.get(`${ownerNodeId}\0${simpleName}`) ?? EMPTY;
+        return nestedByOwner.get(ownerNodeId)?.get(simpleName) ?? EMPTY;
     };
     const registerClass = (name, qualifiedName, def) => {
         const existing = classByName.get(name);
@@ -52,13 +52,17 @@ export const createTypeRegistry = () => {
         }
     };
     const registerByOwner = (ownerNodeId, simpleName, def) => {
-        const key = `${ownerNodeId}\0${simpleName}`;
-        const existing = nestedByOwner.get(key);
+        let byName = nestedByOwner.get(ownerNodeId);
+        if (!byName) {
+            byName = new Map();
+            nestedByOwner.set(ownerNodeId, byName);
+        }
+        const existing = byName.get(simpleName);
         if (existing) {
             existing.push(def);
         }
         else {
-            nestedByOwner.set(key, [def]);
+            byName.set(simpleName, [def]);
         }
     };
     const clear = () => {

package/dist/core/ingestion/scope-resolution/graph-bridge/ids.js

@@ -22,6 +22,15 @@ import { isOverloadableCallable, isPositionQualifiedLocalLabel, } from '../../ut
 import { templateConstraintsIdTag } from '../../utils/template-arguments.js';
 import { parameterShapeIdTag } from '../../utils/method-props.js';
 import { definitionIdPosition } from '../utils/definition-id.js';
+const defGraphIdMemoByLookup = new WeakMap();
+const isResolveDefGraphIdMemoEnabled = () => {
+    const raw = process.env.GITNEXUS_RESOLVE_DEF_GRAPH_ID_MEMO;
+    if (raw === undefined || raw.trim() === '')
+        return true;
+    const value = raw.trim().toLowerCase();
+    return value !== '0' && value !== 'false' && value !== 'off' && value !== 'no';
+};
+const defGraphIdMemoKey = (filePath, def) => `${filePath}\0${def.nodeId ?? ''}\0${def.type ?? ''}\0${def.qualifiedName ?? ''}\0${def.parameterCount ?? ''}\0${(def.parameterTypes ?? []).join(',')}\0${(def.parameterTypeClasses ?? []).join(',')}\0${def.namespacePrefix ?? ''}\0${(def.templateArguments ?? []).join(',')}\0${templateConstraintsIdTag(def.templateConstraints)}`;
 /**
  * Labels that may legitimately ANCHOR a CALLS/ACCESSES edge as the
  * source ("caller"). A Variable / Property can be the TARGET of an
@@ -188,6 +197,25 @@ function siblingCallableLabel(label) {
     return undefined;
 }
 export function resolveDefGraphId(filePath, def, nodeLookup) {
+    if (!isResolveDefGraphIdMemoEnabled()) {
+        return resolveDefGraphIdUncached(filePath, def, nodeLookup);
+    }
+    const qn = def.qualifiedName;
+    if (qn === undefined || qn.length === 0)
+        return undefined;
+    let bucket = defGraphIdMemoByLookup.get(nodeLookup);
+    if (bucket === undefined) {
+        bucket = new Map();
+        defGraphIdMemoByLookup.set(nodeLookup, bucket);
+    }
+    const key = defGraphIdMemoKey(filePath, def);
+    if (bucket.has(key))
+        return bucket.get(key);
+    const resolved = resolveDefGraphIdUncached(filePath, def, nodeLookup);
+    bucket.set(key, resolved);
+    return resolved;
+}
+function resolveDefGraphIdUncached(filePath, def, nodeLookup) {
     const qn = def.qualifiedName;
     if (qn === undefined || qn.length === 0)
         return undefined;

package/dist/core/ingestion/scope-resolution/passes/callable-value-flow.d.ts

@@ -3,7 +3,7 @@
  * values. Providers own syntax recognition; this pass consumes only the
  * JSON-safe facts carried by ParsedFile.
  */
-import type { ParsedFile, SymbolDefinition } from '../../../../_shared/index.js';
+import type { CallableFlowExpectedSignature, ParsedFile, SymbolDefinition } from '../../../../_shared/index.js';
 import type { KnowledgeGraph } from '../../../graph/types.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
@@ -44,6 +44,14 @@ export interface EmitCallableValueFlowInput {
     readonly isCallableValueTarget?: (def: SymbolDefinition) => boolean;
     readonly hasFileLocalCallableLinkage?: (def: SymbolDefinition) => boolean;
     readonly onWarn?: (warning: CallableValueFlowWarning) => void;
+    /** When set, skip a second `collectDeferredIndirectSites` walk. */
+    readonly deferredIndirectSites?: ReadonlySet<string>;
+    /** When set, skip a second `referenceSites` signature walk. */
+    readonly callSignaturesBySite?: ReadonlyMap<string, CallableFlowExpectedSignature>;
+}
+export interface DeferredIndirectCollection {
+    readonly sites: ReadonlySet<string>;
+    readonly callSignaturesBySite: ReadonlyMap<string, CallableFlowExpectedSignature>;
 }
 /** Position key shared with the existing free/reference skip-set contract. */
 export declare function callableFlowSiteKey(filePath: string, range: {
@@ -55,6 +63,8 @@ export declare function callableFlowSiteKey(filePath: string, range: {
  * Malformed/stale facts never suppress ordinary resolution.
  */
 export declare function collectDeferredIndirectSites(parsedFiles: readonly ParsedFile[], scopes?: ScopeResolutionIndexes): ReadonlySet<string>;
+/** One `referenceSites` walk for deferred keys and call-signature evidence. */
+export declare function collectDeferredIndirectCollection(parsedFiles: readonly ParsedFile[], scopes?: ScopeResolutionIndexes): DeferredIndirectCollection;
 export declare function emitCallableValueFlow(input: EmitCallableValueFlowInput): CallableValueFlowResult;
 /**
  * Pure — exported for `bench/callable-value-flow/measure.mjs`, which guards its

package/dist/core/ingestion/scope-resolution/passes/callable-value-flow.js

@@ -28,7 +28,12 @@ export function callableFlowSiteKey(filePath, range) {
  * Malformed/stale facts never suppress ordinary resolution.
  */
 export function collectDeferredIndirectSites(parsedFiles, scopes) {
+    return collectDeferredIndirectCollection(parsedFiles, scopes).sites;
+}
+/** One `referenceSites` walk for deferred keys and call-signature evidence. */
+export function collectDeferredIndirectCollection(parsedFiles, scopes) {
     const out = new Set();
+    const callSignaturesBySite = new Map();
     const flowCells = new Set();
     if (scopes !== undefined) {
         for (const parsed of parsedFiles) {
@@ -41,9 +46,24 @@ export function collectDeferredIndirectSites(parsedFiles, scopes) {
         }
     }
     for (const parsed of parsedFiles) {
-        const canonical = new Set(parsed.referenceSites
-            .filter((site) => site.kind === 'call')
-            .map((site) => callableFlowSiteKey(parsed.filePath, site.atRange)));
+        const canonical = new Set();
+        for (const site of parsed.referenceSites) {
+            if (site.kind !== 'call')
+                continue;
+            const key = callableFlowSiteKey(parsed.filePath, site.atRange);
+            canonical.add(key);
+            const signature = {
+                ...(site.arity !== undefined ? { parameterCount: site.arity } : {}),
+                ...(site.argumentTypes !== undefined ? { parameterTypes: site.argumentTypes } : {}),
+                ...(site.argumentTypeClasses !== undefined
+                    ? { parameterTypeClasses: site.argumentTypeClasses }
+                    : {}),
+            };
+            const previous = callSignaturesBySite.get(key);
+            if (previous === undefined || signatureEvidence(signature) > signatureEvidence(previous)) {
+                callSignaturesBySite.set(key, signature);
+            }
+        }
         for (const site of parsed.callableFlowSites ?? []) {
             if (site.kind !== 'invoke')
                 continue;
@@ -58,7 +78,7 @@ export function collectDeferredIndirectSites(parsedFiles, scopes) {
             }
         }
     }
-    return out;
+    return { sites: out, callSignaturesBySite };
 }
 function flowCellOperand(site) {
     switch (site.kind) {
@@ -80,7 +100,7 @@ function flowCellOperand(site) {
 export function emitCallableValueFlow(input) {
     const facts = [];
     const invokes = [];
-    const canonicalInvokeKeys = collectDeferredIndirectSites(input.parsedFiles, input.scopes);
+    const canonicalInvokeKeys = input.deferredIndirectSites ?? collectDeferredIndirectSites(input.parsedFiles, input.scopes);
     let unmatchedInvokes = 0;
     for (const parsed of input.parsedFiles) {
         for (const site of parsed.callableFlowSites ?? []) {
@@ -347,7 +367,7 @@ export function emitCallableValueFlow(input) {
         addAddress(bindingKey(fact.filePath, fact.site.destination), bindingKey(fact.filePath, fact.site.source), `address:${fact.filePath}:${fact.site.source.name}`);
     }
     const formalsByGraphId = indexFormalsByGraphId(input.parsedFiles, input.scopes, input.nodeLookup, targetIndexes, aliasesByTargetId);
-    const callSignaturesBySite = indexCallSignatures(input.parsedFiles);
+    const callSignaturesBySite = input.callSignaturesBySite ?? indexCallSignatures(input.parsedFiles);
     const dynamicCallees = new Map();
     const dynamicOverflow = new Set();
     const dynamicTargetHistory = new Map();

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -49,7 +49,7 @@ import { emitReturnShapeMemberAccesses } from '../passes/return-shape-members.js
 import { emitImportedValueReferences } from '../passes/imported-value-refs.js';
 import { createCalleeIdAccumulator, } from '../graph-bridge/callee-id-sink.js';
 import { emitImportEdges } from '../graph-bridge/imports-to-edges.js';
-import { callableFlowSiteKey, collectDeferredIndirectSites, emitCallableValueFlow, } from '../passes/callable-value-flow.js';
+import { callableFlowSiteKey, collectDeferredIndirectCollection, emitCallableValueFlow, } from '../passes/callable-value-flow.js';
 import { findEnclosingClassDef, resolveInheritanceBaseInScope } from '../scope/walkers.js';
 import { heritageTypeArgumentsKey, } from '../utils/generic-instantiation.js';
 import { buildWorkspaceResolutionIndex } from '../workspace-index.js';
@@ -614,7 +614,8 @@ export function runScopeResolution(input, provider) {
     // ── Phase 4: emit graph edges (LOAD-BEARING ORDER — see I1) ────────────
     input.onProgress?.('linking symbols', files.length, files.length);
     const handledSites = new Set(preEmittedInheritanceSites);
-    const deferredIndirectSites = collectDeferredIndirectSites(emitParsedFiles, indexes);
+    const deferredIndirectCollection = collectDeferredIndirectCollection(emitParsedFiles, indexes);
+    const deferredIndirectSites = deferredIndirectCollection.sites;
     const callableArgumentSites = new Set();
     if (input.pdg !== true && deferredIndirectSites.size > 0) {
         for (const parsed of emitParsedFiles) {
@@ -788,6 +789,8 @@ export function runScopeResolution(input, provider) {
             collapseByCallerTarget: provider.collapseMemberCallsByCallerTarget === true,
             isCallableValueTarget: provider.isCallableValueTarget,
             hasFileLocalCallableLinkage: provider.hasFileLocalCallableLinkage,
+            deferredIndirectSites,
+            callSignaturesBySite: deferredIndirectCollection.callSignaturesBySite,
             onWarn: (warning) => logger.warn(warning, 'callable-value-flow: candidate set exceeded the cap; no partial CALLS emitted'),
         });
     const importsEmitted = callableFlowOnly

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

@@ -152,14 +152,15 @@ export const isBinaryContent = (content) => {
     }
     return nonPrintable / end > 0.1;
 };
+const EMPTY_PREPARED = { content: '', lines: [''], isBinary: false };
 /**
  * LRU content cache — avoids re-reading the same source file for every
  * symbol defined in it. Sized generously so most files stay cached during
- * the single-pass node iteration.
+ * the single-pass node iteration. Insertion order on the Map is LRU
+ * (delete+set on touch).
  */
 class FileContentCache {
     cache = new Map();
-    accessOrder = [];
     maxSize;
     repoPath;
     constructor(repoPath, maxSize = 3000) {
@@ -168,36 +169,36 @@ class FileContentCache {
     }
     async get(relativePath) {
         if (!relativePath)
-            return '';
+            return EMPTY_PREPARED;
         const cached = this.cache.get(relativePath);
         if (cached !== undefined) {
-            // Move to end of accessOrder (LRU promotion)
-            const idx = this.accessOrder.indexOf(relativePath);
-            if (idx !== -1) {
-                this.accessOrder.splice(idx, 1);
-                this.accessOrder.push(relativePath);
-            }
+            this.cache.delete(relativePath);
+            this.cache.set(relativePath, cached);
             return cached;
         }
         try {
             const fullPath = path.join(this.repoPath, relativePath);
             const content = await fs.readFile(fullPath, 'utf-8');
-            this.set(relativePath, content);
-            return content;
+            const prepared = {
+                content,
+                lines: content.split('\n'),
+                isBinary: isBinaryContent(content),
+            };
+            this.set(relativePath, prepared);
+            return prepared;
         }
         catch {
-            this.set(relativePath, '');
-            return '';
+            this.set(relativePath, EMPTY_PREPARED);
+            return EMPTY_PREPARED;
         }
     }
     set(key, value) {
-        if (this.cache.size >= this.maxSize) {
-            const oldest = this.accessOrder.shift();
-            if (oldest)
+        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            const oldest = this.cache.keys().next().value;
+            if (oldest !== undefined)
                 this.cache.delete(oldest);
         }
         this.cache.set(key, value);
-        this.accessOrder.push(key);
     }
 }
 /**
@@ -247,12 +248,13 @@ const formatFtsDescription = (description) => isBinaryContent(description) ? ''
 const EXACT_SYMBOL_CONTENT_LABELS = SYMBOL_NODE_LABELS;
 const extractContent = async (node, contentCache) => {
     const filePath = node.properties.filePath;
-    const content = await contentCache.get(filePath);
+    const prepared = await contentCache.get(filePath);
+    const content = prepared.content;
     if (!content)
         return '';
     if (node.label === 'Folder')
         return '';
-    if (isBinaryContent(content))
+    if (prepared.isBinary)
         return '[Binary file - content not stored]';
     // File content is stored in full — intentionally NOT length-capped here, so
     // text past the old 10KB cutoff stays FTS-searchable (#2317). It is already
@@ -266,7 +268,7 @@ const extractContent = async (node, contentCache) => {
     const endLine = node.properties.endLine;
     if (startLine === undefined || endLine === undefined)
         return '';
-    const lines = content.split('\n');
+    const lines = prepared.lines;
     const exactSymbolContent = EXACT_SYMBOL_CONTENT_LABELS.has(node.label);
     const start = Math.max(0, exactSymbolContent ? startLine : startLine - 2);
     const end = Math.min(lines.length - 1, exactSymbolContent ? endLine : endLine + 2);

package/package.json

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