gitnexus 1.6.6-rc.2 → 1.6.6-rc.21

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/languages/cpp/captures.js

@@ -3,7 +3,7 @@ import { getCppParser, getCppScopeQuery } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { splitCppInclude, splitCppUsingDecl } from './import-decomposer.js';
-import { computeCppDeclarationArity, computeCppCallArity } from './arity-metadata.js';
+import { classifyCppParameterType, computeCppDeclarationArity, computeCppCallArity, } from './arity-metadata.js';
 import { markCppAnonymousNamespaceRange, markFileLocal } from './file-local-linkage.js';
 import { markCppDependentBase } from './two-phase-lookup.js';
 import { markCppAdlSiteArgs, markCppAdlSiteNoAdl } from './adl.js';
@@ -159,6 +159,10 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
                 if (argTypes !== undefined && argTypes.length > 0) {
                     grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', cNode, JSON.stringify(argTypes));
                 }
+                const argTypeClasses = inferCppCallArgTypeClasses(cNode);
+                if (argTypeClasses !== undefined && argTypeClasses.length > 0) {
+                    grouped['@reference.parameter-type-classes'] = syntheticCapture('@reference.parameter-type-classes', cNode, JSON.stringify(argTypeClasses));
+                }
             }
         }
         // ── Inline namespace detection ──────────────────────────────────
@@ -612,6 +616,36 @@ function inferCppCallArgTypes(node) {
     }
     return types.length > 0 ? types : undefined;
 }
