gitnexus 1.6.6-rc.27 → 1.6.6-rc.28

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

@@ -0,0 +1,7 @@
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+export interface KotlinArityMetadata {
+    readonly parameterCount: number | undefined;
+    readonly requiredParameterCount: number | undefined;
+    readonly parameterTypes: readonly string[] | undefined;
+}
+export declare function computeKotlinArityMetadata(fnNode: SyntaxNode): KotlinArityMetadata;

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

@@ -0,0 +1,20 @@
+import { kotlinMethodConfig } from '../../method-extractors/configs/jvm.js';
+export function computeKotlinArityMetadata(fnNode) {
+    const params = kotlinMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasVararg = false;
+    const parameterTypes = [];
+    for (const param of params) {
+        if (param.isVariadic)
+            hasVararg = true;
+        if (param.type !== null)
+            parameterTypes.push(param.type);
+    }
+    if (hasVararg)
+        parameterTypes.push('vararg');
+    const required = params.filter((p) => !p.isOptional && !p.isVariadic).length;
+    return {
+        parameterCount: hasVararg ? undefined : params.length,
+        requiredParameterCount: required,
+        parameterTypes: parameterTypes.length > 0 ? parameterTypes : undefined,
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
+export declare function kotlinArityCompatibility(def: SymbolDefinition, callsite: Callsite): 'compatible' | 'unknown' | 'incompatible';

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

@@ -0,0 +1,15 @@
+export function kotlinArityCompatibility(def, callsite) {
+    const min = def.requiredParameterCount;
+    const max = def.parameterCount;
+    if (min === undefined && max === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    const hasVararg = def.parameterTypes?.some((t) => t === 'vararg') ?? false;
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasVararg)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/ingestion/languages/kotlin/cache-stats.d.ts

@@ -0,0 +1,7 @@
+export declare function recordKotlinCacheHit(): void;
+export declare function recordKotlinCacheMiss(): void;
+export declare function getKotlinCaptureCacheStats(): {
+    readonly hits: number;
+    readonly misses: number;
+};
+export declare function resetKotlinCaptureCacheStats(): void;

package/dist/core/ingestion/languages/kotlin/cache-stats.js

@@ -0,0 +1,15 @@
+let hits = 0;
+let misses = 0;
+export function recordKotlinCacheHit() {
+    hits += 1;
+}
+export function recordKotlinCacheMiss() {
+    misses += 1;
+}
+export function getKotlinCaptureCacheStats() {
+    return { hits, misses };
+}
+export function resetKotlinCaptureCacheStats() {
+    hits = 0;
+    misses = 0;
+}

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

@@ -0,0 +1,2 @@
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitKotlinScopeCaptures(sourceText: string, _filePath: string, cachedTree?: unknown): readonly CaptureMatch[];

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

@@ -0,0 +1,376 @@
+import { findNodeAtRange, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { computeKotlinArityMetadata } from './arity-metadata.js';
+import { splitKotlinImportHeader } from './import-decomposer.js';
+import { recordKotlinCacheHit, recordKotlinCacheMiss } from './cache-stats.js';
+import { normalizeKotlinType } from './interpret.js';
+import { synthesizeKotlinReceiverBinding } from './receiver-binding.js';
+import { getKotlinParser, getKotlinScopeQuery } from './query.js';
+const FUNCTION_DECL_TAGS = ['@declaration.function'];
+export function emitKotlinScopeCaptures(sourceText, _filePath, cachedTree) {
+    let tree = cachedTree;
+    if (tree === undefined) {
+        tree = parseSourceSafe(getKotlinParser(), sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
+        recordKotlinCacheMiss();
+    }
+    else {
+        recordKotlinCacheHit();
+    }
+    const out = [];
+    const returnTypes = collectKotlinReturnTypeTexts(tree.rootNode);
+    out.push(...synthesizeKotlinLocalAssignmentBindings(tree.rootNode, returnTypes));
+    out.push(...synthesizeKotlinLoopBindings(tree.rootNode, returnTypes));
+    for (const match of getKotlinScopeQuery().matches(tree.rootNode)) {
+        const grouped = {};
+        for (const capture of match.captures) {
+            const tag = '@' + capture.name;
+            grouped[tag] = nodeToCapture(tag, capture.node);
+        }
+        if (Object.keys(grouped).length === 0)
+            continue;
+        if (grouped['@import.statement'] !== undefined) {
+            const importNode = findNodeAtRange(tree.rootNode, grouped['@import.statement'].range, 'import_header');
+            if (importNode !== null) {
+                const decomposed = splitKotlinImportHeader(importNode);
+                if (decomposed !== null) {
+                    out.push(decomposed);
+                    continue;
+                }
+            }
+        }
+        if (grouped['@reference.call.free'] !== undefined &&
+            grouped['@reference.receiver'] !== undefined) {
+            continue;
+        }
+        if (grouped['@reference.read.member'] !== undefined) {
+            const anchor = grouped['@reference.read.member'];
+            const navNode = findNodeAtRange(tree.rootNode, anchor.range, 'navigation_expression');
+            if (navNode === null || !shouldEmitReadMember(navNode))
+                continue;
+        }
+        if (grouped['@scope.function'] !== undefined) {
+            out.push(grouped);
+            const fnNode = findNodeAtRange(tree.rootNode, grouped['@scope.function'].range, 'function_declaration');
+            if (fnNode !== null) {
+                out.push(...synthesizeKotlinReceiverBinding(fnNode));
+            }
+            continue;
+        }
+        const declTag = FUNCTION_DECL_TAGS.find((tag) => grouped[tag] !== undefined);
+        if (declTag !== undefined) {
+            const fnNode = findNodeAtRange(tree.rootNode, grouped[declTag].range, 'function_declaration');
+            if (fnNode !== null) {
+                const arity = computeKotlinArityMetadata(fnNode);
+                if (arity.parameterCount !== undefined) {
+                    grouped['@declaration.parameter-count'] = syntheticCapture('@declaration.parameter-count', fnNode, String(arity.parameterCount));
+                }
+                if (arity.requiredParameterCount !== undefined) {
+                    grouped['@declaration.required-parameter-count'] = syntheticCapture('@declaration.required-parameter-count', fnNode, String(arity.requiredParameterCount));
+                }
+                if (arity.parameterTypes !== undefined) {
+                    grouped['@declaration.parameter-types'] = syntheticCapture('@declaration.parameter-types', fnNode, JSON.stringify(arity.parameterTypes));
+                }
+            }
+        }
+        const callTag = ['@reference.call.free', '@reference.call.member', '@reference.call.constructor'].find((tag) => grouped[tag] !== undefined);
+        if (callTag !== undefined && grouped['@reference.arity'] === undefined) {
+            const callNode = findNodeAtRange(tree.rootNode, grouped[callTag].range, 'call_expression');
+            if (callNode !== null) {
+                const args = callArguments(callNode);
+                grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(args.length));
+                grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', callNode, JSON.stringify(args.map(inferArgType)));
+            }
+        }
+        out.push(grouped);
+        const extensionFallback = extensionFreeCallFallback(grouped, tree.rootNode);
+        if (extensionFallback !== null)
+            out.push(extensionFallback);
+    }
+    return out;
+}
+function synthesizeKotlinLoopBindings(rootNode, returnTypes) {
+    const out = [];
+    for (const fnNode of descendantsOfType(rootNode, 'function_declaration')) {
+        const localTypes = collectKotlinLocalTypeTexts(fnNode, returnTypes);
+        for (const forNode of descendantsOfType(fnNode, 'for_statement')) {
+            const variable = forNode.namedChildren.find((child) => child.type === 'variable_declaration');
+            const name = variable?.namedChildren.find((child) => child.type === 'simple_identifier');
+            if (variable === undefined || name === undefined)
+                continue;
+            const explicitType = variable.namedChildren.find((child) => isKotlinTypeNode(child));
+            const iterable = forNode.namedChildren.find((child) => child.id !== variable.id && child.type !== 'control_structure_body');
+            const rawType = explicitType?.text ??
+                (iterable === undefined
+                    ? null
+                    : inferKotlinIterableElementType(iterable, localTypes, returnTypes));
+            if (rawType === null || rawType.trim() === '')
+                continue;
+            const anchor = forNode.namedChildren.find((child) => child.type === 'control_structure_body') ?? forNode;
+            out.push({
+                '@type-binding.annotation': nodeToCapture('@type-binding.annotation', anchor),
+                '@type-binding.name': syntheticCapture('@type-binding.name', name, name.text),
+                '@type-binding.type': syntheticCapture('@type-binding.type', explicitType ?? iterable ?? name, normalizeKotlinType(rawType)),
+            });
+        }
+    }
+    return out;
+}
+function synthesizeKotlinLocalAssignmentBindings(rootNode, returnTypes) {
+    const out = [];
+    for (const fnNode of descendantsOfType(rootNode, 'function_declaration')) {
+        const localTypes = new Map();
+        for (const prop of descendantsOfType(fnNode, 'property_declaration')) {
+            const inferred = inferKotlinPropertyType(prop, localTypes, returnTypes);
+            if (inferred === null)
+                continue;
+            localTypes.set(inferred.name.text, inferred.rawType);
+            if (inferred.synthetic) {
+                out.push({
+                    '@type-binding.annotation': nodeToCapture('@type-binding.annotation', prop),
+                    '@type-binding.name': syntheticCapture('@type-binding.name', inferred.name, inferred.name.text),
+                    '@type-binding.type': syntheticCapture('@type-binding.type', inferred.source, normalizeKotlinType(inferred.rawType)),
+                });
+            }
+        }
+    }
+    return out;
+}
+function collectKotlinLocalTypeTexts(fnNode, returnTypes) {
+    const out = new Map();
+    for (const node of descendants(fnNode)) {
+        if (node.type === 'parameter') {
+            const name = descendantsOfType(node, 'simple_identifier')[0];
+            const type = node.namedChildren.find((child) => isKotlinTypeNode(child));
+            if (name !== undefined && type !== undefined)
+                out.set(name.text, type.text);
+            continue;
+        }
+        if (node.type === 'property_declaration') {
+            const inferred = inferKotlinPropertyType(node, out, returnTypes);
+            if (inferred !== null)
+                out.set(inferred.name.text, inferred.rawType);
+        }
+    }
+    return out;
+}
+function collectKotlinReturnTypeTexts(rootNode) {
+    const out = new Map();
+    for (const fnNode of descendantsOfType(rootNode, 'function_declaration')) {
+        const name = fnNode.namedChildren.find((child) => child.type === 'simple_identifier');
+        const paramsIndex = fnNode.namedChildren.findIndex((child) => child.type === 'function_value_parameters');
+        const type = paramsIndex < 0
+            ? undefined
+            : fnNode.namedChildren.slice(paramsIndex + 1).find((child) => isKotlinTypeNode(child));
+        if (name !== undefined && type !== undefined)
+            out.set(name.text, type.text);
+    }
+    return out;
+}
+function inferKotlinPropertyType(prop, localTypes, returnTypes) {
+    const variable = prop.namedChildren.find((child) => child.type === 'variable_declaration');
+    const name = variable?.namedChildren.find((child) => child.type === 'simple_identifier');
+    if (variable === undefined || name === undefined)
+        return null;
+    const explicitType = variable.namedChildren.find((child) => isKotlinTypeNode(child));
+    if (explicitType !== undefined) {
+        return { name, rawType: explicitType.text, source: explicitType, synthetic: false };
+    }
+    const value = prop.namedChildren.find((child) => child.id !== variable.id && child.type !== 'binding_pattern_kind');
+    if (value?.type === 'simple_identifier') {
+        const rawType = localTypes.get(value.text);
+        return rawType === undefined ? null : { name, rawType, source: value, synthetic: true };
+    }
+    if (value?.type === 'call_expression') {
+        const callee = value.namedChildren.find((child) => child.type === 'simple_identifier');
+        if (callee === undefined)
+            return null;
+        const rawType = returnTypes.get(callee.text) ?? (isUppercaseName(callee.text) ? callee.text : null);
+        if (rawType === null)
+            return null;
+        return { name, rawType, source: callee, synthetic: true };
+    }
+    return null;
+}
+function inferKotlinIterableElementType(iterable, localTypes, returnTypes) {
+    if (iterable.type === 'simple_identifier') {
+        const raw = localTypes.get(iterable.text);
+        return raw === undefined ? null : kotlinContainerElementType(raw, 'values');
+    }
+    if (iterable.type === 'navigation_expression') {
+        const receiver = iterable.namedChildren[0];
+        const member = iterable.namedChildren
+            .find((child) => child.type === 'navigation_suffix')
+            ?.namedChildren.find((child) => child.type === 'simple_identifier')?.text;
+        if (receiver?.type !== 'simple_identifier')
+            return null;
+        const raw = localTypes.get(receiver.text);
+        return raw === undefined ? null : kotlinContainerElementType(raw, member ?? 'values');
+    }
+    if (iterable.type === 'call_expression') {
+        const callee = iterable.namedChildren.find((child) => child.type === 'simple_identifier');
+        if (callee === undefined)
+            return null;
+        const raw = returnTypes.get(callee.text);
+        return raw === undefined ? null : kotlinContainerElementType(raw, 'values');
+    }
+    return null;
+}
+function isUppercaseName(text) {
+    return /^[A-Z]/.test(text);
+}
+function kotlinContainerElementType(rawType, member) {
+    const parsed = parseKotlinGeneric(rawType);
+    if (parsed === null)
+        return normalizeKotlinType(rawType);
+    const base = parsed.base.split('.').pop() ?? parsed.base;
+    if (isKotlinMapType(base)) {
+        if (member === 'keys')
+            return parsed.args[0] ?? null;
+        return parsed.args[1] ?? null;
+    }
+    if (isKotlinIterableType(base))
+        return parsed.args[0] ?? null;
+    return normalizeKotlinType(rawType);
+}
+function parseKotlinGeneric(text) {
+    const trimmed = text.trim().replace(/\?$/, '');
+    const open = trimmed.indexOf('<');
+    const close = trimmed.lastIndexOf('>');
+    if (open < 0 || close < open)
+        return null;
+    return {
+        base: trimmed.slice(0, open).trim(),
+        args: splitTopLevelKotlinArgs(trimmed.slice(open + 1, close)),
+    };
+}
+function splitTopLevelKotlinArgs(text) {
+    const out = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '<')
+            depth++;
+        else if (ch === '>')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            out.push(text.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    out.push(text.slice(start).trim());
+    return out.filter((arg) => arg.length > 0);
+}
+function isKotlinMapType(base) {
+    return ['Map', 'MutableMap', 'HashMap', 'LinkedHashMap'].includes(base);
+}
+function isKotlinIterableType(base) {
+    return [
+        'List',
+        'MutableList',
+        'ArrayList',
+        'Set',
+        'MutableSet',
+        'Collection',
+        'Iterable',
+        'Sequence',
+        'Array',
+    ].includes(base);
+}
+function isKotlinTypeNode(node) {
+    return (node.type === 'user_type' || node.type === 'nullable_type' || node.type === 'function_type');
+}
+function descendantsOfType(node, type) {
+    return descendants(node).filter((child) => child.type === type);
+}
+function descendants(node) {
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child === null)
+            continue;
+        out.push(child, ...descendants(child));
+    }
+    return out;
+}
+function shouldEmitReadMember(navNode) {
+    const parent = navNode.parent;
+    if (parent === null)
+        return true;
+    if (parent.type === 'call_expression')
+        return false;
+    if (parent.type === 'directly_assignable_expression')
+        return false;
+    return true;
+}
+function callArguments(callNode) {
+    const suffix = callNode.namedChildren.find((child) => child.type === 'call_suffix');
+    if (suffix === undefined)
+        return [];
+    const valueArgs = suffix?.namedChildren.find((child) => child.type === 'value_arguments');
+    const args = valueArgs?.namedChildren.filter((child) => child.type === 'value_argument') ?? [];
+    const trailingLambdas = suffix.namedChildren.filter((child) => child.type === 'annotated_lambda');
+    return [...args, ...trailingLambdas];
+}
+function inferArgType(argNode) {
+    const value = argNode.namedChild(0) ?? argNode;
+    switch (value.type) {
+        case 'integer_literal':
+        case 'long_literal':
+            return 'Int';
+        case 'real_literal':
+            return 'Double';
+        case 'string_literal':
+        case 'line_string_literal':
+        case 'multi_line_string_literal':
+            return 'String';
+        case 'character_literal':
+            return 'Char';
+        case 'boolean_literal':
+            return 'Boolean';
+        case 'call_expression': {
+            const first = value.namedChild(0);
+            return first?.type === 'simple_identifier' ? first.text : '';
+        }
+        default:
+            return '';
+    }
+}
+function extensionFreeCallFallback(grouped, rootNode) {
+    const member = grouped['@reference.call.member'];
+    const receiver = grouped['@reference.receiver'];
+    const name = grouped['@reference.name'];
+    if (member === undefined || receiver === undefined || name === undefined)
+        return null;
+    const callNode = findNodeAtRange(rootNode, member.range, 'call_expression');
+    if (callNode === null)
+        return null;
+    const receiverNode = findNodeAtRange(rootNode, receiver.range);
+    if (receiverNode === null || !isLiteralReceiver(receiverNode))
+        return null;
+    const out = {
+        '@reference.call.free': syntheticCapture('@reference.call.free', callNode, callNode.text),
+        '@reference.name': syntheticCapture('@reference.name', callNode, name.text),
+    };
+    if (grouped['@reference.arity'] !== undefined)
+        out['@reference.arity'] = grouped['@reference.arity'];
+    if (grouped['@reference.parameter-types'] !== undefined) {
+        out['@reference.parameter-types'] = grouped['@reference.parameter-types'];
+    }
+    return out;
+}
+function isLiteralReceiver(node) {
+    return [
+        'integer_literal',
+        'long_literal',
+        'real_literal',
+        'string_literal',
+        'line_string_literal',
+        'multi_line_string_literal',
+        'character_literal',
+        'boolean_literal',
+    ].includes(node.type);
+}

package/dist/core/ingestion/languages/kotlin/import-decomposer.d.ts

@@ -0,0 +1,3 @@
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+export declare function splitKotlinImportHeader(importNode: SyntaxNode): CaptureMatch | null;

package/dist/core/ingestion/languages/kotlin/import-decomposer.js

@@ -0,0 +1,37 @@
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+export function splitKotlinImportHeader(importNode) {
+    if (importNode.type !== 'import_header')
+        return null;
+    const spec = parseKotlinImport(importNode);
+    if (spec === null)
+        return null;
+    const out = {
+        '@import.statement': nodeToCapture('@import.statement', importNode),
+        '@import.kind': syntheticCapture('@import.kind', spec.atNode, spec.kind),
+        '@import.source': syntheticCapture('@import.source', spec.atNode, spec.source),
+        '@import.name': syntheticCapture('@import.name', spec.atNode, spec.name),
+    };
+    if (spec.alias !== undefined) {
+        out['@import.alias'] = syntheticCapture('@import.alias', spec.atNode, spec.alias);
+    }
+    return out;
+}
+function parseKotlinImport(node) {
+    const identifier = node.namedChildren.find((child) => child.type === 'identifier');
+    if (identifier === undefined)
+        return null;
+    const source = identifier.text.trim();
+    if (source.length === 0)
+        return null;
+    const hasWildcard = node.namedChildren.some((child) => child.type === 'wildcard_import');
+    if (hasWildcard) {
+        return { kind: 'wildcard', source, name: '*', atNode: node };
+    }
+    const aliasNode = node.namedChildren.find((child) => child.type === 'import_alias');
+    const alias = aliasNode?.namedChildren.find((child) => child.type === 'type_identifier')?.text;
+    const importedName = source.split('.').pop() ?? source;
+    if (alias !== undefined && alias.length > 0) {
+        return { kind: 'alias', source, name: importedName, alias, atNode: node };
+    }
+    return { kind: 'named', source, name: importedName, atNode: node };
+}

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

@@ -0,0 +1,6 @@
+import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
+export interface KotlinResolveContext {
+    readonly fromFile: string;
+    readonly allFilePaths: ReadonlySet<string>;
+}
+export declare function resolveKotlinImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | null;

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

@@ -0,0 +1,60 @@
+export function resolveKotlinImportTarget(parsedImport, workspaceIndex) {
+    const ctx = workspaceIndex;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        !(ctx.allFilePaths instanceof Set)) {
+        return null;
+    }
+    if (parsedImport.kind === 'dynamic-unresolved')
+        return null;
+    if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
+        return null;
+    const target = parsedImport.targetRaw.endsWith('.*')
+        ? parsedImport.targetRaw.slice(0, -2)
+        : parsedImport.targetRaw;
+    const pathLike = target.replace(/\./g, '/');
+    return (findKotlinFile(ctx.allFilePaths, pathLike) ??
+        findKotlinFile(ctx.allFilePaths, pathLike.split('/').slice(0, -1).join('/')) ??
+        findByProgressivePrefixStrip(ctx.allFilePaths, pathLike));
+}
+function findKotlinFile(allFilePaths, pathLike) {
+    if (pathLike === '')
+        return null;
+    const extensions = ['.kt', '.kts'];
+    const suffix = `/${pathLike}`;
+    const dirPrefix = `${pathLike}/`;
+    const suffixDirPrefix = `/${dirPrefix}`;
+    let suffixFile = null;
+    let directoryChild = null;
+    for (const raw of allFilePaths) {
+        const file = raw.replace(/\\/g, '/');
+        if (!extensions.some((ext) => file.endsWith(ext)))
+            continue;
+        for (const ext of extensions) {
+            if (file === `${pathLike}${ext}`)
+                return raw;
+            if (suffixFile === null && file.endsWith(`${suffix}${ext}`))
+                suffixFile = raw;
+        }
+        if (directoryChild === null) {
+            const atRoot = file.startsWith(dirPrefix);
+            const atNested = file.includes(suffixDirPrefix);
+            if (atRoot || atNested) {
+                const idx = atRoot ? 0 : file.indexOf(suffixDirPrefix) + 1;
+                const after = file.slice(idx + dirPrefix.length);
+                if (after.length > 0 && !after.includes('/'))
+                    directoryChild = raw;
+            }
+        }
+    }
+    return suffixFile ?? directoryChild;
+}
+function findByProgressivePrefixStrip(allFilePaths, pathLike) {
+    const segments = pathLike.split('/').filter(Boolean);
+    for (let skip = 1; skip < segments.length; skip++) {
+        const found = findKotlinFile(allFilePaths, segments.slice(skip).join('/'));
+        if (found !== null)
+            return found;
+    }
+    return null;
+}

package/dist/core/ingestion/languages/kotlin/index.d.ts

@@ -0,0 +1,8 @@
+export { emitKotlinScopeCaptures } from './captures.js';
+export { getKotlinCaptureCacheStats, resetKotlinCaptureCacheStats } from './cache-stats.js';
+export { interpretKotlinImport, interpretKotlinTypeBinding } from './interpret.js';
+export { kotlinArityCompatibility } from './arity.js';
+export { resolveKotlinImportTarget, type KotlinResolveContext } from './import-target.js';
+export { kotlinMergeBindings } from './merge-bindings.js';
+export { populateKotlinOwners } from './owners.js';
+export { kotlinBindingScopeFor, kotlinImportOwningScope, kotlinReceiverBinding, } from './simple-hooks.js';

package/dist/core/ingestion/languages/kotlin/index.js

@@ -0,0 +1,8 @@
+export { emitKotlinScopeCaptures } from './captures.js';
+export { getKotlinCaptureCacheStats, resetKotlinCaptureCacheStats } from './cache-stats.js';
+export { interpretKotlinImport, interpretKotlinTypeBinding } from './interpret.js';
+export { kotlinArityCompatibility } from './arity.js';
+export { resolveKotlinImportTarget } from './import-target.js';
+export { kotlinMergeBindings } from './merge-bindings.js';
+export { populateKotlinOwners } from './owners.js';
+export { kotlinBindingScopeFor, kotlinImportOwningScope, kotlinReceiverBinding, } from './simple-hooks.js';

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

@@ -0,0 +1,4 @@
+import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.js';
+export declare function interpretKotlinImport(captures: CaptureMatch): ParsedImport | null;
+export declare function interpretKotlinTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;
+export declare function normalizeKotlinType(text: string): string;

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

@@ -0,0 +1,70 @@
+export function interpretKotlinImport(captures) {
+    const kind = captures['@import.kind']?.text;
+    const source = captures['@import.source']?.text;
+    const name = captures['@import.name']?.text;
+    if (kind === undefined || source === undefined)
+        return null;
+    switch (kind) {
+        case 'named':
+            return {
+                kind: 'named',
+                localName: name ?? source.split('.').pop() ?? source,
+                importedName: name ?? source.split('.').pop() ?? source,
+                targetRaw: source,
+            };
+        case 'alias': {
+            const alias = captures['@import.alias']?.text;
+            if (alias === undefined || name === undefined)
+                return null;
+            return {
+                kind: 'alias',
+                localName: alias,
+                importedName: name,
+                alias,
+                targetRaw: source,
+            };
+        }
+        case 'wildcard':
+            return { kind: 'wildcard', targetRaw: source.endsWith('.*') ? source : `${source}.*` };
+        default:
+            return null;
+    }
+}
+export function interpretKotlinTypeBinding(captures) {
+    const nameCap = captures['@type-binding.name'];
+    const typeCap = captures['@type-binding.type'];
+    if (nameCap === undefined || typeCap === undefined)
+        return null;
+    let source = 'annotation';
+    if (captures['@type-binding.self'] !== undefined)
+        source = 'self';
+    else if (captures['@type-binding.parameter'] !== undefined)
+        source = 'parameter-annotation';
+    else if (captures['@type-binding.return'] !== undefined)
+        source = 'return-annotation';
+    else if (captures['@type-binding.constructor'] !== undefined)
+        source = 'constructor-inferred';
+    return {
+        boundName: nameCap.text,
+        rawTypeName: normalizeKotlinType(typeCap.text),
+        source,
+    };
+}
+export function normalizeKotlinType(text) {
+    let out = text.trim();
+    while (out.endsWith('?'))
+        out = out.slice(0, -1).trim();
+    const lastDot = out.lastIndexOf('.');
+    if (lastDot >= 0)
+        out = out.slice(lastDot + 1);
+    const collection = out.match(/^(?:List|MutableList|ArrayList|Set|MutableSet|Collection|Iterable|Sequence|Array)<([^,<>]+)>$/);
+    if (collection !== null)
+        return normalizeKotlinType(collection[1]);
+    const map = out.match(/^(?:Map|MutableMap|HashMap|LinkedHashMap)<[^,<>]+,\s*([^,<>]+)>$/);
+    if (map !== null)
+        return normalizeKotlinType(map[1]);
+    const erased = out.match(/^([A-Za-z_][A-Za-z0-9_]*)<.+>$/s);
+    if (erased !== null)
+        return erased[1];
+    return out;
+}

package/dist/core/ingestion/languages/kotlin/merge-bindings.d.ts

@@ -0,0 +1,2 @@
+import type { BindingRef } from '../../../../_shared/index.js';
+export declare function kotlinMergeBindings(bindings: readonly BindingRef[]): readonly BindingRef[];

package/dist/core/ingestion/languages/kotlin/merge-bindings.js

@@ -0,0 +1,25 @@
+function tierOf(binding) {
+    switch (binding.origin) {
+        case 'local':
+            return 0;
+        case 'import':
+        case 'namespace':
+        case 'reexport':
+            return 1;
+        case 'wildcard':
+            return 2;
+        default:
+            return 3;
+    }
+}
+export function kotlinMergeBindings(bindings) {
+    if (bindings.length === 0)
+        return bindings;
+    const best = Math.min(...bindings.map(tierOf));
+    const seen = new Map();
+    for (const binding of bindings) {
+        if (tierOf(binding) === best)
+            seen.set(binding.def.nodeId, binding);
+    }
+    return [...seen.values()];
+}

package/dist/core/ingestion/languages/kotlin/owners.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedFile } from '../../../../_shared/index.js';
+export declare function populateKotlinOwners(parsed: ParsedFile): void;

