gitnexus 1.6.5-rc.44 → 1.6.5-rc.46

package/dist/core/ingestion/languages/cpp/inline-namespaces.d.ts

@@ -60,8 +60,8 @@ export declare function isCppInlineNamespaceScope(scopeId: ScopeId): boolean;
  * Returns the most specific (innermost) match — for `outer::foo()`
  * where `inline namespace v1` declares `foo`, returns `v1::foo`. When
  * multiple inline-namespace children declare the same name, ISO C++
- * leaves the call ambiguous; V1 returns the first match in source
- * order (stable across runs).
+ * leaves the call ambiguous; returns `'ambiguous'` so the caller
+ * suppresses edge emission rather than picking arbitrarily (#1564).
  */
-export declare function resolveCppQualifiedNamespaceMember(receiverName: string, memberName: string, parsedFiles: readonly ParsedFile[], _scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
+export declare function resolveCppQualifiedNamespaceMember(receiverName: string, memberName: string, parsedFiles: readonly ParsedFile[], _scopes: ScopeResolutionIndexes): SymbolDefinition | 'ambiguous' | undefined;
 export {};

package/dist/core/ingestion/languages/cpp/inline-namespaces.js

@@ -26,6 +26,7 @@
  * `std::vector` qualified calls resolve to the inline-namespace
  * declaration transparently.
  */
+import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
 const inlineNamespaceRangesByFile = new Map();
 const inlineNamespaceScopeIds = new Set();
 function rangeKey(r) {
@@ -80,10 +81,12 @@ export function isCppInlineNamespaceScope(scopeId) {
  * Returns the most specific (innermost) match — for `outer::foo()`
  * where `inline namespace v1` declares `foo`, returns `v1::foo`. When
  * multiple inline-namespace children declare the same name, ISO C++
- * leaves the call ambiguous; V1 returns the first match in source
- * order (stable across runs).
+ * leaves the call ambiguous; returns `'ambiguous'` so the caller
+ * suppresses edge emission rather than picking arbitrarily (#1564).
  */
 export function resolveCppQualifiedNamespaceMember(receiverName, memberName, parsedFiles, _scopes) {
+    const allHits = [];
+    const seenNodeId = new Set();
     for (const parsed of parsedFiles) {
         const scopesById = new Map();
         for (const sc of parsed.scopes)
@@ -97,27 +100,58 @@ export function resolveCppQualifiedNamespaceMember(receiverName, memberName, par
             const nsName = nsDef.qualifiedName?.split('.').pop() ?? nsDef.qualifiedName ?? '';
             if (nsName !== receiverName)
                 continue;
-            // Found a matching namespace scope in this file. Collect the
-            // member transitively through any inline-namespace children.
-            const hit = findMemberInNamespaceTransitive(scope, scopesById, memberName);
-            if (hit !== undefined)
-                return hit;
+            // Found a matching namespace scope in this file. Collect ALL
+            // members transitively through any inline-namespace children.
+            const hits = findMemberInNamespaceTransitive(scope, scopesById, memberName);
+            for (const hit of hits) {
+                if (seenNodeId.has(hit.nodeId))
+                    continue;
+                seenNodeId.add(hit.nodeId);
+                allHits.push(hit);
+            }
         }
     }
-    return undefined;
+    if (allHits.length === 0)
+        return undefined;
+    if (allHits.length === 1)
+        return allHits[0];
+    // Multi-candidate: the `resolveQualifiedReceiverMember` hook has no
+    // access to call-site arity or argument types, so
+    // `narrowOverloadCandidates` cannot actually narrow here — the call
+    // with `(allHits, undefined, undefined)` is effectively a pass-through.
+    // We retain it so that `isOverloadAmbiguousAfterNormalization` can
+    // still detect int/long-style normalization collisions on this path,
+    // but for any multi-hit case where candidates have genuinely distinct
+    // signatures (e.g. `foo(int)` vs `foo(double)` in different inline
+    // children), we conservatively suppress rather than pick arbitrarily.
+    // A future enhancement could thread call-site argument info through
+    // the `resolveQualifiedReceiverMember` contract to enable real
+    // narrowing here.
+    const narrowed = narrowOverloadCandidates(allHits, undefined, undefined);
+    if (narrowed.length === 1)
+        return narrowed[0];
+    if (narrowed.length === 0)
+        return undefined;
+    if (isOverloadAmbiguousAfterNormalization(narrowed, undefined))
+        return 'ambiguous';
+    // Multiple surviving candidates (distinct signatures) — conservative
+    // suppress because we lack call-site info to disambiguate.
+    return 'ambiguous';
 }
 /** Recursively search a namespace scope and any inline-namespace
- *  descendants for a callable def with the given simple name. Non-inline
+ *  descendants for callable defs with the given simple name. Non-inline
  *  nested namespaces are NOT traversed — they require explicit
- *  qualification (`outer::nested::foo`). */
+ *  qualification (`outer::nested::foo`). Returns ALL matches so the
+ *  caller can detect same-name ambiguity across inline children (#1564). */
 function findMemberInNamespaceTransitive(scope, scopesById, memberName) {
+    const results = [];
     // Check this scope's own ownedDefs first.
     for (const def of scope.ownedDefs) {
         if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
             continue;
         const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
         if (simple === memberName)
-            return def;
+            results.push(def);
     }
     // Descend into inline-namespace children.
     for (const childScope of scopesById.values()) {
@@ -127,11 +161,11 @@ function findMemberInNamespaceTransitive(scope, scopesById, memberName) {
             continue;
         if (!inlineNamespaceScopeIds.has(childScope.id))
             continue;
-        const hit = findMemberInNamespaceTransitive(childScope, scopesById, memberName);
-        if (hit !== undefined)
-            return hit;
+        const childHits = findMemberInNamespaceTransitive(childScope, scopesById, memberName);
+        for (const hit of childHits)
+            results.push(hit);
     }
-    return undefined;
+    return results;
 }
 function findNamespaceDefInScope(scope) {
     for (const def of scope.ownedDefs) {

package/dist/core/ingestion/languages/cpp/scope-resolver.js

@@ -205,7 +205,7 @@ export const cppScopeResolver = {
             if (imp.localName !== site.name)
                 continue;
             const member = resolveCppQualifiedNamespaceMember(imp.targetRaw, imp.importedName, parsedFiles, scopes);
-            if (member === undefined)
+            if (member === undefined || member === 'ambiguous')
                 continue;
             if (seenUsing.has(member.nodeId))
                 continue;

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -542,10 +542,11 @@ export interface ScopeResolver {
      *
      * Receiver-bound-calls invokes this hook AFTER Case 1 (namespace
      * imports) and AFTER Case 2 (class-name receiver) fail to resolve.
-     * Returns the target def, or `undefined` to fall through to the
-     * remaining cases.
+     * Returns the target def, `'ambiguous'` when multiple inline-namespace
+     * children declare the same name (suppresses edge emission), or
+     * `undefined` to fall through to the remaining cases.
      */
-    readonly resolveQualifiedReceiverMember?: (receiverName: string, memberName: string, callerScope: ScopeId, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => SymbolDefinition | undefined;
+    readonly resolveQualifiedReceiverMember?: (receiverName: string, memberName: string, callerScope: ScopeId, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => SymbolDefinition | 'ambiguous' | undefined;
     /**
      * Enable the receiver-bound Case 0.5 fallback for explicit `this`
      * receivers (`this->m()` / `this.m()`) that resolves against the

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

@@ -324,6 +324,12 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             // class with the same simple name.
             if (provider.resolveQualifiedReceiverMember !== undefined) {
                 const memberDef = provider.resolveQualifiedReceiverMember(receiverName, memberName, site.inScope, scopes, parsedFiles);
+                if (memberDef === 'ambiguous') {
+                    // Same-name ambiguity across inline-namespace children (#1564):
+                    // suppress edge emission, mark site handled.
+                    handledSites.add(siteKey);
+                    continue;
+                }
                 if (memberDef !== undefined) {
                     const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
                     if (ok)

package/dist/storage/parse-cache.d.ts

@@ -55,8 +55,14 @@ export declare const computeChunkHash: (entries: Array<{
  */
 export declare const loadParseCache: (storagePath: string) => Promise<ParseCache>;
 /**
- * Persist the cache to disk atomically (write-and-rename) so a crash
- * mid-write doesn't leave a corrupt file.
+ * Persist the cache to disk using a temp directory + rename.
+ *
+ * Writes shards under `${cacheDir}.tmp`, then removes the old `cacheDir` and
+ * renames the temp directory into place. There is a crash window after
+ * `rm(cacheDir)` and before `rename(tmpDir, cacheDir)` where no cache exists;
+ * that is acceptable — `loadParseCache` yields empty and the next run
+ * reparses. This is not a single atomic swap of the whole tree, but avoids
+ * leaving a half-written shard set visible to readers.
  */
 export declare const saveParseCache: (storagePath: string, cache: ParseCache) => Promise<void>;
 /**

package/dist/storage/parse-cache.js

@@ -69,7 +69,12 @@ const GITNEXUS_PKG_VERSION = (() => {
     return '0.0.0-unknown';
 })();
 export const PARSE_CACHE_VERSION = `${SCHEMA_BUMP}+${GITNEXUS_PKG_VERSION}`;
-const CACHE_FILENAME = 'parse-cache.json';
+const LEGACY_CACHE_FILENAME = 'parse-cache.json';
+const CACHE_DIRNAME = 'parse-cache';
+const CACHE_INDEX_FILENAME = 'index.json';
+/** Keys on disk always come from `computeChunkHash` — 64-char lowercase hex. */
+const CHUNK_CACHE_KEY_HEX_RE = /^[a-f0-9]{64}$/;
+const isValidChunkCacheKey = (chunkHash) => CHUNK_CACHE_KEY_HEX_RE.test(chunkHash);
 /** SHA-256 hex of a single string or buffer. */
 const sha256Hex = (input) => createHash('sha256')
     .update(typeof input === 'string' ? Buffer.from(input) : input)
@@ -116,12 +121,12 @@ const mapReviver = (_key, value) => {
     }
     return value;
 };
-/**
- * Load the parse cache. Returns an empty cache on any failure (missing
- * file, corrupt JSON, version mismatch). Never throws on a normal load.
- */
-export const loadParseCache = async (storagePath) => {
-    const cachePath = path.join(storagePath, CACHE_FILENAME);
+const getLegacyCachePath = (storagePath) => path.join(storagePath, LEGACY_CACHE_FILENAME);
+const getCacheDirPath = (storagePath) => path.join(storagePath, CACHE_DIRNAME);
+const getCacheIndexPath = (storagePath) => path.join(getCacheDirPath(storagePath), CACHE_INDEX_FILENAME);
+const getCacheChunkPath = (storagePath, chunkHash) => path.join(getCacheDirPath(storagePath), `${chunkHash}.json`);
+const loadLegacyParseCache = async (storagePath) => {
+    const cachePath = getLegacyCachePath(storagePath);
     try {
         const raw = await fs.readFile(cachePath, 'utf-8');
         const data = JSON.parse(raw, mapReviver);
@@ -143,22 +148,88 @@ export const loadParseCache = async (storagePath) => {
         return emptyCache();
     }
 };
+const loadShardedParseCache = async (storagePath) => {
+    const indexPath = getCacheIndexPath(storagePath);
+    try {
+        const raw = await fs.readFile(indexPath, 'utf-8');
+        const data = JSON.parse(raw);
+        if (typeof data !== 'object' ||
+            data === null ||
+            data.version !== PARSE_CACHE_VERSION ||
+            !Array.isArray(data.keys)) {
+            return emptyCache();
+        }
+        const entries = new Map();
+        for (const chunkHash of data.keys) {
+            if (typeof chunkHash !== 'string' || !isValidChunkCacheKey(chunkHash))
+                continue;
+            try {
+                const chunkRaw = await fs.readFile(getCacheChunkPath(storagePath, chunkHash), 'utf-8');
+                const chunkData = JSON.parse(chunkRaw, mapReviver);
+                if (Array.isArray(chunkData))
+                    entries.set(chunkHash, chunkData);
+            }
+            catch {
+                /* skip corrupt or missing shard */
+            }
+        }
+        return { version: PARSE_CACHE_VERSION, entries, usedKeys: new Set() };
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Load the parse cache. Returns an empty cache on any failure (missing
+ * file, corrupt JSON, version mismatch). Never throws on a normal load.
+ */
+export const loadParseCache = async (storagePath) => {
+    const sharded = await loadShardedParseCache(storagePath);
+    if (sharded)
+        return sharded;
+    return loadLegacyParseCache(storagePath);
+};
 /**
- * Persist the cache to disk atomically (write-and-rename) so a crash
- * mid-write doesn't leave a corrupt file.
+ * Persist the cache to disk using a temp directory + rename.
+ *
+ * Writes shards under `${cacheDir}.tmp`, then removes the old `cacheDir` and
+ * renames the temp directory into place. There is a crash window after
+ * `rm(cacheDir)` and before `rename(tmpDir, cacheDir)` where no cache exists;
+ * that is acceptable — `loadParseCache` yields empty and the next run
+ * reparses. This is not a single atomic swap of the whole tree, but avoids
+ * leaving a half-written shard set visible to readers.
  */
 export const saveParseCache = async (storagePath, cache) => {
     await fs.mkdir(storagePath, { recursive: true });
-    const cachePath = path.join(storagePath, CACHE_FILENAME);
-    const tmpPath = `${cachePath}.tmp`;
-    const out = {
+    const cacheDir = getCacheDirPath(storagePath);
+    const tmpDir = `${cacheDir}.tmp`;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+    await fs.mkdir(tmpDir, { recursive: true });
+    const keys = [];
+    for (const [chunkHash, chunkResults] of cache.entries) {
+        if (!isValidChunkCacheKey(chunkHash))
+            continue;
+        let payload;
+        try {
+            payload = JSON.stringify(chunkResults, mapReplacer);
+        }
+        catch {
+            // Extremely dense chunks could theoretically exceed string limits; skip
+            // rather than failing the entire save (orchestrator catches save errors).
+            continue;
+        }
+        keys.push(chunkHash);
+        const chunkPath = path.join(tmpDir, `${chunkHash}.json`);
+        await fs.writeFile(chunkPath, payload, 'utf-8');
+    }
+    const index = {
         version: cache.version,
-        entries: Object.fromEntries(cache.entries),
+        keys,
     };
-    // Compact JSON; this file can be tens of MB on a large repo and pretty-
-    // printing roughly doubles size for no value.
-    await fs.writeFile(tmpPath, JSON.stringify(out, mapReplacer), 'utf-8');
-    await fs.rename(tmpPath, cachePath);
+    await fs.writeFile(path.join(tmpDir, CACHE_INDEX_FILENAME), JSON.stringify(index), 'utf-8');
+    await fs.rm(cacheDir, { recursive: true, force: true });
+    await fs.rename(tmpDir, cacheDir);
+    await fs.rm(getLegacyCachePath(storagePath), { force: true });
 };
 /**
  * Drop entries whose hashes are not in `usedHashes`. Called at the end

package/package.json

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