+function inferCppCallArgTypeClasses(node) {
+    const argList = node.childForFieldName('arguments');
+    if (argList === null)
+        return undefined;
+    const classes = [];
+    for (let i = 0; i < argList.childCount; i++) {
+        const child = argList.child(i);
+        if (child === null)
+            continue;
+        if (child.type === ',' || child.type === '(' || child.type === ')')
+            continue;
+        const litType = inferCppLiteralType(child);
+        if (litType !== '') {
+            classes.push(valueTypeClass(litType));
+        }
+        else if (child.type === 'identifier') {
+            classes.push(lookupDeclaredTypeClassForIdentifier(child));
+        }
+        else {
+            classes.push(unknownTypeClass('unknown'));
+        }
+    }
+    return classes.length > 0 ? classes : undefined;
+}
+function valueTypeClass(base) {
+    return { base, cv: 'none', indirection: 'value', pointerDepth: 0 };
+}
+function unknownTypeClass(base) {
+    return { base, cv: 'unknown', indirection: 'unknown', pointerDepth: 0 };
+}
 /**
  * Infer the canonical type name of a C++ literal AST node.
  * Returns empty string for non-literal / unknown nodes.
@@ -674,6 +708,9 @@ function lookupDeclaredTypeForIdentifier(identNode) {
     }
     if (scope === null)
         return '';
+    const paramType = lookupFunctionParameterType(scope, varName);
+    if (paramType !== '')
+        return paramType;
     // Scan declarations in the scope for a matching variable name
     for (let i = 0; i < scope.childCount; i++) {
         const stmt = scope.child(i);
@@ -689,18 +726,113 @@ function lookupDeclaredTypeForIdentifier(identNode) {
         const declarator = stmt.childForFieldName('declarator');
         if (declarator === null)
             continue;
-        if (declarator.type === 'init_declarator') {
-            const nameChild = declarator.childForFieldName('declarator');
-            if (nameChild !== null && nameChild.text === varName) {
-                return normalizeCppTypeText(typeNode.text);
-            }
-        }
-        else if (declarator.text === varName) {
+        const nameChild = declaredNameNode(declarator);
+        if (nameChild !== null && extractDeclaratorLeafName(nameChild) === varName) {
             return normalizeCppTypeText(typeNode.text);
         }
     }
     return '';
 }
+function lookupDeclaredTypeClassForIdentifier(identNode) {
+    const varName = identNode.text;
+    let scope = identNode.parent;
+    while (scope !== null &&
+        scope.type !== 'compound_statement' &&
+        scope.type !== 'translation_unit') {
+        scope = scope.parent;
+    }
+    if (scope === null)
+        return unknownTypeClass('unknown');
+    const paramTypeClass = lookupFunctionParameterTypeClass(scope, varName, identNode);
+    if (paramTypeClass !== undefined)
+        return paramTypeClass;
+    for (let i = 0; i < scope.childCount; i++) {
+        const stmt = scope.child(i);
+        if (stmt === null || stmt.type !== 'declaration')
+            continue;
+        const typeNode = stmt.childForFieldName('type');
+        if (typeNode === null)
+            continue;
+        if (typeNode.type === 'placeholder_type_specifier')
+            continue;
+        const declarator = stmt.childForFieldName('declarator');
+        if (declarator === null)
+            continue;
+        const nameChild = declaredNameNode(declarator);
+        if (nameChild === null || extractDeclaratorLeafName(nameChild) !== varName)
+            continue;
+        const typeClass = classifyCppParameterType(typeNode.text, nameChild.text, stmt.text.replace(/;\s*$/, ''));
+        if (isKnownEnumName(identNode, typeClass.base)) {
+            return { ...typeClass, base: `enum:${typeClass.base}` };
+        }
+        return typeClass;
+    }
+    return unknownTypeClass('unknown');
+}
+function lookupFunctionParameterType(scope, varName) {
+    const param = findEnclosingFunctionParameter(scope, varName);
+    if (param === null)
+        return '';
+    const typeNode = param.childForFieldName('type');
+    if (typeNode === null)
+        return '';
+    return normalizeCppTypeText(typeNode.text);
+}
+function lookupFunctionParameterTypeClass(scope, varName, identNode) {
+    const param = findEnclosingFunctionParameter(scope, varName);
+    if (param === null)
+        return undefined;
+    const typeNode = param.childForFieldName('type');
+    if (typeNode === null)
+        return undefined;
+    const declarator = param.childForFieldName('declarator');
+    if (declarator === null)
+        return undefined;
+    const typeClass = classifyCppParameterType(typeNode.text, declarator.text, param.text);
+    if (isKnownEnumName(identNode, typeClass.base)) {
+        return { ...typeClass, base: `enum:${typeClass.base}` };
+    }
+    return typeClass;
+}
+function findEnclosingFunctionParameter(scope, varName) {
+    let node = scope.parent;
+    while (node !== null) {
+        if (node.type === 'function_definition' || node.type === 'function_declarator') {
+            const fnDecl = node.type === 'function_declarator'
+                ? node
+                : findFirstDescendantOfType(node, 'function_declarator');
+            const params = fnDecl?.childForFieldName('parameters') ?? null;
+            if (params !== null) {
+                for (let i = 0; i < params.namedChildCount; i++) {
+                    const param = params.namedChild(i);
+                    if (param === null || param.type !== 'parameter_declaration')
+                        continue;
+                    const declarator = param.childForFieldName('declarator');
+                    if (declarator !== null && extractDeclaratorLeafName(declarator) === varName) {
+                        return param;
+                    }
+                }
+            }
+            return null;
+        }
+        node = node.parent;
+    }
+    return null;
+}
+function declaredNameNode(declarator) {
+    if (declarator.type !== 'init_declarator')
+        return declarator;
+    for (let i = 0; i < declarator.namedChildCount; i++) {
+        const child = declarator.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'identifier')
+            return child;
+        if (child.type.endsWith('_declarator'))
+            return child;
+    }
+    return declarator.childForFieldName('declarator');
+}
 /** Normalize a type-specifier text for argument type matching.
  *  Strips qualifiers (const, volatile), namespace prefixes (std::),
  *  and pointer/reference markers. */
@@ -711,6 +843,28 @@ function normalizeCppTypeText(text) {
     t = t.replace(/[*&]/g, '').trim();
     return t;
 }
