gitnexus 1.6.6-rc.91 → 1.6.6-rc.93

package/dist/core/group/extractors/http-patterns/python.js

@@ -538,8 +538,9 @@ const HTTPX_ASYNC_CLIENT_GENERIC_PATTERNS = compilePatterns({
 });
 /** Strip `.py` and return the bare basename (e.g. `api/users.py` → `users`). */
 function fileShortKey(rel) {
-    const slash = rel.lastIndexOf('/');
-    const file = slash >= 0 ? rel.slice(slash + 1) : rel;
+    const normalized = rel.replace(/\\/g, '/');
+    const slash = normalized.lastIndexOf('/');
+    const file = slash >= 0 ? normalized.slice(slash + 1) : normalized;
     return file.endsWith('.py') ? file.slice(0, -3) : file;
 }
 /**
@@ -548,7 +549,8 @@ function fileShortKey(rel) {
  * case callers should fall back to the short key.
  */
 function fileLongKey(rel) {
-    const noExt = rel.endsWith('.py') ? rel.slice(0, -3) : rel;
+    const normalized = rel.replace(/\\/g, '/');
+    const noExt = normalized.endsWith('.py') ? normalized.slice(0, -3) : normalized;
     const lastSlash = noExt.lastIndexOf('/');
     if (lastSlash < 0)
         return '';

package/dist/core/ingestion/method-extractors/configs/c-cpp.js

@@ -2,6 +2,7 @@
 // Verified against tree-sitter-cpp ^0.23.4
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { hasKeyword } from '../../field-extractors/configs/helpers.js';
+import { classifyCppParameterType } from '../../languages/cpp/arity-metadata.js';
 import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 // ---------------------------------------------------------------------------
 // C/C++ helpers
@@ -140,6 +141,7 @@ function extractCppParameters(node) {
                         ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
                         : null,
                     rawType: typeNode?.text?.trim() ?? null,
+                    typeClass: classifyCppParameterType(typeNode?.text?.trim() ?? 'unknown', declNode?.text, param.text),
                     isOptional: false,
                     isVariadic: false,
                 });
@@ -155,6 +157,7 @@ function extractCppParameters(node) {
                         ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
                         : null,
                     rawType: typeNode?.text?.trim() ?? null,
+                    typeClass: classifyCppParameterType(typeNode?.text?.trim() ?? 'unknown', declNode?.text, param.text),
                     isOptional: true,
                     isVariadic: false,
                 });
@@ -171,6 +174,7 @@ function extractCppParameters(node) {
                         ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
                         : null,
                     rawType: typeNode?.text?.trim() ?? null,
+                    typeClass: classifyCppParameterType(typeNode?.text?.trim() ?? 'unknown', declNode?.text, param.text),
                     isOptional: false,
                     isVariadic: true,
                 });

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

@@ -1,4 +1,4 @@
-import type { SupportedLanguages } from '../../_shared/index.js';
+import type { ParameterTypeClass, SupportedLanguages } from '../../_shared/index.js';
 import type { FieldVisibility } from './field-types.js';
 import type { SyntaxNode } from './utils/ast-helpers.js';
 export type MethodVisibility = FieldVisibility;
@@ -9,6 +9,7 @@ export interface ParameterInfo {
      *  Used by typeTagForId for overload disambiguation where generic args matter.
      *  Falls back to `type` when not set. */
     rawType?: string | null;
+    typeClass?: ParameterTypeClass;
     isOptional: boolean;
     isVariadic: boolean;
 }

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

@@ -10,7 +10,7 @@ import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, 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, } from './utils/method-props.js';
+import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, parameterShapeIdTag, } from './utils/method-props.js';
 import { extractTemplateArguments, templateArgumentsIdTag, templateConstraintsIdTag, } from './utils/template-arguments.js';
 import { logger } from '../logger.js';
 import { getTreeSitterBufferSize, getTreeSitterContentByteLength, TREE_SITTER_MAX_BUFFER, } from './constants.js';
