gitnexus 1.6.6-rc.134 → 1.6.6-rc.135

package/dist/core/ingestion/class-extractors/generic.js

@@ -124,6 +124,13 @@ export function createClassExtractor(config) {
         extractQualifiedName(node, simpleName) {
             return extract(node, { name: simpleName })?.qualifiedName ?? null;
         },
+        // #1991: qualify a non-typeDeclaration scope node (e.g. a Ruby `module` → Trait)
+        // by the same ancestor-scope walk the node-id path uses, so two same-tail nested
+        // mixin modules stay distinct. extract()/extractQualifiedName cannot be reused —
+        // they bail on non-typeDeclarations (a module is not in typeDeclarationNodes).
+        qualifyScopeName(node, simpleName) {
+            return buildQualifiedName(node, simpleName);
+        },
         shouldSkipClassCapture(context) {
             return config.shouldSkipClassCapture?.(context) ?? false;
         },

package/dist/core/ingestion/class-types.d.ts

@@ -34,6 +34,14 @@ export interface ClassExtractor {
         type?: NodeLabel | null;
     }): ExtractedClassSymbol | null;
     extractQualifiedName(node: SyntaxNode, simpleName: string): string | null;
+    /**
+     * #1991: qualify a scope-defining node that maps to a class-like registry label
+     * (e.g. a Ruby `module` → Trait) but is NOT a typeDeclaration, so it cannot go
+     * through extract()/extractQualifiedName (which bail on non-typeDeclarations).
+     * Walks the same ancestor scopes as the node-id path. Optional — only providers
+     * that materialize such nodes implement it.
+     */
+    qualifyScopeName?(node: SyntaxNode, simpleName: string): string;
     shouldSkipClassCapture?(context: ClassCaptureContext & {
         nodeLabel: ClassLikeNodeLabel;
     }): boolean;

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

@@ -7,16 +7,33 @@ import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
 import { generateId } from '../../../../lib/utils.js';
 const HERITAGE_PREFIX = '__heritage__:';
 const PROPERTY_PREFIX = '__property__:';
+/**
+ * #1991: resolve a BARE mixin reference (`include Loggable`) to a nested module by
+ * the INCLUDING class's lexical scope — Ruby looks up a constant in the innermost
+ * enclosing scope first. For owner `App.S`, try `App.Loggable`, then walk outward.
+ * Returns undefined if no enclosing-scope-qualified module exists.
+ */
+function qualifyMixinByOwnerScope(mixinName, ownerName, graphIdByName) {
+    let prefix = ownerName;
+    let dot = prefix.lastIndexOf('.');
+    while (dot !== -1) {
+        prefix = prefix.slice(0, dot);
+        const g = graphIdByName.get(`${prefix}.${mixinName}`);
+        if (g !== undefined)
+            return g;
+        dot = prefix.lastIndexOf('.');
+    }
+    return undefined;
+}
 function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
     const graphIdByName = new Map();
-    // Secondary tail -> graphId map (first-wins). The `__heritage__` marker carries
-    // the mixin TARGET as the bare written name (`arg.text`, e.g. `Loggable`), not
-    // its full qualifiedName, so a nested mixin module included by its short name
-    // (`include Loggable` where it is `App::Loggable`) misses the full-qn map and
-    // its IMPLEMENTS edge is silently dropped (#1982 follow-up). The tail fallback
-    // recovers it. OWNER (`className`) lookups stay full-qn only, preserving
-    // same-tail owner disambiguation; only the under-qualified mixin reference
-    // falls back, and a genuine same-tail mixin tie there resolves first-wins.
+    // Secondary tail -> graphId map. The `__heritage__` marker carries the mixin
+    // TARGET as the bare written name (`arg.text`, e.g. `Loggable`), not its full
+    // qualifiedName, so a nested mixin module included by its short name misses the
+    // full-qn map. We first resolve it lexically by the including class's enclosing
+    // scope (`qualifyMixinByOwnerScope`); this tail map is the last resort. A genuine
+    // same-tail collision is mapped to `null` so we REFUSE to guess (#1991) rather
+    // than the old first-wins, which cross-wired App::Loggable / Web::Loggable.
     const graphIdByTail = new Map();
     for (const parsed of parsedFiles) {
         for (const def of parsed.localDefs) {
@@ -34,8 +51,13 @@ function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
                     graphIdByName.set(fullName, graphId);
                     const dot = fullName.lastIndexOf('.');
                     const tail = dot === -1 ? fullName : fullName.slice(dot + 1);
-                    if (tail.length > 0 && !graphIdByTail.has(tail))
-                        graphIdByTail.set(tail, graphId);
+                    if (tail.length > 0) {
+                        const existingTail = graphIdByTail.get(tail);
+                        if (existingTail === undefined)
+                            graphIdByTail.set(tail, graphId);
+                        else if (existingTail !== null && existingTail !== graphId)
+                            graphIdByTail.set(tail, null); // same-tail collision — refuse to guess
+                    }
                 }
             }
         }