+function isKnownEnumName(node, typeName) {
+    if (typeName === '' || typeName === 'unknown')
+        return false;
+    let root = node;
+    while (root.parent !== null)
+        root = root.parent;
+    const stack = [root];
+    while (stack.length > 0) {
+        const cur = stack.pop();
+        if (cur.type === 'enum_specifier') {
+            const name = cur.childForFieldName('name');
+            if (name?.text === typeName)
+                return true;
+        }
+        for (let i = 0; i < cur.childCount; i++) {
+            const child = cur.child(i);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+    return false;
+}
 /**
  * Detect whether a `namespace_definition` AST node is inline.
  * Tree-sitter-cpp exposes the `inline` keyword as an anonymous child
@@ -1166,7 +1320,9 @@ function extractDeclaratorLeafName(node) {
         // Common wrapper nodes — follow the 'declarator' field when present.
         const next = cur.childForFieldName('declarator') ??
             // parenthesized_declarator: single named child
-            (cur.type === 'parenthesized_declarator' ? cur.namedChild(0) : null);
+            (cur.type === 'parenthesized_declarator' || cur.type.endsWith('_declarator')
+                ? cur.namedChild(0)
+                : null);
         if (next === null)
             return null;
         cur = next;

package/dist/core/ingestion/languages/cpp/constraint-filter.js

@@ -21,13 +21,9 @@
  */
 import { classifyType } from './type-classifier.js';
 /**
- * Curated Tier-A predicate registry — the four canonical
- * `<type_traits>` variable templates whose truth tables are closed-form
- * over our coarse `TypeClass` enum.
- *
- * Deferred predicates that need a cv/ref/pointer sidecar on
- * `normalizeCppParamType` (today the normalizer strips those markers
- * before storage) live in #1579 as one-line follow-up adds.
+ * Curated Tier-A predicate registry. Predicates that depend on pointer,
+ * reference, or cv shape consult `ConstraintContext.argumentTypeClasses`.
+ * Missing or unsupported shape returns 'unknown' to preserve monotonicity.
  */
 // ISO `<type_traits>` treats `bool`, `char`, and the signed/unsigned char
 // variants as integral types (§21.3.4 Table 48), so `is_integral_v<bool>`
@@ -39,40 +35,117 @@ function isIntegralClass(c) {
     return c === 'integral' || c === 'bool' || c === 'char';
 }
 const REGISTRY = new Map([
-    ['is_integral_v', (cls) => verdictFromBool(isIntegralClass(cls[0]), cls)],
-    ['is_floating_point_v', (cls) => verdictFromBool(cls[0] === 'floating', cls)],
+    [
+        'is_void_v',
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && arg.typeClass === 'void'),
+    ],
+    [
+        'is_integral_v',
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && isIntegralClass(arg.typeClass)),
+    ],
+    [
+        'is_floating_point_v',
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && arg.typeClass === 'floating'),
+    ],
     [
         'is_arithmetic_v',
-        (cls) => verdictFromBool(isIntegralClass(cls[0]) || cls[0] === 'floating', cls),
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && (isIntegralClass(arg.typeClass) || arg.typeClass === 'floating')),
+    ],
+    [
+        'is_enum_v',
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && arg.typeClass === 'enum'),
+    ],
+    [
+        'is_class_v',
+        (args) => unaryVerdict(args, (arg) => isPlainValue(arg) && arg.typeClass === 'class'),
+    ],
+    [
+        'is_pointer_v',
+        (args) => unaryShapeVerdict(args, (shape) => shape.indirection === 'pointer' && shape.pointerDepth > 0),
+    ],
+    [
+        'is_reference_v',
+        (args) => unaryShapeVerdict(args, (shape) => shape.indirection === 'lvalue-ref' || shape.indirection === 'rvalue-ref'),
+    ],
+    [
+        'is_const_v',
+        (args) => unaryShapeVerdict(args, (shape) => shape.cv === 'const' || shape.cv === 'const volatile', {
+            requireTopLevelCv: true,
+        }),
+    ],
+    [
+        'is_volatile_v',
+        (args) => unaryShapeVerdict(args, (shape) => shape.cv === 'volatile' || shape.cv === 'const volatile', {
+            requireTopLevelCv: true,
+        }),
     ],
-    // NOTE: cv-qualifiers are stripped by `normalizeCppParamType` before the
-    // type token reaches `classifyType`, so `is_same_v<const T, T>` returns
-    // `'compatible'` instead of the ISO-correct `false`. Tracked under the
-    // cv-sidecar refactor in #1579's "Out of scope" list; until that lands
-    // this approximation matches the common `is_same_v<T, ConcreteType>`
-    // dispatch idiom and silently degrades on cv-distinct compares.
     [
         'is_same_v',
-        (cls) => {
-            if (cls.length < 2 || cls[0] === 'unknown' || cls[1] === 'unknown')
+        (args) => {
+            if (args.length < 2 || args[0].typeClass === 'unknown' || args[1].typeClass === 'unknown') {
                 return 'unknown';
-            return cls[0] === cls[1] ? 'compatible' : 'incompatible';
+            }
+            return args[0].typeClass === args[1].typeClass ? 'compatible' : 'incompatible';
         },
     ],
 ]);