@@ -504,6 +504,9 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 arityTag += typeTagForId(cached.map, nodeName, arityForId, seqDefMethodInfo, language, cached.groups);
                 arityTag += constTagForId(cached.map, nodeName, arityForId, seqDefMethodInfo, cached.groups);
             }
+            const parameterShapeTag = nodeLabel === 'Function' || nodeLabel === 'Method'
+                ? parameterShapeIdTag(methodProps.parameterTypes, methodProps.parameterTypeClasses)
+                : '';
             const classTemplateArguments = extractedClassSymbol?.templateArguments ??
                 provider.classExtractor?.extractTemplateArgumentsFromCapture?.({
                     captureMap,
@@ -551,7 +554,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                     constraintsTag = '';
                 }
             }
-            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}${constraintsTag}`);
+            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}${constraintsTag}${parameterShapeTag}`);
             const classNodeForSymbol = definitionNodeForRange || definitionNode || nameNode;
             const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
                 (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)

package/dist/core/ingestion/scope-resolution/graph-bridge/ids.d.ts

@@ -16,7 +16,7 @@
  * a different file-level fallback — cross that bridge when they
  * migrate.
  */
-import type { NodeLabel, ScopeId, SymbolDefinition } from '../../../../_shared/index.js';
+import type { NodeLabel, ParameterTypeClass, ScopeId, SymbolDefinition } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
 import { type GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 /**
@@ -40,6 +40,7 @@ export declare function resolveDefGraphId(filePath: string, def: {
     qualifiedName?: string;
     type?: NodeLabel;
     parameterTypes?: readonly string[];
+    parameterTypeClasses?: readonly ParameterTypeClass[];
     templateArguments?: readonly string[];
     templateConstraints?: unknown;
 }, nodeLookup: GraphNodeLookup): string | undefined;

package/dist/core/ingestion/scope-resolution/graph-bridge/ids.js

@@ -19,6 +19,7 @@
 import { generateId } from '../../../../lib/utils.js';
 import { qualifiedKey, simpleKey } from '../graph-bridge/node-lookup.js';
 import { templateConstraintsIdTag } from '../../utils/template-arguments.js';
+import { parameterShapeIdTag } from '../../utils/method-props.js';
 /**
  * Labels that may legitimately ANCHOR a CALLS/ACCESSES edge as the
  * source ("caller"). A Variable / Property can be the TARGET of an
@@ -82,10 +83,21 @@ export function resolveDefGraphId(filePath, def, nodeLookup) {
             if (cHit !== undefined)
                 return cHit;
         }
+        if ((def.type === 'Function' || def.type === 'Method') &&
+            def.parameterTypes !== undefined &&
+            def.parameterTypeClasses !== undefined) {
+            const shapeTag = parameterShapeIdTag(def.parameterTypes, def.parameterTypeClasses);
+            if (shapeTag !== '') {
+                const shapeKey = qualifiedKey(filePath, def.type, `${qn}${shapeTag}`);
+                const shapeHit = nodeLookup.get(shapeKey);
+                if (shapeHit !== undefined)
+                    return shapeHit;
+            }
+        }
         // Overload disambiguation: when the def carries parameter types,
         // try the parameter-typed key first so same-name same-arity
         // overloads route to their distinct graph nodes.
-        if (def.type === 'Method' &&
+        if ((def.type === 'Function' || def.type === 'Method') &&
             def.parameterTypes !== undefined &&
             def.parameterTypes.length > 0) {
             const pKey = qualifiedKey(filePath, def.type, `${qn}~${def.parameterTypes.join(',')}`);

package/dist/core/ingestion/scope-resolution/graph-bridge/node-lookup.js

@@ -18,6 +18,7 @@
  * format that downstream consumers (queries, edges, MCP) expect.
  */
 import { templateConstraintsIdTag } from '../../utils/template-arguments.js';
+import { parameterShapeIdTag } from '../../utils/method-props.js';
 /**
  * Parse a qualified name out of a Function/Method node id.
  *
@@ -37,6 +38,9 @@ function parseQualifiedFromId(id, label, filePath) {
     const hash = suffix.indexOf('#');
     return hash === -1 ? suffix : suffix.slice(0, hash);
 }
+function stripCallableDisambiguatorTags(qualifiedName) {
+    return qualifiedName.replace(/~shape:.*$/, '').replace(/~c:[a-z0-9]+$/, '');
+}
 /**
  * Build a qualified-key string in a separate keyspace from simple-key
  * strings. Prefix `<q>` can't appear in a valid filePath on any OS, so
@@ -72,7 +76,8 @@ export function buildGraphNodeLookup(graph) {
         // `def save` vs `class User: def save`).
         const qualified = props.qualifiedName ?? parseQualifiedFromId(node.id, node.label, props.filePath);
         if (qualified !== undefined && qualified.length > 0) {
-            const qKey = qualifiedKey(props.filePath, node.label, qualified);
+            const keyQualified = stripCallableDisambiguatorTags(qualified);
+            const qKey = qualifiedKey(props.filePath, node.label, keyQualified);
             if (!lookup.has(qKey))
                 lookup.set(qKey, node.id);
             // Overload-disambiguating key: include parameter types so two
@@ -82,10 +87,21 @@ export function buildGraphNodeLookup(graph) {
             // a parameter-types-suffixed key so resolveDefGraphId can find
             // the right overload by matching its def's parameterTypes.
             const pTypes = props.parameterTypes;
-            if (pTypes !== undefined && pTypes.length > 0 && node.label === 'Method') {
-                const pKey = qualifiedKey(props.filePath, node.label, `${qualified}~${pTypes.join(',')}`);
+            if (pTypes !== undefined &&
+                pTypes.length > 0 &&
+                (node.label === 'Function' || node.label === 'Method')) {
+                const pKey = qualifiedKey(props.filePath, node.label, `${keyQualified}~${pTypes.join(',')}`);
                 // Each overload is unique — set unconditionally.
-                lookup.set(pKey, node.id);
+                if (!lookup.has(pKey))
+                    lookup.set(pKey, node.id);
+            }
+            const pClasses = props
+                .parameterTypeClasses;
+            const shapeTag = parameterShapeIdTag(pTypes, pClasses);
+            if (shapeTag !== '' && (node.label === 'Function' || node.label === 'Method')) {
+                const shapeKey = qualifiedKey(props.filePath, node.label, `${keyQualified}${shapeTag}`);
+                if (!lookup.has(shapeKey))
+                    lookup.set(shapeKey, node.id);
             }
             // SFINAE / `requires`-clause disambiguation (issue #1579) — register
             // a constraint-fingerprinted key so resolveDefGraphId can locate the
@@ -95,7 +111,7 @@ export function buildGraphNodeLookup(graph) {
             // `parameterTypes=['T']` would otherwise collide.
             const tConstraints = props.templateConstraints;
             if (tConstraints !== undefined && (node.label === 'Function' || node.label === 'Method')) {
-                const cKey = qualifiedKey(props.filePath, node.label, `${qualified}${templateConstraintsIdTag(tConstraints)}`);
+                const cKey = qualifiedKey(props.filePath, node.label, `${keyQualified}${templateConstraintsIdTag(tConstraints)}`);
                 lookup.set(cKey, node.id);
             }
             if ((node.label === 'Class' ||
@@ -105,7 +121,7 @@ export function buildGraphNodeLookup(graph) {
                 node.label === 'Record') &&
                 props.templateArguments !== undefined &&
                 props.templateArguments.length > 0) {
-                const tKey = qualifiedKey(props.filePath, node.label, `${qualified}~${props.templateArguments.join(',')}`);
+                const tKey = qualifiedKey(props.filePath, node.label, `${keyQualified}~${props.templateArguments.join(',')}`);
                 if (!lookup.has(tKey))
                     lookup.set(tKey, node.id);
             }

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.d.ts

@@ -35,6 +35,11 @@
  *       candidates whose template constraints provably fail at the
  *       call site. Three-valued; `'unknown'` keeps the candidate
  *       (monotonicity).
+ *   4d. Conservative C++ template partial-order approximation. When
+ *       template-placeholder overloads remain tied, prefer a candidate
+ *       whose parameter shape is more specialized for the observed
+ *       argument shape (`T*` over `T`, `const T&` over `T`). Unknown or
+ *       incomparable shapes are left ambiguous.
  *   5. Empty input returns empty output.
  */
 import type { ArityVerdict, Callsite, ConstraintContext, ParameterTypeClass, SymbolDefinition } from '../../../../_shared/index.js';

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.js

@@ -35,6 +35,11 @@
  *       candidates whose template constraints provably fail at the
  *       call site. Three-valued; `'unknown'` keeps the candidate
  *       (monotonicity).
+ *   4d. Conservative C++ template partial-order approximation. When
+ *       template-placeholder overloads remain tied, prefer a candidate
+ *       whose parameter shape is more specialized for the observed
+ *       argument shape (`T*` over `T`, `const T&` over `T`). Unknown or
+ *       incomparable shapes are left ambiguous.
  *   5. Empty input returns empty output.
  */
 export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx) {
@@ -133,6 +138,11 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
             return hookCtx.constraintCompatibility(callsite, def, ctx) !== 'incompatible';
         });
     }