@@ -56,9 +78,14 @@ function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
                 continue;
             const [kind, mixinName, className] = parts;
             const classGraphId = graphIdByName.get(className);
-            // Owner stays full-qn; the mixin target may be written by short name and
-            // miss the full-qn map, so fall back to the simple-tail map (#1982).
-            const mixinGraphId = graphIdByName.get(mixinName) ?? graphIdByTail.get(mixinName);
+            // Owner stays full-qn. The mixin target may be written by short name and miss
+            // the full-qn map; resolve it lexically by the including class's enclosing
+            // scope (`App::S` + `Loggable` -> `App::Loggable`), then fall back to the tail
+            // map ONLY when unambiguous — never first-wins on a collision (#1982/#1991).
+            const mixinGraphId = graphIdByName.get(mixinName) ??
+                qualifyMixinByOwnerScope(mixinName, className, graphIdByName) ??
+                graphIdByTail.get(mixinName) ??
+                undefined;
             if (classGraphId === undefined || mixinGraphId === undefined)
                 continue;
             const edgeKey = `${classGraphId}->${mixinGraphId}:${kind}`;

package/dist/core/ingestion/parsing-processor.js

@@ -7,7 +7,7 @@ import { extractVueScript, isVueSetupTopLevel } from './vue-sfc-extractor.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
 import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
-import { buildConcreteTypedefDefinitionRanges, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, isSuppressedConcreteTypedefDuplicate, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
+import { buildConcreteTypedefDefinitionRanges, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, isSuppressedConcreteTypedefDuplicate, isQualifiableScopeLabel, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
 import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, parameterShapeIdTag, } from './utils/method-props.js';
@@ -450,7 +450,14 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
             // the qualified class node id computed below. Gated on the flag, so the
             // owner walk and its cache entry are byte-identical when the flag is off.
             const getQualifiedOwnerName = provider.classExtractor?.qualifiedNodeId === true
-                ? (node, simpleName) => provider.classExtractor.extractQualifiedName(node, simpleName)
+                ? (node, simpleName) => 
+                // #1991: a Ruby `module` owner is not a typeDeclaration, so
+                // extractQualifiedName returns null; fall back to the scope walk so a
+                // method inside a nested module owns through the SAME qualified Trait
+                // id its node uses (App.Loggable), not a dangling bare id.
+                provider.classExtractor.extractQualifiedName(node, simpleName) ??
+                    provider.classExtractor.qualifyScopeName?.(node, simpleName) ??
+                    null
                 : undefined;
             const enclosingClassInfo = needsOwner
                 ? cachedFindEnclosingClassInfo(nameNode || definitionNodeForRange, file.path, provider.resolveEnclosingOwner, getQualifiedOwnerName)
@@ -468,7 +475,16 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
             const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
                 (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
                     ? (provider.classExtractor.extractQualifiedName(classNodeForSymbol, nodeName) ?? nodeName)
-                    : undefined);
+                    : // #1991: a Ruby `module` maps to Trait (class-like registry) but is not a
+                        // typeDeclaration, so extractQualifiedName bails. Qualify it via the scope
+                        // walk so two same-tail nested mixin modules get distinct ids. Gated on
+                        // qualifiedNodeId, so languages without the flag are unaffected.
+                        isQualifiableScopeLabel(nodeLabel) &&
+                            provider.classExtractor?.qualifiedNodeId === true &&
+                            classNodeForSymbol
+                            ? (provider.classExtractor.qualifyScopeName?.(classNodeForSymbol, nodeName) ??
+                                undefined)
+                            : undefined);
             // Qualify method/property IDs with enclosing class name to avoid collisions
             // e.g. "Method:animal.dart:Animal.speak" vs "Method:animal.dart:Dog.speak".
             // Class-like nodes use their own fully-qualified path as the id key when the
