gitnexus 1.6.6-rc.71 → 1.6.6-rc.73

package/dist/_shared/scope-resolution/symbol-definition.d.ts

@@ -50,6 +50,10 @@ export interface SymbolDefinition {
      *  `ScopeResolver.constraintCompatibility` hook during overload narrowing.
      *  Absent for symbols that have no constraints (the common case). */
     templateConstraints?: unknown;
+    /** True when the producing language marked this callable as explicit.
+     *  Currently used by C++ overload ranking to exclude explicit constructors
+     *  from implicit user-defined conversion candidates. */
+    isExplicit?: boolean;
     /** Links Method/Constructor/Property to owning Class/Struct/Trait nodeId */
     ownerId?: string;
 }

package/dist/_shared/scope-resolution/symbol-definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-definition.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/symbol-definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,kBAAkB;IACjC,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAAC;IACjE,4CAA4C;IAC5C,WAAW,EAAE,OAAO,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3E,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB;;+FAE2F;IAC3F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;iHAC6G;IAC7G,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;uFACmF;IACnF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B;4FACwF;IACxF,oBAAoB,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC5C,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gGAAgG;IAChG,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;;yEAKqE;IACrE,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}
+{"version":3,"file":"symbol-definition.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/symbol-definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,kBAAkB;IACjC,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAAC;IACjE,4CAA4C;IAC5C,WAAW,EAAE,OAAO,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3E,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB;;+FAE2F;IAC3F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;iHAC6G;IAC7G,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;uFACmF;IACnF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B;4FACwF;IACxF,oBAAoB,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC5C,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gGAAgG;IAChG,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;;yEAKqE;IACrE,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;4DAEwD;IACxD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

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

@@ -89,6 +89,9 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
                 if (arity.parameterTypeClasses !== undefined) {
                     grouped['@declaration.parameter-type-classes'] = syntheticCapture('@declaration.parameter-type-classes', fnNode, JSON.stringify(arity.parameterTypeClasses));
                 }
+                if (hasExplicitSpecifier(fnNode)) {
+                    grouped['@declaration.is-explicit'] = syntheticCapture('@declaration.is-explicit', fnNode, 'true');
+                }
                 // Detect static storage class (file-local linkage)
                 if (hasStaticStorageClass(fnNode)) {
                     const nameText = grouped['@declaration.name']?.text;
@@ -1433,6 +1436,20 @@ function extractDeclaratorLeafName(node) {
     }
     return null;
 }
+/**
+ * Check if a C++ declaration has an `explicit` specifier. Tree-sitter-cpp
+ * exposes `explicit` as a direct keyword child on constructor declarations in
+ * current grammar builds; the bounded text prefix keeps this resilient across
+ * small grammar shape differences without scanning whole function bodies.
+ */
+function hasExplicitSpecifier(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child !== null && child.text === 'explicit')
+            return true;
+    }
+    return /\bexplicit\b/.test(node.text.slice(0, 128));
+}
 /**
  * Check if a C++ function_definition or declaration has `static` storage class.
  */

package/dist/core/ingestion/languages/cpp/conversion-rank.d.ts

@@ -12,7 +12,8 @@
  *   - rank 2: standard conversion (arithmetic, nullptr -> T*, T* -> bool,
  *             T* -> void*)
  *   - rank 3: nullptr -> bool (kept worse than nullptr -> T*)
- *   - rank 4: ellipsis conversion (worst viable)
+ *   - rank 4: user-defined conversion (one-step, conservative)
+ *   - rank 5: ellipsis conversion (worst viable)
  *   - Infinity: mismatch (string -> int, user types, unsupported shapes)
  *
  * This function is intentionally C++-specific. Other languages may define
@@ -23,7 +24,8 @@ import type { ParameterTypeClass } from '../../../../_shared/index.js';
  * Return the conversion rank from `argType` to `paramType`.
  *
  * @returns 0 for exact match, 1 for integral promotion, 2 for standard
- *          conversion, 3 for nullptr -> bool, 4 for ellipsis, Infinity
+ *          conversion, 3 for nullptr -> bool, 4 for user-defined conversion,
+ *          5 for ellipsis, Infinity
  *          for mismatch.
  */
 export declare function cppConversionRank(argType: string, paramType: string, argTypeClass?: ParameterTypeClass, paramTypeClass?: ParameterTypeClass): number;

package/dist/core/ingestion/languages/cpp/conversion-rank.js

@@ -12,12 +12,14 @@
  *   - rank 2: standard conversion (arithmetic, nullptr -> T*, T* -> bool,
  *             T* -> void*)
  *   - rank 3: nullptr -> bool (kept worse than nullptr -> T*)
