gitnexus 1.6.5-rc.33 → 1.6.5-rc.34

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

@@ -68,15 +68,19 @@ export const cppScopeResolver = {
         // fallback and wildcard expansion can suppress them as unqualified
         // cross-file callables.
         populateCppNonGloballyVisible(parsed);
-        // Resolve recorded template-class → dependent-base simple names to
-        // class nodeIds for two-phase template lookup (U3 of plan
-        // 2026-05-13-001).
-        populateCppDependentBases(parsed);
         // Build the class-def → enclosing-namespace-qualified-name map used
         // by ADL (U2 of plan 2026-05-13-001) to identify each argument type's
         // associated namespace for Koenig lookup.
         populateCppAssociatedNamespaces(parsed);
     },
+    // Resolve recorded template-class → dependent-base simple names to
+    // class nodeIds for two-phase template lookup (U3 of plan
+    // 2026-05-13-001). Runs AFTER all files have had `populateOwners`
+    // applied so that cross-file base classes (e.g. Base in base.h,
+    // Derived in derived.h) are reachable in the workspace index.
+    populateWorkspaceOwners: (parsedFiles) => {
+        populateCppDependentBases(parsedFiles);
+    },
     // Simple `isSuperReceiver` returns false for C++. Real super
     // classification is caller-context-dependent and lives in
     // `isSuperReceiverInContext` below — without scope context the

package/dist/core/ingestion/languages/cpp/two-phase-lookup.d.ts

@@ -11,8 +11,20 @@
  * This module records — during `emitCppScopeCaptures` — which template
  * class declarations have which dependent base class names (per file).
  * `populateCppDependentBases` then resolves those names to class nodeIds
- * using the workspace registry, building the per-class set the
- * `isDependentBaseMember` predicate consumes.
+ * using a workspace-wide registry, building the per-class set the
+ * `isCppDependentBaseMember` predicate consumes.
+ *
+ * Cross-file resolution: `Base<T>` may be declared in a different header
+ * than `Derived<T>`. `populateCppDependentBases` therefore runs as a
+ * workspace-wide pass (`populateWorkspaceOwners` hook) after every file
+ * has had `populateOwners` applied, so all class defs are reachable.
+ *
+ * Namespace disambiguation: when multiple classes share a simple name
+ * (e.g., `Box` in two namespaces), the resolver prefers the candidate
+ * whose qualified-name prefix (namespace path) matches the deriving
+ * class's prefix. If no namespace match is found, a unique simple-name
+ * match is accepted; ambiguous matches (multiple candidates, no
+ * namespace winner) are skipped conservatively.
  *
  * NOTE: module-level state, single-process-single-repo use only.
  * `clearFileLocalNames()` clears this state alongside file-local linkage