package/dist/core/ingestion/languages/kotlin/owners.js

@@ -0,0 +1,50 @@
+import { isClassLike, populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+export function populateKotlinOwners(parsed) {
+    populateClassOwnedMembers(parsed);
+    populateCompanionMembersOnEnclosingClass(parsed);
+}
+function populateCompanionMembersOnEnclosingClass(parsed) {
+    const scopesById = new Map();
+    for (const scope of parsed.scopes)
+        scopesById.set(scope.id, scope);
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Function' || scope.parent === null)
+            continue;
+        const parent = scopesById.get(scope.parent);
+        if (parent === undefined || parent.kind !== 'Class')
+            continue;
+        if (parent.ownedDefs.some((def) => isClassLike(def.type)))
+            continue;
+        const enclosing = findEnclosingClassWithDef(parent.parent, scopesById);
+        if (enclosing === undefined)
+            continue;
+        for (const def of scope.ownedDefs) {
+            if (def.ownerId !== undefined)
+                continue;
+            def.ownerId = enclosing.nodeId;
+            qualify(def, enclosing);
+        }
+    }
+}
+function findEnclosingClassWithDef(start, scopesById) {
+    let current = start;
+    while (current !== null) {
+        const scope = scopesById.get(current);
+        if (scope === undefined)
+            return undefined;
+        if (scope.kind === 'Class') {
+            const classDef = scope.ownedDefs.find((def) => isClassLike(def.type));
+            if (classDef !== undefined)
+                return classDef;
+        }
+        current = scope.parent;
+    }
+    return undefined;
+}
+function qualify(def, owner) {
+    if (def.qualifiedName === undefined || def.qualifiedName.includes('.'))
+        return;
+    if (owner.qualifiedName === undefined || owner.qualifiedName.length === 0)
+        return;
+    def.qualifiedName = `${owner.qualifiedName}.${def.qualifiedName}`;
+}