+    if (result.length > 1 && argTypes !== undefined && argTypes.length > 0) {
+        const partiallyOrdered = rankByTemplatePartialOrdering(result, argTypes, hookCtx?.argumentTypeClasses);
+        if (partiallyOrdered !== undefined)
+            result = partiallyOrdered;
+    }
     return result;
 }
 function exactTypeSlotMatches(argType, paramType, argTypeClass, paramTypeClass) {
@@ -248,6 +258,110 @@ function pairwiseCompare(a, b) {
         return 1;
     return 0;
 }
+/**
+ * Closed-table approximation of C++ function-template partial ordering.
+ *
+ * Full `[temp.func.order]` requires template argument deduction. GitNexus
+ * keeps this graph-safe by recognizing only syntactic placeholder shapes
+ * that the C++ parameter sidecar already preserves:
+ *   - `T*` is more specialized than `T` for pointer arguments.
+ *
+ * Anything with unknown argument shape, non-template parameter spelling, or
+ * incomparable specialized shapes stays ambiguous so callers suppress. The
+ * placeholder detector is intentionally narrow: lowercase template parameters
+ * are left ambiguous rather than guessed.
+ */
+function rankByTemplatePartialOrdering(candidates, argTypes, argTypeClasses) {
+    if (argTypeClasses === undefined)
+        return undefined;
+    const viable = [];
+    for (const def of candidates) {
+        const params = def.parameterTypes;
+        const paramClasses = def.parameterTypeClasses;
+        if (params === undefined || paramClasses === undefined)
+            continue;
+        const ranks = [];
+        let sawTemplateSlot = false;
+        let ok = true;
+        for (let i = 0; i < argTypes.length; i++) {
+            const paramType = parameterTypeAt(params, i);
+            const paramClass = parameterTypeClassAt(paramClasses, i);
+            const argClass = argTypeClasses[i];
+            if (paramType === undefined || paramClass === undefined || argClass === undefined) {
+                ok = false;
+                break;
+            }
+            const rank = templatePartialOrderSlotRank(paramType, paramClass, argClass);
+            if (rank === undefined) {
+                ok = false;
+                break;
+            }
+            sawTemplateSlot ||= isTemplatePlaceholder(paramType);
+            ranks.push(rank);
+        }
+        if (ok && sawTemplateSlot)
+            viable.push({ def, ranks });
+    }
+    if (viable.length === 0)
+        return undefined;
+    if (viable.length !== candidates.length)
+        return [];
+    if (viable.length <= 1)
+        return viable.map((v) => v.def);
+    const dominated = new Set();
+    for (let i = 0; i < viable.length; i++) {
+        if (dominated.has(i))
+            continue;
+        for (let j = i + 1; j < viable.length; j++) {
+            if (dominated.has(j))
+                continue;
+            const cmp = compareSpecializationRanks(viable[i].ranks, viable[j].ranks);
+            if (cmp < 0)
+                dominated.add(j);
+            else if (cmp > 0)
+                dominated.add(i);
+        }
+    }
+    return viable.filter((_, idx) => !dominated.has(idx)).map((v) => v.def);
+}
+function templatePartialOrderSlotRank(paramType, paramClass, argClass) {
+    if (!isTemplatePlaceholder(paramType))
+        return undefined;
+    if (argClass.indirection === 'unknown' || paramClass.indirection === 'unknown') {
+        return undefined;
+    }
+    if (isPointerShape(paramClass)) {
+        return isPointerShape(argClass) ? 3 : undefined;
+    }
+    if (paramClass.indirection === 'value')
+        return 1;
+    return undefined;
+}
+function isTemplatePlaceholder(typeName) {
+    return /^[A-Z]\w*$/.test(typeName);
+}
+/**
+ * Higher specialization rank is better. Returns -1 when `a` dominates `b`,
+ * +1 when `b` dominates `a`, and 0 for ties / incomparable vectors.
+ */
+function compareSpecializationRanks(a, b) {
+    let aBetter = false;
+    let bBetter = false;
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        if (a[i] > b[i])
+            aBetter = true;
+        else if (b[i] > a[i])
+            bBetter = true;
+        if (aBetter && bBetter)
+            return 0;
+    }
+    if (aBetter && !bBetter)
+        return -1;
+    if (bBetter && !aBetter)
+        return 1;
+    return 0;
+}
 /**
  * Detect when >1 candidate share identical `parameterTypes` after the
  * per-language normalizer has collapsed distinct underlying types. This

package/dist/core/ingestion/utils/method-props.d.ts

@@ -1,5 +1,5 @@
 import type { MethodInfo } from '../method-types.js';
-import { SupportedLanguages } from '../../../_shared/index.js';
+import { SupportedLanguages, type ParameterTypeClass } from '../../../_shared/index.js';
 /**
  * Compute arity for ID-generation purposes.
  * Returns `undefined` when any parameter is variadic (arity is indeterminate).
@@ -28,5 +28,15 @@ collisionGroups?: Map<string, MethodInfo[]>): string;
 export declare function constTagForId(methodMap: Map<string, MethodInfo>, methodName: string, arity: number | undefined, currentInfo: MethodInfo, 
 /** Pre-built collision groups from buildCollisionGroups(). Avoids O(N) scan per call. */
 collisionGroups?: Map<string, MethodInfo[]>): string;
