gitnexus 1.6.5 → 1.6.6-rc.10

package/dist/cli/wiki.js

@@ -14,6 +14,19 @@ import { WikiGenerator } from '../core/wiki/generator.js';
 import { resolveLLMConfig } from '../core/wiki/llm-client.js';
 import { detectCursorCLI } from '../core/wiki/cursor-client.js';
 import { logger } from '../core/logger.js';
+function parsePositiveIntegerOption(value, flag, multiplier = 1) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    if (!/^[1-9]\d*$/.test(trimmed)) {
+        throw new Error(`${flag} must be a positive integer`);
+    }
+    const parsed = parseInt(trimmed, 10);
+    if (parsed > Math.floor(Number.MAX_SAFE_INTEGER / multiplier)) {
+        throw new Error(`${flag} is too large`);
+    }
+    return parsed;
+}
 /**
  * Prompt the user for input via stdin.
  */
@@ -100,6 +113,17 @@ export const wikiCommand = async (inputPath, options) => {
         process.exitCode = 1;
         return;
     }
+    let timeoutSeconds;
+    let retries;
+    try {
+        timeoutSeconds = parsePositiveIntegerOption(options?.timeout, '--timeout', 1000);
+        retries = parsePositiveIntegerOption(options?.retries, '--retries');
+    }
+    catch (error) {
+        console.log(`  Error: ${error.message}\n`);
+        process.exitCode = 1;
+        return;
+    }
     // ── Resolve LLM config (with interactive fallback) ─────────────────
     // Save any CLI overrides immediately
     if (options?.apiKey ||
@@ -305,15 +329,11 @@ export const wikiCommand = async (inputPath, options) => {
         }
     }
     // ── Apply per-run overrides not saved to config ────────────────────