package/dist/core/ingestion/languages/kotlin/query.d.ts

@@ -0,0 +1,3 @@
+import Parser from 'tree-sitter';
+export declare function getKotlinParser(): Parser;
+export declare function getKotlinScopeQuery(): Parser.Query;

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

@@ -0,0 +1,112 @@
+import Parser from 'tree-sitter';
+import Kotlin from 'tree-sitter-kotlin';
+const KOTLIN_SCOPE_QUERY = `
+;; Scopes
+(source_file) @scope.module
+(class_declaration) @scope.class
+(object_declaration) @scope.class
+(companion_object) @scope.class
+(function_declaration) @scope.function
+
+;; Declarations — types
+(class_declaration
+  "interface"
+  (type_identifier) @declaration.name) @declaration.interface
+
+(class_declaration
+  "class"
+  (type_identifier) @declaration.name) @declaration.class
+
+(object_declaration
+  (type_identifier) @declaration.name) @declaration.class
+
+(companion_object
+  (type_identifier) @declaration.name) @declaration.class
+
+(type_alias
+  (type_identifier) @declaration.name) @declaration.type_alias
+
+;; Declarations — functions / methods / properties
+(function_declaration
+  (simple_identifier) @declaration.name) @declaration.function
+
+(property_declaration
+  (variable_declaration
+    (simple_identifier) @declaration.name)) @declaration.property
+
+(class_parameter
+  (binding_pattern_kind)
+  (simple_identifier) @declaration.name) @declaration.property
+
+;; Imports
+(import_header) @import.statement
+
+;; Type bindings — parameters
+(parameter
+  (simple_identifier) @type-binding.name
+  [(user_type) (nullable_type) (function_type)] @type-binding.type) @type-binding.parameter
+
+;; Type bindings — property / local annotations
+(property_declaration
+  (variable_declaration
+    (simple_identifier) @type-binding.name
+    [(user_type) (nullable_type) (function_type)] @type-binding.type)) @type-binding.annotation
+
+(class_parameter
+  (binding_pattern_kind)
+  (simple_identifier) @type-binding.name
+  [(user_type) (nullable_type) (function_type)] @type-binding.type) @type-binding.annotation
+
+;; Type bindings — constructor-inferred val user = User(...)
+(property_declaration
+  (variable_declaration
+    (simple_identifier) @type-binding.name)
+  (call_expression
+    (simple_identifier) @type-binding.type)) @type-binding.constructor
+
+;; Type bindings — return annotations after function parameters
+(function_declaration
+  (simple_identifier) @type-binding.name
+  (function_value_parameters)
+  [(user_type) (nullable_type) (function_type)] @type-binding.type) @type-binding.return
+
+;; References — direct calls / constructor syntax
+(call_expression
+  (simple_identifier) @reference.name) @reference.call.free
+
+;; References — member calls: obj.method()
+(call_expression
+  (navigation_expression
+    (_) @reference.receiver
+    (navigation_suffix
+      (simple_identifier) @reference.name))) @reference.call.member
+
+;; References — property writes
+(assignment
+  (directly_assignable_expression
+    (_) @reference.receiver
+    (navigation_suffix
+      (simple_identifier) @reference.name))
+  (_)) @reference.write.member
+
+;; References — property reads
+(navigation_expression
+  (_) @reference.receiver
+  (navigation_suffix
+    (simple_identifier) @reference.name)) @reference.read.member
+`;
+let parser = null;
+let query = null;
+export function getKotlinParser() {
+    if (parser === null) {
+        parser = new Parser();
+        parser.setLanguage(Kotlin);
+    }
+    return parser;
+}
+export function getKotlinScopeQuery() {
+    if (query === null) {
+        query = new Parser.Query(Kotlin, KOTLIN_SCOPE_QUERY);
+    }
+    return query;
+}