@@ -33,15 +45,19 @@ export declare function markCppDependentBase(filePath: string, className: string
 /** Clear two-phase-lookup state. Called from `clearFileLocalNames`. */
 export declare function clearCppDependentBases(): void;
 /**
- * Resolve recorded dependent-base simple names to class nodeIds using
- * the parsed file's localDefs. Run as part of `populateOwners` so the
- * resolved set is available before any resolution pass consults it.
+ * Resolve recorded dependent-base simple names to class nodeIds using a
+ * workspace-wide index. Run as `populateWorkspaceOwners` after every
+ * file has had `populateOwners` applied, so class defs from ALL files
+ * are reachable.
  *
- * Matches by simple name within the same file (the template class and
- * its base are typically declared in the same TU; cross-file template
- * bases are an edge case deferred to V2).
+ * Disambiguation strategy (multiple classes sharing a simple name):
+ *  1. Prefer the candidate whose qualified-name namespace prefix matches
+ *     the deriving class's namespace prefix (same-namespace bias).
+ *  2. Fall back to accepting a unique simple-name match.
+ *  3. Skip when multiple candidates exist and no namespace match is
+ *     found (conservative: avoids false associations).
  */
-export declare function populateCppDependentBases(parsed: ParsedFile): void;
+export declare function populateCppDependentBases(parsedFiles: readonly ParsedFile[]): void;
 /**
  * Two-phase lookup predicate: is the candidate def a member of a
  * dependent base of the caller's enclosing template class?

package/dist/core/ingestion/languages/cpp/two-phase-lookup.js

@@ -11,8 +11,20 @@
  * This module records — during `emitCppScopeCaptures` — which template
  * class declarations have which dependent base class names (per file).
  * `populateCppDependentBases` then resolves those names to class nodeIds
- * using the workspace registry, building the per-class set the
- * `isDependentBaseMember` predicate consumes.
+ * using a workspace-wide registry, building the per-class set the
+ * `isCppDependentBaseMember` predicate consumes.
+ *
+ * Cross-file resolution: `Base<T>` may be declared in a different header
+ * than `Derived<T>`. `populateCppDependentBases` therefore runs as a
+ * workspace-wide pass (`populateWorkspaceOwners` hook) after every file
+ * has had `populateOwners` applied, so all class defs are reachable.
+ *
+ * Namespace disambiguation: when multiple classes share a simple name
+ * (e.g., `Box` in two namespaces), the resolver prefers the candidate
+ * whose qualified-name prefix (namespace path) matches the deriving
+ * class's prefix. If no namespace match is found, a unique simple-name
+ * match is accepted; ambiguous matches (multiple candidates, no
+ * namespace winner) are skipped conservatively.
  *
  * NOTE: module-level state, single-process-single-repo use only.
  * `clearFileLocalNames()` clears this state alongside file-local linkage
@@ -61,40 +73,97 @@ export function clearCppDependentBases() {
     dependentBaseNodeIds.clear();
 }
 /**
- * Resolve recorded dependent-base simple names to class nodeIds using
- * the parsed file's localDefs. Run as part of `populateOwners` so the
- * resolved set is available before any resolution pass consults it.
+ * Resolve recorded dependent-base simple names to class nodeIds using a
+ * workspace-wide index. Run as `populateWorkspaceOwners` after every
+ * file has had `populateOwners` applied, so class defs from ALL files
+ * are reachable.
  *
- * Matches by simple name within the same file (the template class and
- * its base are typically declared in the same TU; cross-file template
- * bases are an edge case deferred to V2).
+ * Disambiguation strategy (multiple classes sharing a simple name):
+ *  1. Prefer the candidate whose qualified-name namespace prefix matches
+ *     the deriving class's namespace prefix (same-namespace bias).
+ *  2. Fall back to accepting a unique simple-name match.
+ *  3. Skip when multiple candidates exist and no namespace match is
+ *     found (conservative: avoids false associations).
  */
-export function populateCppDependentBases(parsed) {
-    const perFile = dependentBasesByFile.get(parsed.filePath);
-    if (perFile === undefined)
+export function populateCppDependentBases(parsedFiles) {
+    if (dependentBasesByFile.size === 0)
         return;
-    // Build simple-name → nodeId index for this file's class-like defs.
-    const classByName = new Map();
-    for (const def of parsed.localDefs) {
-        if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
-            continue;
-        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
-        if (simple !== '')
-            classByName.set(simple, def.nodeId);
+    // Build workspace-wide index: simpleName → {nodeId, nsPrefix}[]
+    // nsPrefix is the dot-joined namespace path (qualifiedName without the
+    // last segment). Classes at global scope have nsPrefix = ''.
+    const classesBySimpleName = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+                continue;
+            const qn = def.qualifiedName ?? '';
+            const lastDot = qn.lastIndexOf('.');
+            const simple = lastDot >= 0 ? qn.slice(lastDot + 1) : qn;
+            if (simple === '')
+                continue;
+            const nsPrefix = lastDot >= 0 ? qn.slice(0, lastDot) : '';
+            let entries = classesBySimpleName.get(simple);
+            if (entries === undefined) {
+                entries = [];
+                classesBySimpleName.set(simple, entries);
+            }
+            entries.push({ nodeId: def.nodeId, nsPrefix });
+        }
     }
-    for (const [className, baseNames] of perFile) {
-        const classNodeId = classByName.get(className);
-        if (classNodeId === undefined)
+    // Build a filePath → ParsedFile lookup for fast per-file access.
+    const parsedByFile = new Map();
+    for (const parsed of parsedFiles)
+        parsedByFile.set(parsed.filePath, parsed);
+    for (const [filePath, perFile] of dependentBasesByFile) {
+        const parsed = parsedByFile.get(filePath);
+        if (parsed === undefined)
             continue;
-        let bases = dependentBaseNodeIds.get(classNodeId);
-        if (bases === undefined) {
-            bases = new Set();
-            dependentBaseNodeIds.set(classNodeId, bases);
+        // Build a simple-name → {nodeId, nsPrefix} map for THIS file's
+        // class-like defs so we can identify each template class precisely
+        // (avoids cross-file name collisions for the deriving class itself).
+        const localClassByName = new Map();
+        for (const def of parsed.localDefs) {
+            if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+                continue;
+            const qn = def.qualifiedName ?? '';
+            const lastDot = qn.lastIndexOf('.');
+            const simple = lastDot >= 0 ? qn.slice(lastDot + 1) : qn;
+            if (simple === '')
+                continue;
+            const nsPrefix = lastDot >= 0 ? qn.slice(0, lastDot) : '';
+            localClassByName.set(simple, { nodeId: def.nodeId, nsPrefix });
         }
-        for (const baseName of baseNames) {
-            const baseNodeId = classByName.get(baseName);
-            if (baseNodeId !== undefined)
-                bases.add(baseNodeId);
+        for (const [className, baseNames] of perFile) {
+            const classEntry = localClassByName.get(className);
+            if (classEntry === undefined)
+                continue;
+            let bases = dependentBaseNodeIds.get(classEntry.nodeId);
+            if (bases === undefined) {
+                bases = new Set();
+                dependentBaseNodeIds.set(classEntry.nodeId, bases);
+            }
+            for (const baseName of baseNames) {
+                const candidates = classesBySimpleName.get(baseName);
+                if (candidates === undefined || candidates.length === 0)
+                    continue;
+                if (candidates.length === 1) {
+                    // Unique simple-name match — accept regardless of namespace.
+                    bases.add(candidates[0].nodeId);
+                    continue;
+                }
+                // Multiple classes share the same simple name — prefer the one
+                // whose namespace matches the deriving class's namespace.
+                // V1: exact dot-prefix match only. Cross-namespace inheritance
+                // (e.g., `ns::outer::Derived` extending bare `Inner` defined in
+                // `ns::outer::inner`) and inline-namespace cases are deferred to
+                // V2; the conservative skip-on-ambiguity below avoids false
+                // associations in those edge cases.
+                const nsMatch = candidates.find((c) => c.nsPrefix === classEntry.nsPrefix);
+                if (nsMatch !== undefined) {
+                    bases.add(nsMatch.nodeId);
+                }
+                // else: ambiguous (multiple candidates, no namespace match) → skip.
+            }
         }
     }
 }

package/package.json

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