gitnexus 1.6.6-rc.135 → 1.6.6-rc.136

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

@@ -33,7 +33,7 @@ import { getDartParser, getDartScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
-import { DART_HERITAGE_PREFIX } from './interpret.js';
+import { encodeMarker } from '../../utils/heritage-marker.js';
 import { DART_BUILT_INS } from './built-ins.js';
 const FUNCTION_DECL_TAGS = [
     '@declaration.function',
@@ -439,7 +439,7 @@ function emitHeritageMarkers(container, kind, className, out) {
         const c = container.namedChild(i);
         if (c === null || c.type !== 'type_identifier')
             continue;
-        const payload = `${DART_HERITAGE_PREFIX}${kind}:${c.text}:${className}`;
+        const payload = encodeMarker('heritage', [kind, c.text, className]);
         out.push({ '@import.heritage': syntheticCapture('@import.heritage', c, payload) });
     }
 }

package/dist/core/ingestion/languages/dart/interpret.d.ts

@@ -15,8 +15,10 @@
  */
 import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.js';
 /** Marker prefix carried on a side-effect `ParsedImport.targetRaw` for
- *  `implements`/`with` heritage, consumed by `emitDartHeritageEdges`. */
-export declare const DART_HERITAGE_PREFIX = "__heritage__:";
+ *  `implements`/`with` heritage, consumed by `emitDartHeritageEdges`. Aliased to
+ *  the shared codec prefix (#1994) so the Dart wire prefix has a single source of
+ *  truth and cannot desync from `encodeMarker`/`decodeMarker`. */
+export declare const DART_HERITAGE_PREFIX: string;
 export declare function interpretDartImport(captures: CaptureMatch): ParsedImport | null;
 export declare function normalizeDartType(text: string): string;
 export declare function interpretDartTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;

package/dist/core/ingestion/languages/dart/interpret.js

@@ -13,9 +13,12 @@
  *     normalizing the Dart type (strip nullable `?`, unwrap single-arg
  *     container generics like `Future<X>`/`List<X>`, drop library prefixes).
  */
+import { HERITAGE_MARKER_PREFIX } from '../../utils/heritage-marker.js';
 /** Marker prefix carried on a side-effect `ParsedImport.targetRaw` for
- *  `implements`/`with` heritage, consumed by `emitDartHeritageEdges`. */
-export const DART_HERITAGE_PREFIX = '__heritage__:';
+ *  `implements`/`with` heritage, consumed by `emitDartHeritageEdges`. Aliased to
+ *  the shared codec prefix (#1994) so the Dart wire prefix has a single source of
+ *  truth and cannot desync from `encodeMarker`/`decodeMarker`. */
+export const DART_HERITAGE_PREFIX = HERITAGE_MARKER_PREFIX;
 function stripQuotes(s) {
     return s.replace(/^['"]|['"]$/g, '');
 }

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

@@ -31,7 +31,8 @@ import { populateClassOwnedMembers, isClassLike } from '../../scope-resolution/s
 import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
 import { generateId } from '../../../../lib/utils.js';
 import { dartProvider } from '../dart.js';
-import { dartArityCompatibility, dartMergeBindings, resolveDartImportTarget, DART_HERITAGE_PREFIX, } from './index.js';
+import { dartArityCompatibility, dartMergeBindings, resolveDartImportTarget } from './index.js';
+import { decodeMarker } from '../../utils/heritage-marker.js';
 import { expandDartWildcardNames } from './expand-wildcards.js';
 /**
  * Resolve a class simple name to a graph id with FILE AFFINITY: prefer a
@@ -88,9 +89,12 @@ function emitDartHeritageEdges(graph, parsedFiles, nodeLookup) {
     for (const parsed of parsedFiles) {
         for (const imp of parsed.parsedImports) {
             const raw = imp.targetRaw;
-            if (typeof raw !== 'string' || !raw.startsWith(DART_HERITAGE_PREFIX))
+            if (typeof raw !== 'string')
                 continue;
-            const parts = raw.slice(DART_HERITAGE_PREFIX.length).split(':');
+            const decoded = decodeMarker(raw);
+            if (decoded?.kind !== 'heritage')
+                continue;
+            const parts = decoded.fields;
             if (parts.length < 3)
                 continue;
             const [kind, baseName, childName] = parts;

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

@@ -5,6 +5,7 @@ import { synthesizeRubyReceiverBinding, findEnclosingClassOrModule } from './rec
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { splitQualifiedName } from '../../utils/qualified-name.js';
+import { encodeMarker } from '../../utils/heritage-marker.js';
 const FUNCTION_NODE_TYPES = ['method', 'singleton_method'];
 const HERITAGE_CALL_NAMES = new Set(['include', 'extend', 'prepend']);
 const ATTR_CALL_NAMES = new Set([
@@ -159,7 +160,7 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
                                     out.push({
                                         '@import.statement': grouped['@reference.call.free'],
                                         '@import.kind': syntheticCapture('@import.kind', callNode, 'namespace'),
-                                        '@import.source': syntheticCapture('@import.source', callNode, `__heritage__:${callName}:${mixinName}:${ownerName}`),
+                                        '@import.source': syntheticCapture('@import.source', callNode, encodeMarker('heritage', [callName, mixinName, ownerName])),
                                         '@import.name': syntheticCapture('@import.name', callNode, mixinName),
                                     });
                                 }
@@ -188,7 +189,7 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
                                     out.push({
                                         '@import.statement': grouped['@reference.call.free'],
                                         '@import.kind': syntheticCapture('@import.kind', callNode, 'namespace'),
-                                        '@import.source': syntheticCapture('@import.source', callNode, `__property__:${callName}:${propName}:${ownerName}`),
+                                        '@import.source': syntheticCapture('@import.source', callNode, encodeMarker('property', [callName, propName, ownerName])),
                                         '@import.name': syntheticCapture('@import.name', callNode, propName),
                                     });
                                     // Emit a property declaration so the property flows into

package/dist/core/ingestion/languages/ruby/import-target.js

@@ -8,6 +8,7 @@
  */
 import { resolveRubyImportInternal } from '../../import-resolvers/ruby.js';
 import { buildSuffixIndex } from '../../import-resolvers/utils.js';
+import { isHeritageMarker } from '../../utils/heritage-marker.js';
 // ─── resolveRubyImportTarget ──────────────────────────────────────────────
 /**
  * ScopeResolver-shaped adapter:
@@ -25,7 +26,7 @@ import { buildSuffixIndex } from '../../import-resolvers/utils.js';
 export function resolveRubyImportTarget(targetRaw, fromFile, allFilePaths, _resolutionConfig) {
     if (!targetRaw)
         return null;
-    if (targetRaw.startsWith('__heritage__:') || targetRaw.startsWith('__property__:'))
+    if (isHeritageMarker(targetRaw))
         return null;
     const fromNormalized = fromFile.replace(/\\/g, '/');
     const fromDir = fromNormalized.includes('/')

package/dist/core/ingestion/languages/ruby/interpret.js

@@ -1,3 +1,4 @@
+import { isHeritageMarker } from '../../utils/heritage-marker.js';
 // ─── interpretImport ──────────────────────────────────────────────────────
 /**
  * Interpret a pre-decomposed Ruby import capture into a `ParsedImport`.
@@ -18,7 +19,7 @@ export function interpretRubyImport(captures) {
         return null;
     // Heritage-encoded imports (__heritage__:include:Serializable:User)
     // are stored as namespace imports so emitHeritageEdges can read them.
-    if (source.startsWith('__heritage__:') || source.startsWith('__property__:')) {
+    if (isHeritageMarker(source)) {
         const name = captures['@import.name']?.text ?? source;
         return { kind: 'namespace', localName: name, importedName: name, targetRaw: source };
     }

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

@@ -5,8 +5,7 @@ import { rubyArityCompatibility, rubyMergeBindings, resolveRubyImportTarget } fr
 import { populateClassOwnedMembers, isClassLike } from '../../scope-resolution/scope/walkers.js';
 import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
 import { generateId } from '../../../../lib/utils.js';
-const HERITAGE_PREFIX = '__heritage__:';
-const PROPERTY_PREFIX = '__property__:';
+import { decodeMarker } from '../../utils/heritage-marker.js';
 /**
  * #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
@@ -71,9 +70,10 @@ function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
     }
     for (const parsed of parsedFiles) {
         for (const imp of parsed.parsedImports) {
-            if (!imp.targetRaw.startsWith(HERITAGE_PREFIX))
+            const decoded = decodeMarker(imp.targetRaw);
+            if (decoded?.kind !== 'heritage')
                 continue;
-            const parts = imp.targetRaw.slice(HERITAGE_PREFIX.length).split(':');
+            const parts = decoded.fields;
             if (parts.length < 3)
                 continue;
             const [kind, mixinName, className] = parts;
@@ -114,9 +114,10 @@ function emitRubyMixinEdges(graph, parsedFiles, nodeLookup) {
     }
     for (const parsed of parsedFiles) {
         for (const imp of parsed.parsedImports) {
-            if (!imp.targetRaw.startsWith(PROPERTY_PREFIX))
+            const decoded = decodeMarker(imp.targetRaw);
+            if (decoded?.kind !== 'property')
                 continue;
-            const parts = imp.targetRaw.slice(PROPERTY_PREFIX.length).split(':');
+            const parts = decoded.fields;
             if (parts.length < 3)
                 continue;
             const [_attrKind, propName, className] = parts;

package/dist/core/ingestion/utils/heritage-marker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * #1994: shared codec for the synthetic `__heritage__:` / `__property__:` import
+ * markers used by the Ruby and Dart scope resolvers to carry side-effect facts
+ * (mixin includes, attr_accessor properties) through the import channel. Both
+ * languages share the exact `':'`-delimited wire format, so a single encode/decode
+ * pair removes the per-site hand-rolled string handling that produced the #1981
+ * edge-drop. Language-NEUTRAL — keyed only on the literal prefixes; no provider
+ * branching belongs here.
+ */
+export type MarkerKind = 'heritage' | 'property';
+export declare const HERITAGE_MARKER_PREFIX: string;
+export declare const PROPERTY_MARKER_PREFIX: string;
+/**
+ * Build a marker string `<prefix><field>:<field>:...`. The `':'` delimiter IS the
+ * wire format, so a field that itself contains `':'` is structurally invalid and
+ * THROWS — callers must pre-normalize colon-bearing values (e.g. a qualified mixin
+ * arg `Outer::Mixin` → `Outer.Mixin`). This makes the #1981 silent edge-drop a
+ * loud failure instead.
+ */
+export declare function encodeMarker(kind: MarkerKind, fields: readonly string[]): string;
+/**
+ * Parse a marker string back into its kind + positional fields, or `null` if `raw`
+ * is not a marker. Mirrors the historical `slice(PREFIX.length).split(':')`.
+ */
+export declare function decodeMarker(raw: string): {
+    kind: MarkerKind;
+    fields: string[];
+} | null;
+/**
+ * True if `raw` is a synthetic heritage/property marker — exactly the prior
+ * `startsWith('__heritage__:') || startsWith('__property__:')` pair.
+ */
+export declare function isHeritageMarker(raw: string): boolean;

package/dist/core/ingestion/utils/heritage-marker.js

@@ -0,0 +1,41 @@
+const PREFIX_BY_KIND = {
+    heritage: '__heritage__:',
+    property: '__property__:',
+};
+export const HERITAGE_MARKER_PREFIX = PREFIX_BY_KIND.heritage;
+export const PROPERTY_MARKER_PREFIX = PREFIX_BY_KIND.property;
+/**
+ * Build a marker string `<prefix><field>:<field>:...`. The `':'` delimiter IS the
+ * wire format, so a field that itself contains `':'` is structurally invalid and
+ * THROWS — callers must pre-normalize colon-bearing values (e.g. a qualified mixin
+ * arg `Outer::Mixin` → `Outer.Mixin`). This makes the #1981 silent edge-drop a
+ * loud failure instead.
+ */
+export function encodeMarker(kind, fields) {
+    for (const field of fields) {
+        if (field.includes(':')) {
+            throw new Error(`encodeMarker: field "${field}" contains the ':' delimiter; normalize it before encoding`);
+        }
+    }
+    return PREFIX_BY_KIND[kind] + fields.join(':');
+}
+/**
+ * Parse a marker string back into its kind + positional fields, or `null` if `raw`
+ * is not a marker. Mirrors the historical `slice(PREFIX.length).split(':')`.
+ */
+export function decodeMarker(raw) {
+    if (raw.startsWith(PREFIX_BY_KIND.heritage)) {
+        return { kind: 'heritage', fields: raw.slice(PREFIX_BY_KIND.heritage.length).split(':') };
+    }
+    if (raw.startsWith(PREFIX_BY_KIND.property)) {
+        return { kind: 'property', fields: raw.slice(PREFIX_BY_KIND.property.length).split(':') };
+    }
+    return null;
+}
+/**
+ * True if `raw` is a synthetic heritage/property marker — exactly the prior
+ * `startsWith('__heritage__:') || startsWith('__property__:')` pair.
+ */
+export function isHeritageMarker(raw) {
+    return raw.startsWith(PREFIX_BY_KIND.heritage) || raw.startsWith(PREFIX_BY_KIND.property);
+}

package/package.json

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