-    if (options?.timeout) {
-        const secs = parseInt(options.timeout, 10);
-        if (!isNaN(secs) && secs > 0)
-            llmConfig.requestTimeoutMs = secs * 1000;
+    if (timeoutSeconds !== undefined) {
+        llmConfig.requestTimeoutMs = timeoutSeconds * 1000;
     }
-    if (options?.retries) {
-        const n = parseInt(options.retries, 10);
-        if (!isNaN(n) && n > 0)
-            llmConfig.maxAttempts = n;
+    if (retries !== undefined) {
+        llmConfig.maxAttempts = retries;
     }
     // ── Setup progress bar with elapsed timer ──────────────────────────
     const bar = new cliProgress.SingleBar({
@@ -344,6 +364,7 @@ export const wikiCommand = async (inputPath, options) => {
         force: options?.force,
         concurrency: options?.concurrency ? parseInt(options.concurrency, 10) : undefined,
         reviewOnly: options?.review,
+        lang: options?.lang,
     };
     const generator = new WikiGenerator(repoPath, storagePath, lbugPath, llmConfig, wikiOptions, (phase, percent, detail) => {
         const label = detail || phase;
@@ -473,6 +494,9 @@ export const wikiCommand = async (inputPath, options) => {
         if (err.message?.includes('No source files')) {
             console.log(`\n  ${err.message}\n`);
         }
+        else if (err.message?.includes('LLM request timed out after')) {
+            console.log(`\n  Timeout: ${err.message}\n`);
+        }
         else if (err.message?.includes('content filter')) {
             // Content filter block — actionable message
             console.log(`\n  Content Filter: ${err.message}\n`);

package/dist/core/ingestion/language-provider.d.ts

@@ -155,6 +155,35 @@ interface LanguageProviderConfig {
         funcName: string;
         label: NodeLabel;
     } | null;
+    /**
+     * Extract a per-language template-constraint payload for a templated
+     * function / method definition. Used by `parsing-processor` to
+     * disambiguate same-name same-arity overloads whose distinguishing
+     * signal is their template constraints rather than their parameter
+     * types — the canonical C++ SFINAE case (issue #1579):
+     *
+     *   template<class T, std::enable_if_t<is_integral_v<T>, int> = 0>
+     *   void process(T);   // overload A
+     *
+     *   template<class T, std::enable_if_t<is_floating_point_v<T>, int> = 0>
+     *   void process(T);   // overload B
+     *
+     * Both overloads' `parameterTypes` collapse to `['T']`, so without a
+     * constraint fingerprint in the graph node ID they merge into one
+     * Function node and the resolver only ever sees one candidate to
+     * narrow. The hook's return value is stamped onto the node's ID via
+     * `templateConstraintsIdTag()` AND stored on the node's
+     * `templateConstraints` property so `resolveDefGraphId` can look up
+     * the right overload by re-hashing the def's constraints at resolve
+     * time.
+     *
+     * Returns the opaque payload (any JSON-serializable shape — the
+     * producing adapter owns it; shared code MUST NOT inspect) or
+     * `undefined` when no constraints exist / the node isn't a templated
+     * function. Languages without SFINAE / concept semantics leave this
+     * undefined and the disambiguation is a pass-through.
+     */
+    readonly extractTemplateConstraints?: (definitionNode: SyntaxNode) => unknown;
     /** Override the default node label for definition.function captures.
      *  Return null to skip (C/C++ duplicate), a different label to reclassify
      *  (e.g., 'Method' for Kotlin), or defaultLabel to keep as-is.

package/dist/core/ingestion/languages/c-cpp.js

@@ -39,6 +39,7 @@ import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 import { stripUeMacros } from '../cpp-ue-preprocessor.js';
 import { emitCScopeCaptures, interpretCImport, interpretCTypeBinding, cArityCompatibility, cBindingScopeFor, cImportOwningScope, cReceiverBinding, } from './c/index.js';
 import { emitCppScopeCaptures, interpretCppImport, interpretCppTypeBinding, cppArityCompatibility, cppBindingScopeFor, cppImportOwningScope, cppReceiverBinding, } from './cpp/index.js';
+import { extractCppTemplateConstraints } from './cpp/constraint-extractor.js';
 const C_BUILT_INS = new Set([
     'printf',
     'fprintf',
@@ -417,6 +418,7 @@ export const cppProvider = defineLanguage({
     heritageExtractor: createHeritageExtractor(SupportedLanguages.CPlusPlus),
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,
+    extractTemplateConstraints: extractCppTemplateConstraintsForProvider,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     emitScopeCaptures: emitCppScopeCaptures,
     interpretImport: interpretCppImport,
@@ -427,3 +429,47 @@ export const cppProvider = defineLanguage({
     arityCompatibility: cppArityCompatibility,
     // mergeBindings + resolveImportTarget live on ScopeResolver (see cpp/scope-resolver.ts).
 });
+/**
+ * LanguageProvider hook: walk from a function definition node up to its
+ * enclosing `template_declaration` and extract the SFINAE / `requires`-
+ * clause constraint payload. Used by `parsing-processor` to fingerprint
+ * the graph node ID so two SFINAE overloads with identical
+ * `parameterTypes` get distinct nodes (issue #1579).
+ *
+ * Returns `undefined` for non-templated functions and for templated
+ * functions whose constraints the extractor can't model — both cases
+ * result in no constraint suffix on the node ID.
+ */
+function extractCppTemplateConstraintsForProvider(definitionNode) {
+    // Walk up to the enclosing template_declaration. Bound the walk so we
+    // can't accidentally land on a far-ancestor template_declaration that
+    // wraps an unrelated function.
+    let cur = definitionNode.parent;
+    let hops = 8;
+    let templateDecl = null;
+    while (cur !== null && hops-- > 0) {
+        if (cur.type === 'template_declaration') {
+            templateDecl = cur;
+            break;
+        }
+        if (cur.type === 'translation_unit')
+            break;
+        cur = cur.parent;
+    }
+    if (templateDecl === null)
+        return undefined;
+    // Find the function_declarator inside the function definition so the
+    // extractor can map template params to function-argument indices.
+    let declarator = definitionNode.childForFieldName('declarator');
+    let walk = 8;
+    while (declarator !== null && walk-- > 0) {
+        if (declarator.type === 'function_declarator')
+            break;
+        if (declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator') {
+            declarator = declarator.childForFieldName('declarator');
+            continue;
+        }
+        break;
+    }
+    return extractCppTemplateConstraints(templateDecl, declarator);
+}

package/dist/core/ingestion/languages/cpp/arity-metadata.d.ts

@@ -1,8 +1,10 @@
 import type { SyntaxNode } from '../../utils/ast-helpers.js';
+import type { ParameterTypeClass } from '../../../../_shared/index.js';
 export interface CppArityInfo {
     parameterCount?: number;
     requiredParameterCount?: number;
     parameterTypes?: string[];
+    parameterTypeClasses?: ParameterTypeClass[];
 }
 /**
  * Compute declaration arity from a C++ function definition or declaration node.
@@ -16,3 +18,18 @@ export declare function computeCppDeclarationArity(node: SyntaxNode): CppArityIn
  * Compute call-site arity from a call_expression node.
  */
 export declare function computeCppCallArity(node: SyntaxNode): number;
+/**
+ * Normalize a C++ parameter type for overload disambiguation.
+ * Maps common qualified/aliased types to their canonical short forms
+ * so that `narrowOverloadCandidates` can match against literal-inferred
+ * argument types (e.g. `inferCppLiteralType` returns `'string'` for
+ * string literals, not `'std::string'`).
+ *
+ * This intentionally remains coarse and graph-ID-stable: cv-qualifiers,
+ * reference markers, and pointer markers are stripped here. C++ callers
+ * that need those distinctions should read `parameterTypeClasses`, which
+ * is an additive sidecar and does not participate in overload node ID
+ * hashing.
+ */
+export declare function normalizeCppParamType(raw: string): string;
+export declare function classifyCppParameterType(rawType: string, declaratorText?: string, fullParameterText?: string): ParameterTypeClass;

package/dist/core/ingestion/languages/cpp/arity-metadata.js

@@ -55,27 +55,34 @@ export function computeCppDeclarationArity(node) {
         p.type === 'variadic_parameter_declaration').length;
     const totalNonVariadic = requiredCount + optionalCount;
     const types = [];
+    const typeClasses = [];
     for (const p of params) {
         if (p.type === 'variadic_parameter') {
             types.push('...');
+            typeClasses.push(unknownTypeClass('...'));
         }
         else if (p.type === 'variadic_parameter_declaration') {
             // Parameter pack: treated as variadic
             types.push('...');
+            typeClasses.push(unknownTypeClass('...'));
         }
         else {
             const typeNode = p.childForFieldName('type');
-            types.push(normalizeCppParamType(typeNode?.text ?? 'unknown'));
+            const rawType = typeNode?.text ?? 'unknown';
+            types.push(normalizeCppParamType(rawType));
+            typeClasses.push(classifyCppParameterType(rawType, p.childForFieldName('declarator')?.text, p.text));
         }
     }
     // Append '...' for C-style variadic if not already in types
     if (hasEllipsis && !types.includes('...')) {
         types.push('...');
+        typeClasses.push(unknownTypeClass('...'));
     }
     return {
         parameterCount: isVariadic ? undefined : totalNonVariadic,
         requiredParameterCount: requiredCount,
         parameterTypes: types,
+        parameterTypeClasses: typeClasses,
     };
 }
 /**
@@ -102,8 +109,14 @@ export function computeCppCallArity(node) {
  * so that `narrowOverloadCandidates` can match against literal-inferred
  * argument types (e.g. `inferCppLiteralType` returns `'string'` for
  * string literals, not `'std::string'`).
+ *
+ * This intentionally remains coarse and graph-ID-stable: cv-qualifiers,
+ * reference markers, and pointer markers are stripped here. C++ callers
+ * that need those distinctions should read `parameterTypeClasses`, which
+ * is an additive sidecar and does not participate in overload node ID
+ * hashing.
  */
-function normalizeCppParamType(raw) {
+export function normalizeCppParamType(raw) {
     let t = raw.trim();
     // Strip const, volatile, etc.
     t = t.replace(/\b(const|volatile|restrict|mutable|constexpr)\b/g, '').trim();
@@ -140,6 +153,42 @@ function normalizeCppParamType(raw) {
     };
     return STD_MAP[t] ?? t;
 }
+export function classifyCppParameterType(rawType, declaratorText, fullParameterText) {
+    const source = fullParameterText ?? `${rawType} ${declaratorText ?? ''}`.trim();
+    if (rawType === 'unknown')
+        return unknownTypeClass('unknown');
+    const hasConst = /\bconst\b/.test(source);
+    const hasVolatile = /\bvolatile\b/.test(source);
+    const cv = hasConst && hasVolatile
+        ? 'const volatile'
+        : hasConst
+            ? 'const'
+            : hasVolatile
+                ? 'volatile'
+                : 'none';
+    const pointerDepth = (source.match(/\*/g) ?? []).length;
+    const indirection = pointerDepth > 0
+        ? 'pointer'
+        : /&&/.test(source)
+            ? 'rvalue-ref'
+            : /&/.test(source)
+                ? 'lvalue-ref'
+                : 'value';
+    return {
+        base: normalizeCppParamType(rawType),
+        cv,
+        indirection,
+        pointerDepth,
+    };
+}
+function unknownTypeClass(base) {
+    return {
+        base,
+        cv: 'unknown',
+        indirection: 'unknown',
+        pointerDepth: 0,
+    };
+}
 function findFuncDeclarator(node) {
     let decl = node.childForFieldName('declarator');
     if (decl === null) {

package/dist/core/ingestion/languages/cpp/arity.d.ts

@@ -7,7 +7,10 @@ import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
  *   - Default parameters (requiredParameterCount < parameterCount)
  *   - Variadic functions (C-style `...`)
  *   - Parameter packs (V1: treated as variadic)
- *   - Templates (V1: generic-ignored, arity check on non-template params)
+ *   - Templates: arity check on non-template params; SFINAE / `requires`
+ *     constraints are filtered separately via `constraintCompatibility`
+ *     (see `constraint-filter.ts` and issue #1579). Type-argument generic
+ *     substitution (`List<T>` ≡ `List<U>`) remains out of V1 scope.
  *
  * Verdict:
  *   - 'compatible':    callsite.arity fits within [required, total] range

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

@@ -6,7 +6,10 @@
  *   - Default parameters (requiredParameterCount < parameterCount)
  *   - Variadic functions (C-style `...`)
  *   - Parameter packs (V1: treated as variadic)
- *   - Templates (V1: generic-ignored, arity check on non-template params)
+ *   - Templates: arity check on non-template params; SFINAE / `requires`
+ *     constraints are filtered separately via `constraintCompatibility`
+ *     (see `constraint-filter.ts` and issue #1579). Type-argument generic
+ *     substitution (`List<T>` ≡ `List<U>`) remains out of V1 scope.
  *
  * Verdict:
  *   - 'compatible':    callsite.arity fits within [required, total] range

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

@@ -8,6 +8,7 @@ import { markCppAnonymousNamespaceRange, markFileLocal } from './file-local-link
 import { markCppDependentBase } from './two-phase-lookup.js';
 import { markCppAdlSiteArgs, markCppAdlSiteNoAdl } from './adl.js';
 import { markCppInlineNamespaceRange } from './inline-namespaces.js';
+import { extractCppTemplateConstraints } from './constraint-extractor.js';
 export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -85,6 +86,9 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
                 if (arity.parameterTypes !== undefined) {
                     grouped['@declaration.parameter-types'] = syntheticCapture('@declaration.parameter-types', fnNode, JSON.stringify(arity.parameterTypes));
                 }
+                if (arity.parameterTypeClasses !== undefined) {
+                    grouped['@declaration.parameter-type-classes'] = syntheticCapture('@declaration.parameter-type-classes', fnNode, JSON.stringify(arity.parameterTypeClasses));
+                }
                 // Detect static storage class (file-local linkage)
                 if (hasStaticStorageClass(fnNode)) {
                     const nameText = grouped['@declaration.name']?.text;
@@ -99,6 +103,19 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
                         markFileLocal(filePath, nameText);
                     }
                 }
+                // SFINAE / `requires`-clause aware constraints for overload
+                // narrowing (issue #1579). Walk from the enclosing
+                // `template_declaration` — not the inner `function_definition` —
+                // so inline method templates (`template<...> class C { template<...> void f(); }`)
+                // pick up the correct outer constraint scope.
+                const templateDecl = findEnclosingTemplateDeclaration(fnNode);
+                if (templateDecl !== null) {
+                    const funcDeclarator = findFunctionDeclarator(fnNode);
+                    const constraints = extractCppTemplateConstraints(templateDecl, funcDeclarator);
+                    if (constraints !== undefined) {
+                        grouped['@declaration.template-constraints'] = syntheticCapture('@declaration.template-constraints', fnNode, JSON.stringify(constraints));
+                    }
+                }
             }
         }
         // ── Detect static variables (file-local linkage) ────────────────
@@ -484,6 +501,53 @@ function extractBaseLookupName(baseNode) {
     }
     return '';
 }
+/**
+ * Walk parent chain from a function_definition / declaration / field_declaration
+ * to find the enclosing `template_declaration`. Returns null when the function
+ * isn't templated. The walk only ascends through wrapper nodes the C++
+ * grammar inserts between `template_declaration` and the function — direct
+ * parent in the common case, two hops for member templates whose outer
+ * class is also templated (we return the INNERMOST template_declaration,
+ * which carries this function's own template parameters).
+ */
+function findEnclosingTemplateDeclaration(fnNode) {
+    let cur = fnNode.parent;
+    // Cap the walk — `template_declaration` is typically the immediate parent
+    // or one wrapper away. Anything deeper is an inline-method-in-template
+    // shape and we still want the innermost templates_declaration whose body
+    // wraps `fnNode`.
+    let hops = 8;
+    while (cur !== null && hops-- > 0) {
+        if (cur.type === 'template_declaration')
+            return cur;
+        // Don't ascend past structural boundaries that should reset template scope.
+        if (cur.type === 'translation_unit')
+            return null;
+        cur = cur.parent;
+    }
+    return null;
+}
+/**
+ * Locate the `function_declarator` AST node within a function definition
+ * or declaration. Unwraps pointer/reference declarator wrappers. Returns
+ * null when no function_declarator is found (e.g. variable declaration
+ * mis-classified upstream).
+ */
+function findFunctionDeclarator(fnNode) {
+    const direct = fnNode.childForFieldName('declarator');
+    let cur = direct;
+    let hops = 8;
+    while (cur !== null && hops-- > 0) {
+        if (cur.type === 'function_declarator')
+            return cur;
+        if (cur.type === 'pointer_declarator' || cur.type === 'reference_declarator') {
+            cur = cur.childForFieldName('declarator');
+            continue;
+        }
+        break;
+    }
+    return findFirstDescendantOfType(fnNode, 'function_declarator');
+}
 /** Find the first direct child matching one of the given types. */
 function findChildOfType(node, types) {
     for (let i = 0; i < node.childCount; i++) {
@@ -589,6 +653,15 @@ function inferCppLiteralType(node) {
  *   - `int n = ...` → 'int'
  *   - `const int n = ...` → 'int'
  * Returns empty string if no declaration found or type is auto/placeholder.
+ *
+ * Limitation: only `declaration` siblings inside the enclosing
+ * `compound_statement` are inspected. Function parameters live in the
+ * `function_declarator`'s `parameter_list` and are NOT resolved here, so
+ *   `void run(int n) { process(n); }`
+ * infers `''` for `n` and the constraint filter falls through to
+ * `'unknown'` → ambiguity suppression → 0 CALLS edges. This is a
+ * "degrade not lie" gap (no wrong edges, just missing ones); extending
+ * the scan to `parameter_list` is tracked under #1579 as a follow-up.
  */
 function lookupDeclaredTypeForIdentifier(identNode) {
     const varName = identNode.text;

package/dist/core/ingestion/languages/cpp/constraint-extractor.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Extract C++ template constraint expressions for SFINAE-aware overload
+ * narrowing (issue #1579). Recognizes 3 AST shapes:
+ *
+ *   F1 — unqualified non-type template param default:
+ *        `template<class T, enable_if_t<P, int> = 0> void f(T);`
+ *   F2 — `std::`-qualified variant (canonical ticket form):
+ *        `template<class T, std::enable_if_t<P, int> = 0> void f(T);`
+ *   F4 — C++20 leading requires-clause:
+ *        `template<class T> requires P void f(T);`
+ *
+ * Deferred (return `{kind:'unknown'}`):
+ *   F3 — void-default `typename = enable_if_t<P>` (cppref labels this
+ *        `/* WRONG *\/` because adjacent overloads collapse to redeclarations)
+ *   F5 — trailing requires (`void f(T) requires P;`)
+ *   `requires_expression` blocks (`requires { typename T::U; }`)
+ *   `decltype(...)`, fold-expressions, user-defined `_v` aliases.
+ *
+ * The output payload is opaque to shared code — only
+ * `constraint-filter.ts` consumes it. See ISO `[temp.constr.normal]` /
+ * `<https://en.cppreference.com/w/cpp/language/constraints>` for the
+ * normalization the Kleene 3-valued evaluator implements.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+export type ConstraintExpr = {
+    readonly kind: 'atomic';
+    readonly name: string;
+    readonly args: readonly string[];
+} | {
+    readonly kind: 'and';
+    readonly children: readonly ConstraintExpr[];
+} | {
+    readonly kind: 'or';
+    readonly children: readonly ConstraintExpr[];
+} | {
+    readonly kind: 'not';
+    readonly child: ConstraintExpr;
+} | {
+    readonly kind: 'unknown';
+};
+export interface CppConstraintPayload {
+    /** Ordered template parameter names (type-params only — non-type defaults
+     *  carrying enable_if predicates are folded into `expr`). */
+    readonly templateParams: readonly string[];
+    /**
+     * Mapping from each template parameter name to the call-site argument
+     * index where its deduced type lives. Computed by scanning the function's
+     * parameter list for the first parameter whose type is the bare template
+     * parameter name (or template-typed by it). Missing entries → 'unknown'
+     * verdict at evaluation time.
+     */
+    readonly paramArgIndex: {
+        readonly [paramName: string]: number;
+    };
+    /** Root constraint expression. When multiple constraints (multiple
+     *  enable_if defaults, requires clause, etc.) are present they are
+     *  implicitly conjoined under a top-level `and` node. */
+    readonly expr: ConstraintExpr;
+}
+/**
+ * Walk a `template_declaration` AST node and extract its constraint
+ * payload. Caller is responsible for passing the OUTER `template_declaration`
+ * — for class-member template functions, that means the enclosing
+ * template_declaration of the class OR of the method, whichever
+ * directly precedes the function definition.
+ *
+ * Returns `undefined` when the template_declaration declares no
+ * constraints worth tracking (no enable_if default, no requires clause).
+ * Returns a payload whose `expr.kind === 'unknown'` when constraints are
+ * present but the extractor cannot model them — monotonicity guarantees
+ * the filter keeps the candidate in that case.
+ */
+export declare function extractCppTemplateConstraints(templateDecl: SyntaxNode, funcDeclarator: SyntaxNode | null): CppConstraintPayload | undefined;