gitnexus 1.6.5-rc.32 → 1.6.5-rc.33

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/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.33",
   "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",