@@ -487,13 +503,16 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 : undefined;
             const qualifiedName = rustImplQualifiedName !== undefined
                 ? rustImplQualifiedName
-                : isClassLikeLabel &&
-                    provider.classExtractor?.qualifiedNodeId === true &&
-                    qualifiedTypeName !== undefined
-                    ? qualifiedTypeName
-                    : enclosingClassInfo
-                        ? `${enclosingClassInfo.className}.${nodeName}`
-                        : nodeName;
+                : // #1991: include Trait so a Ruby mixin module's qualified scope id keys
+                    // the node, mirroring the class-like path (qualifiedTypeName is computed
+                    // for Trait above).
+                    (isClassLikeLabel || isQualifiableScopeLabel(nodeLabel)) &&
+                        provider.classExtractor?.qualifiedNodeId === true &&
+                        qualifiedTypeName !== undefined
+                        ? qualifiedTypeName
+                        : enclosingClassInfo
+                            ? `${enclosingClassInfo.className}.${nodeName}`
+                            : nodeName;
             // Extract method metadata for Function/Method/Constructor nodes BEFORE generating
             // the node ID — parameterCount is needed to disambiguate overloaded methods.
             // Use the per-language MethodExtractor for method metadata (isAbstract, isStatic,

package/dist/core/ingestion/utils/ast-helpers.d.ts

@@ -17,6 +17,17 @@ export type SyntaxNode = Parser.SyntaxNode;
  * parse-worker mirrors this so the owner edge and node id agree byte-for-byte.
  */
 export declare const qualifyRustImplTargetByModScope: (implNode: SyntaxNode, rawTargetText: string) => string;