package/dist/core/ingestion/languages/kotlin/receiver-binding.d.ts

@@ -0,0 +1,3 @@
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+export declare function synthesizeKotlinReceiverBinding(fnNode: SyntaxNode): CaptureMatch[];

package/dist/core/ingestion/languages/kotlin/receiver-binding.js

@@ -0,0 +1,100 @@
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { normalizeKotlinType } from './interpret.js';
+const TYPE_DECL_NODE_TYPES = new Set([
+    'class_declaration',
+    'object_declaration',
+    'companion_object',
+]);
+export function synthesizeKotlinReceiverBinding(fnNode) {
+    if (fnNode.type !== 'function_declaration')
+        return [];
+    const anchorNode = findFunctionBody(fnNode);
+    if (anchorNode === null)
+        return [];
+    const extensionReceiver = extensionReceiverType(fnNode);
+    if (extensionReceiver !== null) {
+        return [buildReceiverMatch(anchorNode, 'this', extensionReceiver)];
+    }
+    const enclosingType = findEnclosingTypeDeclaration(fnNode);
+    if (enclosingType === null)
+        return [];
+    const enclosingName = typeDeclarationName(enclosingType);
+    if (enclosingName === null)
+        return [];
+    const out = [buildReceiverMatch(anchorNode, 'this', enclosingName)];
+    const superName = firstSuperclassText(enclosingType);
+    if (superName !== null)
+        out.push(buildReceiverMatch(anchorNode, 'super', superName));
+    return out;
+}
+function findFunctionBody(fnNode) {
+    for (let i = 0; i < fnNode.namedChildCount; i++) {
+        const child = fnNode.namedChild(i);
+        if (child?.type === 'function_body')
+            return child;
+    }
+    return fnNode;
+}
+function extensionReceiverType(fnNode) {
+    for (let i = 0; i < fnNode.namedChildCount; i++) {
+        const child = fnNode.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'simple_identifier')
+            return null;
+        if (child.type === 'user_type' || child.type === 'nullable_type') {
+            return normalizeKotlinType(child.text);
+        }
+    }
+    return null;
+}
+function findEnclosingTypeDeclaration(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (TYPE_DECL_NODE_TYPES.has(current.type))
+            return current;
+        current = current.parent;
+    }
+    return null;
+}
+function typeDeclarationName(typeNode) {
+    if (typeNode.type === 'companion_object') {
+        return (typeNode.namedChildren.find((child) => child.type === 'type_identifier')?.text ??
+            enclosingNonCompanionTypeName(typeNode) ??
+            'Companion');
+    }
+    return typeNode.namedChildren.find((child) => child.type === 'type_identifier')?.text ?? null;
+}
+function enclosingNonCompanionTypeName(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'class_declaration' || current.type === 'object_declaration') {
+            return current.namedChildren.find((child) => child.type === 'type_identifier')?.text ?? null;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function firstSuperclassText(typeNode) {
+    if (typeNode.type !== 'class_declaration')
+        return null;
+    for (const child of typeNode.namedChildren) {
+        if (child.type !== 'delegation_specifier')
+            continue;
+        const ctor = child.namedChildren.find((n) => n.type === 'constructor_invocation');
+        const userType = ctor?.namedChildren.find((n) => n.type === 'user_type') ??
+            child.namedChildren.find((n) => n.type === 'user_type');
+        const name = userType?.namedChildren.find((n) => n.type === 'type_identifier')?.text;
+        if (name !== undefined)
+            return normalizeKotlinType(name);
+    }
+    return null;
+}
+function buildReceiverMatch(anchorNode, name, typeText) {
+    const out = {
+        '@type-binding.self': nodeToCapture('@type-binding.self', anchorNode),
+        '@type-binding.name': syntheticCapture('@type-binding.name', anchorNode, name),
+        '@type-binding.type': syntheticCapture('@type-binding.type', anchorNode, typeText),
+    };
+    return out;
+}

package/dist/core/ingestion/languages/kotlin/scope-resolver.d.ts

@@ -0,0 +1,17 @@
+import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
+/**
+ * Kotlin scope resolver for RFC #909 Ring 3.
+ *
+ * Kotlin is intentionally registered but not yet listed in
+ * `MIGRATED_LANGUAGES`, matching the Java migration pattern from #1482:
+ * the resolver can run in shadow/forced mode, while production default
+ * stays on the legacy DAG until registry-primary parity reaches the
+ * RFC threshold. Forced mode currently passes 154/175 fixtures (88%),
+ * including core import, receiver, companion, default-param, vararg,
+ * constructor, local assignment-chain, and collection-iteration fixtures.
+ * Remaining gaps are advanced TypeEnv behaviors such as smart casts,
+ * cross-file iterable return propagation, method-chain fixpoint cases,
+ * overload target-id selection, virtual dispatch, and interface default
+ * method dispatch.
+ */
+export declare const kotlinScopeResolver: ScopeResolver;

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

@@ -0,0 +1,37 @@
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { kotlinProvider } from '../kotlin.js';
+import { kotlinArityCompatibility, kotlinMergeBindings, populateKotlinOwners, resolveKotlinImportTarget, } from './index.js';
+/**
+ * Kotlin scope resolver for RFC #909 Ring 3.
+ *
+ * Kotlin is intentionally registered but not yet listed in
+ * `MIGRATED_LANGUAGES`, matching the Java migration pattern from #1482:
+ * the resolver can run in shadow/forced mode, while production default
+ * stays on the legacy DAG until registry-primary parity reaches the
+ * RFC threshold. Forced mode currently passes 154/175 fixtures (88%),
+ * including core import, receiver, companion, default-param, vararg,
+ * constructor, local assignment-chain, and collection-iteration fixtures.
+ * Remaining gaps are advanced TypeEnv behaviors such as smart casts,
+ * cross-file iterable return propagation, method-chain fixpoint cases,
+ * overload target-id selection, virtual dispatch, and interface default
+ * method dispatch.
+ */
+export const kotlinScopeResolver = {
+    language: SupportedLanguages.Kotlin,
+    languageProvider: kotlinProvider,
+    importEdgeReason: 'kotlin-scope: import',
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
+        const ws = { fromFile, allFilePaths };
+        return resolveKotlinImportTarget({ kind: 'named', localName: '_', importedName: '_', targetRaw }, ws);
+    },
+    mergeBindings: (existing, incoming) => [...kotlinMergeBindings([...existing, ...incoming])],
+    arityCompatibility: (callsite, def) => kotlinArityCompatibility(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    populateOwners: (parsed) => populateKotlinOwners(parsed),
+    isSuperReceiver: (text) => text.trim() === 'super',
+    fieldFallbackOnMethodLookup: false,
+    propagatesReturnTypesAcrossImports: true,
+    collapseMemberCallsByCallerTarget: false,
+    hoistTypeBindingsToModule: true,
+};

package/dist/core/ingestion/languages/kotlin/simple-hooks.d.ts

@@ -0,0 +1,4 @@
+import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } from '../../../../_shared/index.js';
+export declare function kotlinBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | null;
+export declare function kotlinImportOwningScope(_imp: ParsedImport, _innermost: Scope, _tree: ScopeTree): ScopeId | null;
+export declare function kotlinReceiverBinding(functionScope: Scope): TypeRef | null;