-function verdictFromBool(predicate, cls) {
-    if (cls[0] === 'unknown')
+function unaryVerdict(args, predicate) {
+    const arg = args[0];
+    if (arg === undefined || arg.typeClass === 'unknown')
         return 'unknown';
-    return predicate ? 'compatible' : 'incompatible';
+    return predicate(arg) ? 'compatible' : 'incompatible';
+}
+function unaryShapeVerdict(args, predicate, options = {}) {
+    const arg = args[0];
+    if (arg === undefined || arg.typeClass === 'unknown')
+        return 'unknown';
+    const shape = arg.shape;
+    if (shape === undefined || shape.indirection === 'unknown' || shape.cv === 'unknown') {
+        return 'unknown';
+    }
+    if (options.requireTopLevelCv === true && shape.indirection === 'pointer') {
+        return 'unknown';
+    }
+    return predicate(shape) ? 'compatible' : 'incompatible';
+}
+function isPlainValue(arg) {
+    const shape = arg.shape;
+    if (shape === undefined)
+        return true;
+    return shape.indirection === 'value';
+}
+function classifyConstraintArg(token, shape) {
+    if (shape !== undefined && shape.base.startsWith('enum:')) {
+        return { typeClass: 'enum', shape };
+    }
+    const typeClass = token === undefined || token === '' ? 'unknown' : classifyType(token);
+    return { typeClass, ...(shape !== undefined ? { shape } : {}) };
+}
+function tokenForArg(ctx, argIdx) {
+    const shape = ctx.argumentTypeClasses?.[argIdx];
+    if (shape?.base.startsWith('enum:'))
+        return shape.base;
+    return ctx.argumentTypes?.[argIdx];
+}
+function shapeForTemplateParam(ctx, paramName, argIdx, def) {
+    const argShape = ctx.argumentTypeClasses?.[argIdx];
+    if (argShape === undefined)
+        return undefined;
+    const paramShape = def?.parameterTypeClasses?.[argIdx];
+    if (paramShape === undefined)
+        return argShape;
+    if (paramShape.base === paramName && paramShape.indirection === 'value')
+        return argShape;
+    return undefined;
 }
 /** Public surface — registered as `ScopeResolver.constraintCompatibility`. */
 export function cppConstraintCompatibility(_callsite, def, ctx) {
     const payload = def.templateConstraints;
     if (payload === undefined)
         return 'unknown';
-    return evaluate(payload.expr, payload, ctx);
+    return evaluate(payload.expr, payload, ctx, def);
 }
-function evaluate(expr, payload, ctx) {
+function evaluate(expr, payload, ctx, def) {
     switch (expr.kind) {
         case 'unknown':
             return 'unknown';
@@ -83,18 +156,15 @@ function evaluate(expr, payload, ctx) {
             const classes = expr.args.map((paramName) => {
                 const argIdx = payload.paramArgIndex[paramName];
                 if (argIdx === undefined)
-                    return 'unknown';
-                const token = ctx.argumentTypes?.[argIdx];
-                if (token === undefined || token === '')
-                    return 'unknown';
-                return classifyType(token);
+                    return { typeClass: 'unknown' };
+                return classifyConstraintArg(tokenForArg(ctx, argIdx), shapeForTemplateParam(ctx, paramName, argIdx, def));
             });
             return evaluator(classes);
         }
         case 'and': {
             let result = 'compatible';
             for (const child of expr.children) {
-                const v = evaluate(child, payload, ctx);
+                const v = evaluate(child, payload, ctx, def);
                 if (v === 'incompatible')
                     return 'incompatible';
                 if (v === 'unknown')
@@ -105,7 +175,7 @@ function evaluate(expr, payload, ctx) {
         case 'or': {
             let result = 'incompatible';
             for (const child of expr.children) {
-                const v = evaluate(child, payload, ctx);
+                const v = evaluate(child, payload, ctx, def);
                 if (v === 'compatible')
                     return 'compatible';
                 if (v === 'unknown')
@@ -114,7 +184,7 @@ function evaluate(expr, payload, ctx) {
             return result;
         }
         case 'not': {
-            const v = evaluate(expr.child, payload, ctx);
+            const v = evaluate(expr.child, payload, ctx, def);
             if (v === 'compatible')
                 return 'incompatible';
             if (v === 'incompatible')

package/dist/core/ingestion/languages/cpp/type-classifier.d.ts

@@ -7,20 +7,20 @@
  * the call-site inference in `captures.ts`) to one of the categories
  * the `<type_traits>` predicate registry uses for SFINAE filtering.
  *
- * Intentionally coarse: cv / pointer / reference qualifiers are stripped
- * upstream by `normalizeCppParamType`. Tier-A predicates
- * (`is_integral_v`, `is_floating_point_v`, `is_arithmetic_v`, `is_same_v`)
- * are insensitive to those modifiers per ISO `<type_traits>` semantics
- * ("including any cv-qualified variants").
+ * `argumentTypes` remain normalized for overload narrowing, while
+ * constraint predicates that need cv/ref/pointer shape read the parallel
+ * `argumentTypeClasses` sidecar. Unknown shapes must stay unknown rather
+ * than being guessed as incompatible.
  */
-export type TypeClass = 'integral' | 'floating' | 'bool' | 'char' | 'string' | 'null' | 'class' | 'unknown';
+export type TypeClass = 'integral' | 'floating' | 'bool' | 'char' | 'string' | 'null' | 'void' | 'enum' | 'class' | 'pointer' | 'reference' | 'unknown';
 /**
  * Classify a normalized C++ type token. The mapping mirrors the literal-
  * inference table in `captures.ts:inferCppLiteralType` plus the std::
  * normalization in `arity-metadata.ts:normalizeCppParamType`.
  *
- * Caller note: token must already be normalized (no `const`, no `&` / `*`,
- * no `std::` prefix). Tokens passed via `ConstraintContext.argumentTypes`
- * coming from `inferCppCallArgTypes` satisfy this.
+ * Caller note: token should be normalized for overload matching. Enum
+ * tokens produced by the C++ adapter use the internal `enum:<Name>`
+ * prefix so `is_enum_v` does not have to guess that every user token is
+ * class-like.
  */
 export declare function classifyType(token: string): TypeClass;

package/dist/core/ingestion/languages/cpp/type-classifier.js

@@ -7,25 +7,29 @@
  * the call-site inference in `captures.ts`) to one of the categories
  * the `<type_traits>` predicate registry uses for SFINAE filtering.
  *
- * Intentionally coarse: cv / pointer / reference qualifiers are stripped
- * upstream by `normalizeCppParamType`. Tier-A predicates
- * (`is_integral_v`, `is_floating_point_v`, `is_arithmetic_v`, `is_same_v`)
- * are insensitive to those modifiers per ISO `<type_traits>` semantics
- * ("including any cv-qualified variants").
+ * `argumentTypes` remain normalized for overload narrowing, while
+ * constraint predicates that need cv/ref/pointer shape read the parallel
+ * `argumentTypeClasses` sidecar. Unknown shapes must stay unknown rather
+ * than being guessed as incompatible.
  */
 /**
  * Classify a normalized C++ type token. The mapping mirrors the literal-
  * inference table in `captures.ts:inferCppLiteralType` plus the std::
  * normalization in `arity-metadata.ts:normalizeCppParamType`.
  *
- * Caller note: token must already be normalized (no `const`, no `&` / `*`,
- * no `std::` prefix). Tokens passed via `ConstraintContext.argumentTypes`
- * coming from `inferCppCallArgTypes` satisfy this.
+ * Caller note: token should be normalized for overload matching. Enum
+ * tokens produced by the C++ adapter use the internal `enum:<Name>`
+ * prefix so `is_enum_v` does not have to guess that every user token is
+ * class-like.
  */
 export function classifyType(token) {
     if (token.length === 0)
         return 'unknown';
+    if (token.startsWith('enum:'))
+        return 'enum';
     switch (token) {
+        case 'void':
+            return 'void';
         case 'int':
             return 'integral';
         case 'double':

package/dist/core/ingestion/languages/java.js

@@ -26,6 +26,40 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { javaVariableConfig } from '../variable-extractors/configs/jvm.js';
 import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 import { emitJavaScopeCaptures, interpretJavaImport, interpretJavaTypeBinding, javaBindingScopeFor, javaImportOwningScope, javaMergeBindings, javaReceiverBinding, javaArityCompatibility, resolveJavaImportTarget, } from './java/index.js';
+const orderJavaSameNameTypeCandidates = ({ callSiteFilePath, candidates, }) => {
+    if (!callSiteFilePath.endsWith('.java'))
+        return null;
+    if (candidates.length <= 1)
+        return null;
+    const callerDir = splitDirectorySegments(callSiteFilePath);
+    const scored = candidates.map((candidate, index) => ({
+        candidate,
+        index,
+        score: sharedPrefixLength(callerDir, splitDirectorySegments(candidate.filePath)),
+    }));
+    const bestScore = Math.max(...scored.map((entry) => entry.score));
+    // When all candidates tie, we have no structural signal to prefer one path.
+    // Returning null keeps downstream ambiguity handling conservative.
+    if (scored.every((entry) => entry.score === bestScore))
+        return null;
+    const ordered = [...scored]
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .map((entry) => entry.candidate);
+    return ordered;
+};
+const splitDirectorySegments = (filePath) => {
+    const normalized = filePath.replace(/\\/g, '/');
+    // Remove empty segments from leading/trailing/multiple slashes, then drop filename.
+    const segments = normalized.split('/').filter(Boolean);
+    return segments.slice(0, -1);
+};
+const sharedPrefixLength = (left, right) => {
+    const max = Math.min(left.length, right.length);
+    let idx = 0;
+    while (idx < max && left[idx] === right[idx])
+        idx += 1;
+    return idx;
+};
 export const javaProvider = defineLanguage({
     id: SupportedLanguages.Java,
     extensions: ['.java'],
@@ -73,4 +107,5 @@ export const javaProvider = defineLanguage({
     receiverBinding: javaReceiverBinding,
     arityCompatibility: javaArityCompatibility,
     resolveImportTarget: resolveJavaImportTarget,
+    orderSameNameTypeCandidates: orderJavaSameNameTypeCandidates,
 });

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

@@ -0,0 +1,11 @@
+/**
+ * Arity compatibility for JavaScript.
+ *
+ * Delegates to `typescriptArityCompatibility` unchanged — JavaScript
+ * supports the same arity constructs (rest parameters `...args`, default
+ * parameters `p = v`) and the metadata shape (`parameterCount`,
+ * `requiredParameterCount`, `parameterTypes`) is synthesized by the same
+ * `computeTsArityMetadata` function (which understands both TS and JS
+ * parameter node types via `extractTsJsParameters`).
+ */
+export { typescriptArityCompatibility as jsArityCompatibility } from '../typescript/arity.js';

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

@@ -0,0 +1,11 @@
+/**
+ * Arity compatibility for JavaScript.
+ *
+ * Delegates to `typescriptArityCompatibility` unchanged — JavaScript
+ * supports the same arity constructs (rest parameters `...args`, default
+ * parameters `p = v`) and the metadata shape (`parameterCount`,
+ * `requiredParameterCount`, `parameterTypes`) is synthesized by the same
+ * `computeTsArityMetadata` function (which understands both TS and JS
+ * parameter node types via `extractTsJsParameters`).
+ */
+export { typescriptArityCompatibility as jsArityCompatibility } from '../typescript/arity.js';

package/dist/core/ingestion/languages/javascript/captures.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `emitScopeCaptures` for JavaScript.
+ *
+ * Adapts `emitTsScopeCaptures` for the JavaScript grammar:
+ *
+ *   1. **JS grammar** — uses `tree-sitter-javascript` instead of
+ *      `tree-sitter-typescript`. The JS scope query is a subset of the
+ *      TypeScript one (TypeScript-only node types dropped).
+ *
+ *   2. **CJS `require()` decomposition** — `const { X } = require('./m')`
+ *      and `const X = require('./m')` are walked in a post-query pass and
+ *      synthesized as `@import.kind/name/alias/source` markers so that
+ *      `interpretJsImport` can recover a `ParsedImport` using the same
+ *      shape as the TypeScript ESM decomposer.
+ *
+ *   3. **JSDoc type bindings** — JavaScript has no static type annotations
+ *      so `@type-binding.parameter` / `@type-binding.return` must be
+ *      inferred from leading JSDoc comments. A lightweight regex scanner
+ *      (`parseJsDocParams` / `parseJsDocReturn`) extracts `@param {T} n`
+ *      and `@returns {T}` tags and emits synthetic captures positioned on
+ *      the annotated function node.
+ *
+ *   4. **Shared synthesis passes** — destructuring, for-of map-tuple, and
+ *      instanceof narrowing passes are duplicated from `typescript/captures.ts`
+ *      (they are pure AST operations with no grammar-specific logic).
+ *
+ * Pure given the input source text. No I/O, no globals consulted.
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitJsScopeCaptures(sourceText: string, filePath: string, cachedTree?: unknown): readonly CaptureMatch[];