+/**
+ * #1991: scope-label predicate that single-sources the `nodeLabel === 'Trait'`
+ * checks in parsing-processor.ts / parse-worker.ts. A Ruby `module` maps to the
+ * `Trait` registry label but is NOT a typeDeclaration, so `extractQualifiedName`
+ * bails on it; these node labels are instead qualified via the scope walk
+ * (`qualifyScopeName`) so same-tail nested modules get distinct ids. Keeping the
+ * literal in one place stops the four hand-maintained copies (two each in the
+ * sequential and worker definition paths) from drifting apart. Pure predicate —
+ * value-identical to the inlined `nodeLabel === 'Trait'`.
+ */
+export declare const isQualifiableScopeLabel: (nodeLabel: string) => boolean;
 /**
  * Ordered list of definition capture keys for tree-sitter query matches.
  * Used to extract the definition node from a capture map.

package/dist/core/ingestion/utils/ast-helpers.js

@@ -28,6 +28,17 @@ export const qualifyRustImplTargetByModScope = (implNode, rawTargetText) => {
     }
     return [...modSegments, ...splitQualifiedName(rawTargetText)].filter(Boolean).join('.');
 };
+/**
+ * #1991: scope-label predicate that single-sources the `nodeLabel === 'Trait'`
+ * checks in parsing-processor.ts / parse-worker.ts. A Ruby `module` maps to the
+ * `Trait` registry label but is NOT a typeDeclaration, so `extractQualifiedName`
+ * bails on it; these node labels are instead qualified via the scope walk
+ * (`qualifyScopeName`) so same-tail nested modules get distinct ids. Keeping the
+ * literal in one place stops the four hand-maintained copies (two each in the
+ * sequential and worker definition paths) from drifting apart. Pure predicate —
+ * value-identical to the inlined `nodeLabel === 'Trait'`.
+ */
+export const isQualifiableScopeLabel = (nodeLabel) => nodeLabel === 'Trait';
 /**
  * Ordered list of definition capture keys for tree-sitter query matches.
  * Used to extract the definition node from a capture map.

package/dist/core/ingestion/workers/parse-worker.js

@@ -38,7 +38,7 @@ try {
 }
 catch { }
 import { getLanguageFromFilename } from '../../../_shared/index.js';
-import { buildConcreteTypedefDefinitionRanges, FUNCTION_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, genericFuncName, inferFunctionLabel, isSuppressedConcreteTypedefDuplicate, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, } from '../utils/ast-helpers.js';
+import { buildConcreteTypedefDefinitionRanges, FUNCTION_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, genericFuncName, inferFunctionLabel, isSuppressedConcreteTypedefDuplicate, isQualifiableScopeLabel, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, } from '../utils/ast-helpers.js';
 import { extractCallArgTypes } from '../utils/call-analysis.js';
 import { buildTypeEnv } from '../type-env.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
@@ -1290,7 +1290,14 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             // to the *qualified* class id (Outer.Inner). Gated on the flag → byte-identical
             // when off. Mirrors parsing-processor.ts.
             const getQualifiedOwnerName = provider.classExtractor?.qualifiedNodeId === true
-                ? (node, simpleName) => provider.classExtractor.extractQualifiedName(node, simpleName)
+                ? (node, simpleName) => 
+                // #1991: LOCKSTEP — a Ruby `module` owner is not a typeDeclaration, so
+                // extractQualifiedName returns null; fall back to the scope walk so a
+                // method inside a nested module owns through the SAME qualified Trait
+                // id its node uses on the worker path too.
+                provider.classExtractor.extractQualifiedName(node, simpleName) ??
+                    provider.classExtractor.qualifyScopeName?.(node, simpleName) ??
+                    null
                 : undefined;
             const enclosingClassInfo = needsOwner
                 ? cachedFindEnclosingClassInfo(nameNode || definitionNode, file.path, provider.resolveEnclosingOwner, getQualifiedOwnerName)
@@ -1306,7 +1313,15 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
                 (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
                     ? (provider.classExtractor.extractQualifiedName(classNodeForSymbol, nodeName) ?? nodeName)
-                    : undefined);
+                    : // #1991: LOCKSTEP with parsing-processor.ts — qualify a Ruby `module`
+                        // (Trait) via the scope walk so same-tail nested mixin modules get
+                        // distinct ids on the worker path too. Gated on qualifiedNodeId.
+                        isQualifiableScopeLabel(nodeLabel) &&
+                            provider.classExtractor?.qualifiedNodeId === true &&
+                            classNodeForSymbol
+                            ? (provider.classExtractor.qualifyScopeName?.(classNodeForSymbol, nodeName) ??
+                                undefined)
+                            : undefined);
             // Qualify method/property IDs with enclosing class name to avoid collisions.
             // Class-like nodes use their own fully-qualified path as the id key when the
             // language enables qualifiedNodeId (#1978); everything else is unchanged.
@@ -1320,13 +1335,15 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 : undefined;
             const qualifiedName = rustImplQualifiedName !== undefined
                 ? rustImplQualifiedName
-                : isClassLikeLabel &&
-                    provider.classExtractor?.qualifiedNodeId === true &&
-                    qualifiedTypeName !== undefined
-                    ? qualifiedTypeName
-                    : enclosingClassInfo
-                        ? `${enclosingClassInfo.className}.${nodeName}`
-                        : nodeName;
+                : // #1991: LOCKSTEP — include Trait so a Ruby mixin module's qualified
+                    // scope id keys the worker-path node, matching the sequential path.
+                    (isClassLikeLabel || isQualifiableScopeLabel(nodeLabel)) &&
+                        provider.classExtractor?.qualifiedNodeId === true &&
+                        qualifiedTypeName !== undefined
+                        ? qualifiedTypeName
+                        : enclosingClassInfo
+                            ? `${enclosingClassInfo.className}.${nodeName}`
+                            : nodeName;
             // Extract method metadata BEFORE generating node ID — parameterCount is needed
             // to disambiguate overloaded methods via #<arity> suffix in the ID.
             let declaredType;

package/package.json

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