- *   - rank 4: ellipsis conversion (worst viable)
+ *   - rank 4: user-defined conversion (one-step, conservative)
+ *   - rank 5: ellipsis conversion (worst viable)
  *   - Infinity: mismatch (string -> int, user types, unsupported shapes)
  *
  * This function is intentionally C++-specific. Other languages may define
  * their own `ConversionRankFn` in the future.
  */
+import { hasCppUserDefinedConversion } from './user-defined-conversions.js';
 /** Set of normalized arithmetic types that support implicit conversion. */
 const ARITHMETIC = new Set(['int', 'double', 'char', 'bool']);
 /** Integral promotion targets: char -> int and bool -> int are rank 1. */
@@ -29,7 +31,8 @@ const INTEGRAL_PROMOTION = new Map([
  * Return the conversion rank from `argType` to `paramType`.
  *
  * @returns 0 for exact match, 1 for integral promotion, 2 for standard
- *          conversion, 3 for nullptr -> bool, 4 for ellipsis, Infinity
+ *          conversion, 3 for nullptr -> bool, 4 for user-defined conversion,
+ *          5 for ellipsis, Infinity
  *          for mismatch.
  */
 export function cppConversionRank(argType, paramType, argTypeClass, paramTypeClass) {
@@ -37,7 +40,7 @@ export function cppConversionRank(argType, paramType, argTypeClass, paramTypeCla
         return exactShapeCompatible(argTypeClass, paramTypeClass) ? 0 : Infinity;
     }
     if (paramType === '...')
-        return 4;
+        return 5;
     if (INTEGRAL_PROMOTION.get(argType) === paramType)
         return 1;
     if (ARITHMETIC.has(argType) && ARITHMETIC.has(paramType))
@@ -50,6 +53,8 @@ export function cppConversionRank(argType, paramType, argTypeClass, paramTypeCla
         return 2;
     if (isPointer(argTypeClass) && isPointer(paramTypeClass) && paramType === 'void')
         return 2;
+    if (hasCppUserDefinedConversion(argType, paramType))
+        return 4;
     return Infinity;
 }
 function isPointer(typeClass) {

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

@@ -224,6 +224,12 @@ const CPP_SCOPE_QUERY = `
     declarator: (function_declarator
       declarator: (field_identifier) @declaration.name))) @declaration.method
 
+;; Constructor prototype in class body: User(int id);
+(field_declaration_list
+  (declaration
+    declarator: (function_declarator
+      declarator: (identifier) @declaration.name)) @declaration.method)
+
 ;; Method prototype with reference return: User& getRef();
 (field_declaration
   declarator: (reference_declarator

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

@@ -14,6 +14,7 @@ import { populateCppAssociatedNamespaces, clearCppAdlState, pickCppAdlCandidates
 import { clearCppInlineNamespaces, populateCppInlineNamespaceScopes, resolveCppQualifiedNamespaceMember, } from './inline-namespaces.js';
 import { populateCppRangeBindings } from './range-bindings.js';
 import { cppConstraintCompatibility } from './constraint-filter.js';
+import { clearCppUserDefinedConversions, populateCppUserDefinedConversions, } from './user-defined-conversions.js';
 /**
  * C++ `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
@@ -39,6 +40,7 @@ export const cppScopeResolver = {
         clearCppDependentBases();
         clearCppAdlState();
         clearCppInlineNamespaces();
+        clearCppUserDefinedConversions();
         return scanCppHeaderFiles(repoPath);
     },
     resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
@@ -80,6 +82,10 @@ export const cppScopeResolver = {
         // by ADL (U2 of plan 2026-05-13-001) to identify each argument type's
         // associated namespace for Koenig lookup.
         populateCppAssociatedNamespaces(parsed);
+        // Build conservative one-step user-defined conversion facts for
+        // overload ranking (#1631): implicit converting constructors only,
+        // with no chaining or conversion-operator handling.
+        populateCppUserDefinedConversions(parsed);
     },
     // Resolve recorded template-class → dependent-base simple names to
     // class nodeIds for two-phase template lookup (U3 of plan

package/dist/core/ingestion/languages/cpp/user-defined-conversions.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedFile } from '../../../../_shared/index.js';
+export declare function clearCppUserDefinedConversions(): void;
+export declare function hasCppUserDefinedConversion(argType: string, paramType: string): boolean;
+export declare function populateCppUserDefinedConversions(parsed: ParsedFile): void;
+export declare function registerCppUserDefinedConversion(argType: string, paramType: string): void;

package/dist/core/ingestion/languages/cpp/user-defined-conversions.js

@@ -0,0 +1,122 @@
+import { normalizeCppParamType } from './arity-metadata.js';
+const userDefinedConversions = new Set();
+const pendingUserDefinedConversions = [];
+const classIdentitiesBySimpleName = new Map();
+export function clearCppUserDefinedConversions() {
+    userDefinedConversions.clear();
+    pendingUserDefinedConversions.length = 0;
+    classIdentitiesBySimpleName.clear();
+}
+export function hasCppUserDefinedConversion(argType, paramType) {
+    return userDefinedConversions.has(conversionKey(argType, paramType));
+}
+export function populateCppUserDefinedConversions(parsed) {
+    const scopesById = new Map();
+    for (const scope of parsed.scopes)
+        scopesById.set(scope.id, scope);
+    for (const classScope of parsed.scopes) {
+        if (classScope.kind !== 'Class')
+            continue;
+        const classDef = classScope.ownedDefs.find(isClassLike);
+        if (classDef !== undefined)
+            recordClassIdentity(classDef);
+    }
+    for (const classScope of parsed.scopes) {
+        if (classScope.kind !== 'Class')
+            continue;
+        const classDef = classScope.ownedDefs.find(isClassLike);
+        if (classDef === undefined)
+            continue;
+        const className = normalizedSimpleName(classDef);
+        if (className === '')
+            continue;
+        const methodDefs = collectClassMethodDefs(classScope.id, parsed, scopesById);
+        for (const def of methodDefs) {
+            const simpleName = simpleNameOf(def);
+            if (simpleName === className && def.parameterTypes?.length === 1) {
+                if (def.isExplicit === true)
+                    continue;
+                registerPendingCppUserDefinedConversion(def.parameterTypes[0], className, className);
+            }
+        }
+    }
+    rebuildCppUserDefinedConversions();
+}
+export function registerCppUserDefinedConversion(argType, paramType) {
+    if (argType === '' || paramType === '')
+        return;
+    if (argType === paramType)
+        return;
+    userDefinedConversions.add(conversionKey(argType, paramType));
+}
+function collectClassMethodDefs(classScopeId, parsed, scopesById) {
+    const methods = [];
+    const classScope = scopesById.get(classScopeId);
+    if (classScope === undefined)
+        return methods;
+    for (const def of classScope.ownedDefs) {
+        if (isCallableMember(def))
+            methods.push(def);
+    }
+    for (const scope of parsed.scopes) {
+        if (scope.parent !== classScopeId)
+            continue;
+        if (scope.kind === 'Class')
+            continue;
+        for (const def of scope.ownedDefs) {
+            if (isCallableMember(def))
+                methods.push(def);
+        }
+    }
+    return methods;
+}
+function conversionKey(argType, paramType) {
+    return `${argType}\0${paramType}`;
+}
+function registerPendingCppUserDefinedConversion(argType, paramType, ownerClassName) {
+    if (argType === '' || paramType === '')
+        return;
+    if (argType === paramType)
+        return;
+    pendingUserDefinedConversions.push({ argType, paramType, ownerClassName });
+}
+function rebuildCppUserDefinedConversions() {
+    userDefinedConversions.clear();
+    for (const conversion of pendingUserDefinedConversions) {
+        if (isAmbiguousClassName(conversion.ownerClassName))
+            continue;
+        userDefinedConversions.add(conversionKey(conversion.argType, conversion.paramType));
+    }
+}
+function recordClassIdentity(def) {
+    const simpleName = normalizedSimpleName(def);
+    if (simpleName === '')
+        return;
+    const identities = classIdentitiesBySimpleName.get(simpleName) ?? new Set();
+    identities.add(normalizedQualifiedClassName(def));
+    classIdentitiesBySimpleName.set(simpleName, identities);
+}
+function isAmbiguousClassName(simpleName) {
+    return (classIdentitiesBySimpleName.get(simpleName)?.size ?? 0) > 1;
+}
+function normalizedQualifiedClassName(def) {
+    const qualifiedName = def.qualifiedName ?? simpleNameOf(def);
+    if (qualifiedName === '' || !qualifiedName.includes('.'))
+        return `${def.filePath}:${def.nodeId}`;
+    return qualifiedName
+        .split('.')
+        .map((part) => normalizeCppParamType(part))
+        .join('.');
+}
+function normalizedSimpleName(def) {
+    return normalizeCppParamType(simpleNameOf(def));
+}
+function simpleNameOf(def) {
+    return def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+}
+function isClassLike(def) {
+    return def.type === 'Class' || def.type === 'Struct' || def.type === 'Interface';
+}
+function isCallableMember(def) {
+    return def.type === 'Method' || def.type === 'Constructor';
+}

package/dist/core/ingestion/languages/typescript/import-target.d.ts

@@ -15,6 +15,7 @@
  */
 import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
 import { SupportedLanguages } from '../../../../_shared/index.js';
+import type { SuffixIndex } from '../../import-resolvers/utils.js';
 import type { TsconfigPaths } from '../../language-config.js';
 export interface TsResolveContext {
     readonly fromFile: string;
@@ -28,6 +29,8 @@ export interface TsResolveContext {
     readonly normalizedFileList?: readonly string[];
     /** Per-call resolution cache to dedupe repeated lookups. */
     readonly resolveCache?: Map<string, string | null>;
+    /** Prebuilt suffix index for O(1)-style package/absolute import matching. */
+    readonly index?: SuffixIndex;
     /** Parsed tsconfig path-aliases. `null` = no aliases configured. */
     readonly tsconfigPaths?: TsconfigPaths | null;
     /** JavaScript vs TypeScript switch — affects the extensions the

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

@@ -48,7 +48,7 @@ export function resolveTsTarget(targetRaw, ctx) {
     const allFileList = ctx.allFileList ?? Array.from(ctx.allFilePaths);
     const normalizedFileList = ctx.normalizedFileList ?? allFileList.map((f) => f.toLowerCase());
     const resolveCache = ctx.resolveCache ?? new Map();
-    return resolveImportPath(ctx.fromFile, targetRaw, ctx.allFilePaths, allFileList, normalizedFileList, resolveCache, language, ctx.tsconfigPaths ?? null);
+    return resolveImportPath(ctx.fromFile, targetRaw, ctx.allFilePaths, allFileList, normalizedFileList, resolveCache, language, ctx.tsconfigPaths ?? null, ctx.index);
 }
 function narrowTsContext(workspaceIndex) {
     const ctx = workspaceIndex;

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

@@ -16,6 +16,7 @@ import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
 import { typescriptProvider } from '../typescript.js';
 import { loadTsconfigPaths } from '../../language-config.js';
+import { buildSuffixIndex } from '../../import-resolvers/utils.js';
 import { typescriptArityCompatibility, typescriptMergeBindings, resolveTsTarget, } from './index.js';
 /**
  * Build a `resolveImportTarget` adapter that memoizes the workspace
@@ -35,11 +36,13 @@ function makeTsResolveImportTarget() {
     return (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
         if (cached === null || cached.key !== allFilePaths) {
             const allFileList = Array.from(allFilePaths);
+            const normalizedFileList = allFileList.map((f) => f.toLowerCase());
             cached = {
                 key: allFilePaths,
                 allFilePaths: new Set(allFilePaths),
                 allFileList,
-                normalizedFileList: allFileList.map((f) => f.toLowerCase()),
+                normalizedFileList,
+                index: buildSuffixIndex(normalizedFileList, allFileList),
                 resolveCache: new Map(),
             };
         }
@@ -49,6 +52,7 @@ function makeTsResolveImportTarget() {
             allFilePaths: cached.allFilePaths,
             allFileList: cached.allFileList,
             normalizedFileList: cached.normalizedFileList,
+            index: cached.index,
             resolveCache: cached.resolveCache,
             tsconfigPaths: cfg?.tsconfigPaths ?? null,
         };

package/dist/core/ingestion/scope-extractor.js

@@ -398,6 +398,7 @@ function buildDefFromDeclarationMatch(match, anchor, filePath) {
     const declaredType = match['@declaration.field-type']?.text;
     const returnType = match['@declaration.return-type']?.text;
     const templateConstraints = parseJsonCapture(match['@declaration.template-constraints']);
+    const isExplicit = parseBooleanCapture(match['@declaration.is-explicit']);
     return {
         nodeId: makeDefId(filePath, anchor.range, type, nameCap.text),
         filePath,
@@ -411,6 +412,7 @@ function buildDefFromDeclarationMatch(match, anchor, filePath) {
         ...(returnType !== undefined ? { returnType } : {}),
         ...(templateArguments !== undefined ? { templateArguments } : {}),
         ...(templateConstraints !== undefined ? { templateConstraints } : {}),
+        ...(isExplicit === true ? { isExplicit: true } : {}),
     };
 }
 /** Parse an opaque JSON payload synthesized by per-language captures
@@ -433,6 +435,15 @@ function parseIntCapture(cap) {
     const n = Number.parseInt(cap.text, 10);
     return Number.isFinite(n) ? n : undefined;
 }
+function parseBooleanCapture(cap) {
+    if (cap === undefined)
+        return undefined;
+    if (cap.text === 'true')
+        return true;
+    if (cap.text === 'false')
+        return false;
+    return undefined;
+}
 function parseJsonParameterTypeClassesCapture(cap) {
     if (cap === undefined)
         return undefined;
@@ -843,6 +854,7 @@ const KNOWN_SUB_TAGS = new Set([
     '@declaration.parameter-types',
     '@declaration.parameter-type-classes',
     '@declaration.template-constraints',
+    '@declaration.is-explicit',
 ]);
 /**
  * Return the anchor capture for a match — the one whose name begins with

package/package.json

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