package/dist/core/ingestion/languages/kotlin/simple-hooks.js

@@ -0,0 +1,19 @@
+export function kotlinBindingScopeFor(decl, innermost, tree) {
+    if (decl['@type-binding.return'] === undefined)
+        return null;
+    let current = innermost;
+    while (current !== undefined && current.kind !== 'Module') {
+        if (current.parent === null)
+            break;
+        current = tree.getScope(current.parent);
+    }
+    return current?.kind === 'Module' ? current.id : null;
+}
+export function kotlinImportOwningScope(_imp, _innermost, _tree) {
+    return null;
+}
+export function kotlinReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('this') ?? functionScope.typeBindings.get('super') ?? null;
+}

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

@@ -26,6 +26,7 @@ import { kotlinMethodConfig } from '../method-extractors/configs/jvm.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { kotlinVariableConfig } from '../variable-extractors/configs/jvm.js';
 import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { emitKotlinScopeCaptures, interpretKotlinImport, interpretKotlinTypeBinding, kotlinArityCompatibility, kotlinBindingScopeFor, kotlinImportOwningScope, kotlinMergeBindings, kotlinReceiverBinding, } from './kotlin/index.js';
 /** Check if a Kotlin function_declaration capture is inside a class_body (i.e., a method).
  *  Kotlin grammar uses function_declaration for both top-level functions and class methods.
  *  Returns true when the captured definition node has a class_body ancestor. */