+/**
+ * Disambiguate function-template overloads whose normalized parameter types
+ * intentionally collapse to the same placeholder token (`T`, `U`, ...), but
+ * whose C++ sidecar shape is semantically different (`T` vs `T*` / `T&`).
+ *
+ * Kept intentionally narrow: concrete types already use the existing raw-type
+ * overload tag, and non-template languages should not acquire sidecar-shaped
+ * IDs.
+ */
+export declare function parameterShapeIdTag(parameterTypes?: readonly string[], parameterTypeClasses?: readonly ParameterTypeClass[]): string;
 /** Convert MethodInfo from methodExtractor into flat properties for a graph node. */
 export declare function buildMethodProps(info: MethodInfo): Record<string, unknown>;

package/dist/core/ingestion/utils/method-props.js

@@ -113,14 +113,53 @@ collisionGroups) {
     }
     return '';
 }
+/**
+ * Disambiguate function-template overloads whose normalized parameter types
+ * intentionally collapse to the same placeholder token (`T`, `U`, ...), but
+ * whose C++ sidecar shape is semantically different (`T` vs `T*` / `T&`).
+ *
+ * Kept intentionally narrow: concrete types already use the existing raw-type
+ * overload tag, and non-template languages should not acquire sidecar-shaped
+ * IDs.
+ */
+export function parameterShapeIdTag(parameterTypes, parameterTypeClasses) {
+    if (parameterTypes === undefined ||
+        parameterTypeClasses === undefined ||
+        parameterTypes.length === 0) {
+        return '';
+    }
+    let hasTemplatePlaceholder = false;
+    let hasDisambiguatingShape = false;
+    const parts = [];
+    for (let i = 0; i < parameterTypes.length; i++) {
+        const type = parameterTypes[i];
+        const typeClass = parameterTypeClasses[i];
+        if (typeClass === undefined)
+            return '';
+        if (/^[A-Z]\w*$/.test(type))
+            hasTemplatePlaceholder = true;
+        if (typeClass.indirection !== 'value' ||
+            typeClass.pointerDepth > 0 ||
+            (typeClass.cv !== 'none' && typeClass.cv !== 'unknown')) {
+            hasDisambiguatingShape = true;
+        }
+        parts.push(`${type}:${typeClass.cv}:${typeClass.indirection}:${typeClass.pointerDepth.toString()}`);
+    }
+    if (!hasTemplatePlaceholder || !hasDisambiguatingShape)
+        return '';
+    return `~shape:${parts.join('|')}`;
+}
 /** Convert MethodInfo from methodExtractor into flat properties for a graph node. */
 export function buildMethodProps(info) {
     const types = [];
+    const typeClasses = [];
     let optionalCount = 0;
     let hasVariadic = false;
     for (const p of info.parameters) {
         if (p.type !== null)
             types.push(p.type);
+        if (p.typeClass !== undefined)
+            typeClasses.push(p.typeClass);
         if (p.isOptional)
             optionalCount++;
         if (p.isVariadic)
@@ -132,6 +171,9 @@ export function buildMethodProps(info) {
             ? { requiredParameterCount: info.parameters.length - optionalCount }
             : {}),
         ...(types.length > 0 ? { parameterTypes: types } : {}),
+        ...(typeClasses.length === info.parameters.length && typeClasses.length > 0
+            ? { parameterTypeClasses: typeClasses }
+            : {}),
         returnType: info.returnType ?? undefined,
         visibility: info.visibility,
         isStatic: info.isStatic,

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

@@ -44,7 +44,7 @@ import { detectFrameworkFromAST } from '../framework-detection.js';
 import { generateId } from '../../../lib/utils.js';
 import { preprocessImportPath } from '../import-processor.js';
 import { extractVueScript, extractTemplateComponents, isVueSetupTopLevel, } from '../vue-sfc-extractor.js';
-import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from '../utils/method-props.js';
+import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, parameterShapeIdTag, } from '../utils/method-props.js';
 import { extractTemplateArguments, templateArgumentsIdTag } from '../utils/template-arguments.js';
 import { extractParsedFile } from '../scope-extractor-bridge.js';
 import { extractLaravelRoutes } from '../route-extractors/laravel.js';
@@ -1357,6 +1357,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 arityTag += typeTagForId(defMethodMap, nodeName, arityForId, defMethodInfo, language, groups);
                 arityTag += constTagForId(defMethodMap, nodeName, arityForId, defMethodInfo, groups);
             }
+            const parameterShapeTag = nodeLabel === 'Function' || nodeLabel === 'Method'
+                ? parameterShapeIdTag(methodProps.parameterTypes, methodProps.parameterTypeClasses)
+                : '';
             const classTemplateArguments = extractedClassSymbol?.templateArguments ??
                 provider.classExtractor?.extractTemplateArgumentsFromCapture?.({
                     captureMap,
@@ -1376,7 +1379,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 classTemplateArguments.length > 0
                 ? templateArgumentsIdTag(classTemplateArguments)
                 : '';
-            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}`);
+            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}${parameterShapeTag}`);
             const classNodeForSymbol = definitionNode || nameNode;
             const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
                 (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)

package/package.json

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