gitnexus 1.6.5-rc.32 → 1.6.5-rc.34

package/dist/core/ingestion/languages/cpp/captures.js

@@ -237,6 +237,12 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
         }
         out.push(grouped);
     }
+    // ── Emit inheritance references for scope-resolution MRO / EXTENDS ──
+    // Walk every class/struct base list and synthesize `@reference.inherits`
+    // captures consumed by the registry-primary graph bridge. The lookup name
+    // is normalized to the bare class name so `Base<T>` / `outer::v1::Base<T>`
+    // resolve through V1's simple-name `findClassBindingInScope('Base')`.
+    emitCppInheritanceCaptures(tree.rootNode, out);
     // ── Detect dependent-base relationships for two-phase template lookup ──
     // Walk the tree once, finding every `template_declaration` whose
     // child is a class/struct definition with a `base_class_clause` whose
@@ -248,6 +254,41 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     detectCppDependentBases(tree.rootNode, filePath);
     return out;
 }
+/**
+ * Walk every C++ class/struct base clause and emit `@reference.inherits`
+ * captures for each base so scope resolution can resolve them into EXTENDS
+ * edges. Lookup names are normalized to bare class names (`Base<T>` → `Base`,
+ * `outer::v1::Base<T>` → `Base`) to match the V1 simple-name
+ * `findClassBindingInScope` contract. This intentionally preserves the
+ * existing scope-chain tradeoff: qualified namespace context is discarded
+ * here instead of introducing a C++-only name-resolution lane in shared
+ * ingestion infrastructure.
+ */
+function emitCppInheritanceCaptures(root, out) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'class_specifier' || node.type === 'struct_specifier') {
+            const baseClause = findChildOfType(node, ['base_class_clause']);
+            if (baseClause !== null) {
+                for (const base of iterBaseClasses(baseClause)) {
+                    const baseName = extractBaseLookupName(base);
+                    if (baseName.length === 0)
+                        continue;
+                    out.push({
+                        '@reference.inherits': nodeToCapture('@reference.inherits', base),
+                        '@reference.name': syntheticCapture('@reference.name', base, baseName),
+                    });
+                }
+            }
+        }
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+}
 /**
  * Walk the AST finding every template_declaration containing a class or
  * struct definition with a dependent base. Records (className, baseName)
@@ -277,7 +318,7 @@ function detectCppDependentBases(root, filePath) {
                     if (baseClause !== null) {
                         for (const base of iterBaseClasses(baseClause)) {
                             if (isBaseDependent(base, params)) {
-                                const baseName = extractBaseSimpleName(base);
+                                const baseName = extractBaseLookupName(base);
                                 if (baseName !== '') {
                                     markCppDependentBase(filePath, className, baseName);
                                 }
@@ -393,23 +434,40 @@ function isBaseDependent(baseNode, templateParams) {
     }
     return false;
 }
-/** Extract the simple name of a base class node. */
-function extractBaseSimpleName(baseNode) {
-    if (baseNode.type === 'type_identifier')
+/**
+ * Recursively extract the bare lookup name of a base class node.
+ * Examples: `Base` → `Base`, `Base<T>` → `Base`,
+ * `outer::v1::Base<T>` → `Base`. Namespace qualifiers are intentionally
+ * dropped to align with V1 scope-chain lookup everywhere else in the
+ * registry-primary pipeline.
+ */
+function extractBaseLookupName(baseNode) {
+    if (baseNode.type === 'type_identifier' || baseNode.type === 'identifier')
         return baseNode.text;
     if (baseNode.type === 'template_type') {
         const nameNode = baseNode.childForFieldName('name');
         if (nameNode !== null)
-            return nameNode.text;
-        // Fallback: first type_identifier descendant.
-        const id = findFirstDescendantOfType(baseNode, 'type_identifier');
+            return extractBaseLookupName(nameNode);
+        const id = findFirstDescendantOfType(baseNode, 'type_identifier') ??
+            findFirstDescendantOfType(baseNode, 'identifier');
         if (id !== null)
             return id.text;
     }
     if (baseNode.type === 'qualified_identifier') {
         const nameNode = baseNode.childForFieldName('name');
-        if (nameNode !== null)
-            return nameNode.text;
+        if (nameNode !== null) {
+            const nested = extractBaseLookupName(nameNode);
+            if (nested.length > 0)
+                return nested;
+        }
+        for (let i = baseNode.childCount - 1; i >= 0; i--) {
+            const child = baseNode.child(i);
+            if (child === null)
+                continue;
+            const nested = extractBaseLookupName(child);
+            if (nested.length > 0)
+                return nested;
+        }
     }
     return '';
 }

package/dist/core/ingestion/languages/cpp/query.js

@@ -416,6 +416,25 @@ const CPP_SCOPE_QUERY = `
     scope: (_) @reference.receiver
     name: (identifier) @reference.name)) @reference.call.qualified
 
+;; Nested qualified receiver: outer::v1::Base<T>::f()
+;; tree-sitter-cpp nests this as qualified_identifier(name:
+;; qualified_identifier(scope: qualified_identifier(...), name: identifier)).
+;; Capturing the innermost receiver still gives isSuperReceiverInContext
+;; enough text to strip qualifiers/template args down to Base.
+(call_expression
+  function: (qualified_identifier
+    name: (qualified_identifier
+      scope: (_) @reference.receiver
+      name: (identifier) @reference.name))) @reference.call.qualified
+
+;; Double-nested qualified receiver: outer::v1::Base<T>::f()
+(call_expression
+  function: (qualified_identifier
+    name: (qualified_identifier
+      name: (qualified_identifier
+        scope: (_) @reference.receiver
+        name: (identifier) @reference.name)))) @reference.call.qualified
+
 ;; ─── References — member calls (obj.method() / ptr->method()) ───────
 (call_expression
   function: (field_expression

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/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -87,6 +87,9 @@
  *     attempting emission (even on dedup-collapse), because the
  *     per-(caller, target) collapse semantics require multiple call
  *     sites in the same caller body not produce multiple edges.
+ *     `preEmitInheritanceEdges` also pre-marks every `inherits` site so
+ *     the generic bridge cannot remap class heritage into method-owned
+ *     EXTENDS edges via `resolveCallerGraphId`.
  *
  *   - **I3 — `propagateImportedReturnTypes` mutation timing + ordering.**
  *     The pass mutates `Scope.typeBindings` (a plain `new Map(...)` from

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.js

@@ -87,6 +87,9 @@
  *     attempting emission (even on dedup-collapse), because the
  *     per-(caller, target) collapse semantics require multiple call
  *     sites in the same caller body not produce multiple edges.
+ *     `preEmitInheritanceEdges` also pre-marks every `inherits` site so
+ *     the generic bridge cannot remap class heritage into method-owned
+ *     EXTENDS edges via `resolveCallerGraphId`.
  *
  *   - **I3 — `propagateImportedReturnTypes` mutation timing + ordering.**
  *     The pass mutates `Scope.typeBindings` (a plain `new Map(...)` from

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

@@ -28,14 +28,68 @@ import { extractParsedFile } from '../../scope-extractor-bridge.js';
 import { finalizeScopeModel } from '../../finalize-orchestrator.js';
 import { resolveReferenceSites } from '../../resolve-references.js';
 import { buildGraphNodeLookup } from '../graph-bridge/node-lookup.js';
+import { resolveDefGraphId } from '../graph-bridge/ids.js';
 import { buildPopulatedMethodDispatch } from '../graph-bridge/method-dispatch.js';
+import { tryEmitEdge } from '../graph-bridge/edges.js';
 import { propagateImportedReturnTypes } from '../passes/imported-return-types.js';
 import { emitReceiverBoundCalls } from '../passes/receiver-bound-calls.js';
 import { emitFreeCallFallback } from '../passes/free-call-fallback.js';
 import { emitReferencesViaLookup } from '../graph-bridge/references-to-edges.js';
 import { emitImportEdges } from '../graph-bridge/imports-to-edges.js';
+import { findClassBindingInScope, findEnclosingClassDef } from '../scope/walkers.js';
 import { buildWorkspaceResolutionIndex } from '../workspace-index.js';
 import { logger } from '../../../logger.js';
+/**
+ * Resolve inheritance reference sites early and pre-emit their EXTENDS edges
+ * before MRO construction. This lets template-base captures contribute to the
+ * graph in time for `buildMro`, while `handledSites` prevents the generic
+ * reference-edge bridge from re-emitting the same sites later.
+ *
+ * @returns Site keys to seed the downstream handled-site skip set.
+ */
+function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
+    const handledSites = new Set();
+    const seen = new Set();
+    const existing = new Set();
+    for (const rel of graph.iterRelationshipsByType('EXTENDS')) {
+        existing.add(`${rel.sourceId}->${rel.targetId}`);
+    }
+    for (const site of scopes.referenceSites) {
+        if (site.kind !== 'inherits')
+            continue;
+        const scope = scopes.scopeTree.getScope(site.inScope);
+        const siteKey = scope?.filePath !== undefined
+            ? `${scope.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`
+            : undefined;
+        if (siteKey !== undefined) {
+            // Intentionally suppress every `inherits` site from the generic
+            // reference bridge, even when this pre-pass can't emit an EXTENDS
+            // edge. The shared bridge resolves the source via
+            // `resolveCallerGraphId`, which can degrade class-heritage sites into
+            // method-owned EXTENDS edges once methods exist on the class. This
+            // pre-pass is the authoritative inheritance emitter, so broad
+            // suppression keeps `buildMro` and the final graph class-owned.
+            handledSites.add(siteKey);
+        }
+        const targetDef = findClassBindingInScope(site.inScope, site.name, scopes);
+        if (targetDef === undefined)
+            continue;
+        const callerClass = findEnclosingClassDef(site.inScope, scopes);
+        if (callerClass === undefined)
+            continue;
+        const callerGraphId = resolveDefGraphId(callerClass.filePath, callerClass, nodeLookup);
+        const targetGraphId = resolveDefGraphId(targetDef.filePath, targetDef, nodeLookup);
+        if (callerGraphId === undefined || targetGraphId === undefined)
+            continue;
+        const edgeKey = `${callerGraphId}->${targetGraphId}`;
+        if (existing.has(edgeKey))
+            continue;
+        if (tryEmitEdge(graph, scopes, nodeLookup, site, targetDef, 'scope-resolution: inherits', seen, 0.85)) {
+            existing.add(edgeKey);
+        }
+    }
+    return handledSites;
+}
 export function runScopeResolution(input, provider) {
     const { graph, files } = input;
     const onWarn = input.onWarn ?? (() => { });
@@ -108,8 +162,6 @@ export function runScopeResolution(input, provider) {
     // ── Phase 2: finalize → ScopeResolutionIndexes ─────────────────────────
     const allFilePaths = new Set(parsedFiles.map((f) => f.filePath));
     const nodeLookup = buildGraphNodeLookup(graph);
-    const mroByClassDefId = provider.buildMro(graph, parsedFiles, nodeLookup);
-    const extendsOnlyMroByClassDefId = provider.buildExtendsOnlyMro?.(graph, parsedFiles, nodeLookup);
     const resolutionConfig = input.resolutionConfig;
     const finalized = finalizeScopeModel(parsedFiles, {
         hooks: {
@@ -118,6 +170,9 @@ export function runScopeResolution(input, provider) {
             mergeBindings: (existing, incoming, scopeId) => provider.mergeBindings(existing, incoming, scopeId),
         },
     });
+    const preEmittedInheritanceSites = preEmitInheritanceEdges(graph, finalized, nodeLookup);
+    const mroByClassDefId = provider.buildMro(graph, parsedFiles, nodeLookup);
+    const extendsOnlyMroByClassDefId = provider.buildExtendsOnlyMro?.(graph, parsedFiles, nodeLookup);
     // Replace the empty MethodDispatchIndex that finalizeScopeModel
     // builds by design with the populated one derived from the
     // language's MRO. Spread produces a fresh `ScopeResolutionIndexes`
@@ -184,7 +239,7 @@ export function runScopeResolution(input, provider) {
     });
     const tResolve = PROF ? process.hrtime.bigint() : 0n;
     // ── Phase 4: emit graph edges (LOAD-BEARING ORDER — see I1) ────────────
-    const handledSites = new Set();
+    const handledSites = new Set(preEmittedInheritanceSites);
     const receiverExtras = emitReceiverBoundCalls(graph, indexes, parsedFiles, nodeLookup, handledSites, provider, workspaceIndex, readonlyModel);
     const unresolvedReceiverExtras = provider.emitUnresolvedReceiverEdges !== undefined
         ? provider.emitUnresolvedReceiverEdges(graph, indexes, parsedFiles, nodeLookup, handledSites, readonlyModel)

package/package.json

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