@@ -161,4 +162,13 @@ export const kotlinProvider = defineLanguage({
             return 'Method';
         return defaultLabel;
     },
+    // ── RFC #909 Ring 3: scope-based resolution hooks ──
+    emitScopeCaptures: emitKotlinScopeCaptures,
+    interpretImport: interpretKotlinImport,
+    interpretTypeBinding: interpretKotlinTypeBinding,
+    bindingScopeFor: kotlinBindingScopeFor,
+    importOwningScope: kotlinImportOwningScope,
+    mergeBindings: (_scope, bindings) => kotlinMergeBindings(bindings),
+    receiverBinding: kotlinReceiverBinding,
+    arityCompatibility: kotlinArityCompatibility,
 });

package/dist/core/ingestion/scope-resolution/pipeline/registry.js

@@ -18,6 +18,7 @@ import { cScopeResolver } from '../../languages/c/scope-resolver.js';
 import { cppScopeResolver } from '../../languages/cpp/scope-resolver.js';
 import { phpScopeResolver } from '../../languages/php/scope-resolver.js';
 import { javascriptScopeResolver } from '../../languages/javascript/scope-resolver.js';
+import { kotlinScopeResolver } from '../../languages/kotlin/scope-resolver.js';
 /** Map of `SupportedLanguages` → `ScopeResolver`. The phase iterates
  *  this map intersected with `MIGRATED_LANGUAGES` (the per-language
  *  flag set) so adding a resolver here without flipping the flag is
@@ -32,4 +33,5 @@ export const SCOPE_RESOLVERS = new Map([
     [SupportedLanguages.CPlusPlus, cppScopeResolver],
     [SupportedLanguages.PHP, phpScopeResolver],
     [SupportedLanguages.JavaScript, javascriptScopeResolver],
+    [SupportedLanguages.Kotlin, kotlinScopeResolver],
 ]);

package/package.json

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