gitnexus 1.6.11-rc.32 → 1.6.11-rc.33

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

@@ -324,7 +324,9 @@ export function resolveRouteHandlerSymbols(model, extractedRoutes, decoratorRout
             : uniqueById(model.methods.lookupAllByOwner(owner.nodeId, member))?.nodeId;
     };
     const claim = (routePath, prefix, httpMethod, symbolId) => {
-        if (!routePath)
+        // An empty path is a valid, pathless mapping and normalizes to either `/`
+        // or its class/router prefix. Only null means the extractor had no route.
+        if (routePath === null)
             return;
         const url = normalizeExtractedRoutePath(routePath, prefix);
         const key = routeNodeKey(normalizeRouteMethod(httpMethod), url);

package/dist/core/ingestion/frameworks/spring/annotation-arguments.js

@@ -123,7 +123,14 @@ export function parseSpringAnnotationArguments(annotationText) {
     if (body.length === 0)
         return [];
     const rawArguments = splitTopLevel(body, ',');
-    if (rawArguments === null || rawArguments.some((argument) => argument.length === 0))
+    if (rawArguments === null)
+        return null;
+    // Kotlin (and some formatters) allow a trailing comma. An empty *middle*
+    // argument is still invalid and fail-closed.
+    while (rawArguments.at(-1)?.length === 0) {
+        rawArguments.pop();
+    }
+    if (rawArguments.some((argument) => argument.length === 0))
         return null;
     const parsed = [];
     for (const raw of rawArguments) {

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

@@ -30,6 +30,8 @@ import { kotlinVariableConfig } from '../variable-extractors/configs/jvm.js';
 import { collectKotlinCaptureSideChannel, emitKotlinScopeCaptures, interpretKotlinImport, interpretKotlinTypeBinding, kotlinArityCompatibility, kotlinBindingScopeFor, kotlinImportOwningScope, kotlinMergeBindings, kotlinReceiverBinding, } from './kotlin/index.js';
 import { synthesizeLombokAccessors } from './kotlin/lombok-synthesizer.js';
 import { extractKotlinRuntimeSymbolProperties, kotlinRuntimeSymbolStrategy, } from './kotlin/spring-actuator.js';
+import { extractKotlinSpringRoutes } from '../route-extractors/kotlin-spring.js';
+import { extractKotlinModuleConstants, foldKotlinOperands, } from '../route-extractors/kotlin-const-resolver.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. */
@@ -188,4 +190,8 @@ export const kotlinProvider = defineLanguage({
     receiverBinding: kotlinReceiverBinding,
     arityCompatibility: kotlinArityCompatibility,
     synthesizeStructureMembers: synthesizeLombokAccessors,
+    // ── Spring decorator routes + composed path constants (#3130) ──
+    extractDecoratorRoutes: extractKotlinSpringRoutes,
+    extractModuleConstants: extractKotlinModuleConstants,
+    foldRoutePathOperands: foldKotlinOperands,
 });

package/dist/core/ingestion/route-extractors/kotlin-const-resolver.d.ts

@@ -123,16 +123,11 @@
  *
  * WHERE THIS IS WIRED. Java reaches its binding from BOTH layers: the group
  * extractor (`group/extractors/http-patterns/java.ts`) and the ingestion
- * provider (`languages/java.ts`, via `extractModuleConstants` +
- * `foldRoutePathOperands`). Kotlin is wired into the GROUP layer only, because
- * the ingestion fold in `pipeline-phases/parse-impl.ts` runs exclusively over
- * `decoratorRoutes` — and `languages/kotlin.ts` declares no
- * `extractDecoratorRoutes`, since the ingestion Spring extractor (`spring.ts`)
- * is bound to `tree-sitter-java` and its node types. Declaring the constant
- * hooks on the Kotlin provider today would harvest a map on every Kotlin file
- * that nothing consumes. An ingestion-side Kotlin route extractor is the
- * prerequisite; when it lands, this binding is what its provider hooks should
- * point at, and no change here is needed.
+ * provider (`languages/java.ts`). Kotlin now does the same: the group extractor
+ * (`group/extractors/http-patterns/kotlin.ts`) plus `languages/kotlin.ts`
+ * (`extractDecoratorRoutes`, `extractModuleConstants`, `foldRoutePathOperands`).
+ * The dedicated ingestion walker is `route-extractors/kotlin-spring.ts`; it
+ * does not reuse Java `spring.ts`.
  */
 import type Parser from 'tree-sitter';
 import { type ModuleConstants, type Operand, type RepoConstants } from './constant-resolver.js';

package/dist/core/ingestion/route-extractors/kotlin-const-resolver.js

@@ -123,16 +123,11 @@
  *
  * WHERE THIS IS WIRED. Java reaches its binding from BOTH layers: the group
  * extractor (`group/extractors/http-patterns/java.ts`) and the ingestion
- * provider (`languages/java.ts`, via `extractModuleConstants` +
- * `foldRoutePathOperands`). Kotlin is wired into the GROUP layer only, because
- * the ingestion fold in `pipeline-phases/parse-impl.ts` runs exclusively over
- * `decoratorRoutes` — and `languages/kotlin.ts` declares no
- * `extractDecoratorRoutes`, since the ingestion Spring extractor (`spring.ts`)
- * is bound to `tree-sitter-java` and its node types. Declaring the constant
- * hooks on the Kotlin provider today would harvest a map on every Kotlin file
- * that nothing consumes. An ingestion-side Kotlin route extractor is the
- * prerequisite; when it lands, this binding is what its provider hooks should
- * point at, and no change here is needed.
+ * provider (`languages/java.ts`). Kotlin now does the same: the group extractor
+ * (`group/extractors/http-patterns/kotlin.ts`) plus `languages/kotlin.ts`
+ * (`extractDecoratorRoutes`, `extractModuleConstants`, `foldRoutePathOperands`).
+ * The dedicated ingestion walker is `route-extractors/kotlin-spring.ts`; it
+ * does not reuse Java `spring.ts`.
  */
 import { unquoteSpringLiteral } from './spring-shared.js';
 import { MAX_FOLD_LENGTH, unfoldableDeclarationsOf, } from './constant-resolver.js';

package/dist/core/ingestion/route-extractors/kotlin-spring.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Kotlin Spring MVC route annotations for the ingestion pipeline (#3130).
+ *
+ * This module only walks a caller-provided tree. In particular, it does not
+ * import or load tree-sitter-kotlin at module initialization, so platforms
+ * without the optional grammar can still load the language-provider registry.
+ */
+import type Parser from 'tree-sitter';
+import type { ExtractedDecoratorRoute } from '../workers/parse-worker.js';
+/**
+ * Extract direct Spring handler methods from concrete Kotlin RestControllers.
+ */
+export declare function extractKotlinSpringRoutes(tree: Parser.Tree, filePath: string, lineOffset?: number): ExtractedDecoratorRoute[];

package/dist/core/ingestion/route-extractors/kotlin-spring.js

@@ -0,0 +1,266 @@
+import { intersectSpringHttpMethods, springAnnotationHttpMethods, unquoteSpringLiteral, } from './spring-shared.js';
+import { extractKotlinModuleConstants, parseKotlinConstOperands, unfoldableDeclarationsOf, unquoteKotlinIdentifier, } from './kotlin-const-resolver.js';
+/** Direct declaration annotations in source order. */
+function declarationAnnotations(node) {
+    const modifiers = node.namedChildren.find((child) => child.type === 'modifiers');
+    return modifiers?.namedChildren.filter((child) => child.type === 'annotation') ?? [];
+}
+/** `@Foo`, `@Foo(...)`, or `@a.b.Foo(...)` → `Foo`. */
+function annotationName(annotation) {
+    const constructor = annotation.namedChildren.find((child) => child.type === 'constructor_invocation');
+    const userType = annotation.namedChildren.find((child) => child.type === 'user_type') ??
+        constructor?.namedChildren.find((child) => child.type === 'user_type');
+    const identifiers = userType?.namedChildren.filter((child) => child.type === 'type_identifier') ?? [];
+    const identifier = identifiers.at(-1);
+    return identifier ? unquoteKotlinIdentifier(identifier.text) : null;
+}
+function annotationArguments(annotation) {
+    const constructor = annotation.namedChildren.find((child) => child.type === 'constructor_invocation');
+    const values = constructor?.namedChildren.find((child) => child.type === 'value_arguments');
+    return values?.namedChildren.filter((child) => child.type === 'value_argument') ?? [];
+}
+/**
+ * Kotlin represents positional and named annotation arguments with the same
+ * `value_argument` node. A direct `=` token distinguishes the named form.
+ */
+function readAnnotationArgument(argument) {
+    const named = argument.children.some((child) => child.type === '=');
+    if (!named) {
+        const expression = argument.namedChild(0);
+        return expression ? { expression } : null;
+    }
+    const key = argument.namedChild(0);
+    const expression = argument.namedChild(1);
+    if (key?.type !== 'simple_identifier' || !expression)
+        return null;
+    return { name: unquoteKotlinIdentifier(key.text), expression };
+}
+function routeArguments(annotation) {
+    const out = [];
+    for (const argument of annotationArguments(annotation)) {
+        const parsed = readAnnotationArgument(argument);
+        if (!parsed)
+            return null;
+        if (parsed.name === undefined || parsed.name === 'path' || parsed.name === 'value') {
+            out.push(parsed);
+        }
+    }
+    return out;
+}
+/** A fully static Kotlin string literal: no `$name` or `${expr}` children. */
+function isPlainStringLiteral(node) {
+    return (node.type === 'string_literal' &&
+        node.namedChildren.every((child) => child.type === 'string_content'));
+}
+/**
+ * Empty `[]` / `arrayOf()` is Spring "no path", not an unresolvable prefix.
+ * tree-sitter-kotlin may put a zero-width recovery child inside `[]`.
+ */
+function isEmptyKotlinPathCollection(node) {
+    if (node.type === 'collection_literal') {
+        return node.namedChildren.every((child) => child.text.length === 0);
+    }
+    if (node.type !== 'call_expression')
+        return false;
+    const callee = node.namedChild(0);
+    if (callee?.type !== 'simple_identifier' || unquoteKotlinIdentifier(callee.text) !== 'arrayOf') {
+        return false;
+    }
+    const suffix = node.namedChildren.find((child) => child.type === 'call_suffix');
+    const args = suffix?.namedChildren.find((child) => child.type === 'value_arguments');
+    if (!args)
+        return true;
+    return args.namedChildren.every((child) => child.type !== 'value_argument');
+}
+function isKotlinInterface(node) {
+    return node.children.some((child) => child.type === 'interface');
+}
+function isAbstractOrSealedClass(node) {
+    const modifiers = node.namedChildren.find((child) => child.type === 'modifiers');
+    return (modifiers?.namedChildren.some((child) => {
+        if (child.type !== 'inheritance_modifier' && child.type !== 'class_modifier') {
+            return false;
+        }
+        const text = child.text.trim();
+        return text === 'abstract' || text === 'sealed';
+    }) === true);
+}
+function directFunctions(node) {
+    const body = node.namedChildren.find((child) => child.type === 'class_body');
+    return body?.namedChildren.filter((child) => child.type === 'function_declaration') ?? [];
+}
+function functionName(node) {
+    const field = node.childForFieldName('name');
+    const identifier = field?.type === 'simple_identifier'
+        ? field
+        : node.namedChildren.find((child) => child.type === 'simple_identifier');
+    return identifier ? unquoteKotlinIdentifier(identifier.text) : null;
+}
+/**
+ * `springAnnotationHttpMethods` parses Java `{A, B}` collections.
+ * Translate only Kotlin `method = [A, B]` before delegating.
+ */
+function kotlinSpringHttpMethods(name, annotation) {
+    if (name !== 'RequestMapping')
+        return springAnnotationHttpMethods(name, annotation.text);
+    const normalized = annotation.text.replace(/(\bmethod\s*=\s*)\[([^\]]*)\]/gs, (_match, assignment, values) => `${assignment}{${values}}`);
+    return springAnnotationHttpMethods(name, normalized);
+}
+function typeName(node) {
+    const identifier = node.children.find((child) => child.type === 'type_identifier');
+    return identifier ? unquoteKotlinIdentifier(identifier.text) : null;
+}
+/**
+ * Qualified enclosing type paths, innermost first. Kotlin companion members
+ * are keyed through their enclosing class, so companion_object itself adds no
+ * segment.
+ */
+function enclosingTypeNames(node) {
+    const simpleNames = [];
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type !== 'class_declaration' && current.type !== 'object_declaration')
+            continue;
+        const name = typeName(current);
+        if (name)
+            simpleNames.push(name);
+    }
+    return simpleNames.map((_, index) => simpleNames.slice(index).reverse().join('.'));
+}
+function declarationExists(constants, name) {
+    return (constants.literals.has(name) ||
+        constants.exprs.has(name) ||
+        unfoldableDeclarationsOf(constants).has(name));
+}
+/**
+ * The provider fold hook has a language-neutral three-argument signature and
+ * cannot receive a Kotlin reference site's enclosing type chain. Qualify only
+ * names whose owner is proven by this same tree; unresolved/imported names are
+ * left untouched for the repo-wide resolver.
+ */
+function qualifySameFileOperands(operands, functionNode, constants) {
+    const enclosingTypes = enclosingTypeNames(functionNode);
+    return operands.map((operand) => {
+        if (operand.kind === 'literal')
+            return operand;
+        for (const owner of enclosingTypes) {
+            const qualified = `${owner}.${operand.name}`;
+            if (declarationExists(constants, qualified)) {
+                return { kind: 'ref', name: qualified };
+            }
+        }
+        return operand;
+    });
+}
+/**
+ * Read the one optional class-level RequestMapping. A present route member must
+ * be exactly one plain string literal, an empty `[]`/`arrayOf()` (no prefix),
+ * or absent; constants, interpolation, non-empty collections, duplicate
+ * mappings, and dynamic expressions fail closed for the whole class.
+ */
+function classMapping(annotations) {
+    const mappings = annotations.filter((annotation) => annotationName(annotation) === 'RequestMapping');
+    if (mappings.length === 0)
+        return { prefix: '', methods: ['*'] };
+    if (mappings.length !== 1)
+        return null;
+    const mapping = mappings[0];
+    const paths = routeArguments(mapping);
+    if (paths === null || paths.length > 1)
+        return null;
+    let prefix = '';
+    if (paths.length === 1) {
+        const path = paths[0].expression;
+        if (isEmptyKotlinPathCollection(path)) {
+            prefix = '';
+        }
+        else if (isPlainStringLiteral(path)) {
+            const literal = unquoteSpringLiteral(path.text);
+            if (literal === null)
+                return null;
+            prefix = literal;
+        }
+        else {
+            return null;
+        }
+    }
+    const methods = kotlinSpringHttpMethods('RequestMapping', mapping);
+    return methods.length === 0 ? null : { prefix, methods };
+}
+/**
+ * Extract direct Spring handler methods from concrete Kotlin RestControllers.
+ */
+export function extractKotlinSpringRoutes(tree, filePath, lineOffset = 0) {
+    const routes = [];
+    let moduleConstants;
+    for (const classNode of tree.rootNode.descendantsOfType('class_declaration')) {
+        if (isKotlinInterface(classNode) || isAbstractOrSealedClass(classNode))
+            continue;
+        const annotations = declarationAnnotations(classNode);
+        const annotationNames = annotations.map(annotationName);
+        if (!annotationNames.includes('RestController'))
+            continue;
+        if (annotationNames.includes('FeignClient'))
+            continue;
+        const ownerMapping = classMapping(annotations);
+        if (ownerMapping === null)
+            continue;
+        for (const functionNode of directFunctions(classNode)) {
+            const handlerName = functionName(functionNode);
+            if (!handlerName)
+                continue;
+            for (const annotation of declarationAnnotations(functionNode)) {
+                const decoratorName = annotationName(annotation);
+                if (!decoratorName)
+                    continue;
+                const methodMethods = kotlinSpringHttpMethods(decoratorName, annotation);
+                const methods = intersectSpringHttpMethods(ownerMapping.methods, methodMethods);
+                if (methods.length === 0)
+                    continue;
+                const paths = routeArguments(annotation);
+                if (paths === null || paths.length > 1)
+                    continue;
+                let routePath = '';
+                let routePathExpr;
+                let routePathOperands;
+                if (paths.length === 1) {
+                    const expression = paths[0].expression;
+                    if (isEmptyKotlinPathCollection(expression)) {
+                        routePath = '';
+                    }
+                    else if (isPlainStringLiteral(expression)) {
+                        const literal = unquoteSpringLiteral(expression.text);
+                        if (literal === null)
+                            continue;
+                        routePath = literal;
+                    }
+                    else {
+                        const operands = parseKotlinConstOperands(expression);
+                        if (operands === null)
+                            continue;
+                        moduleConstants ??= extractKotlinModuleConstants(tree);
+                        routePathExpr = expression.text;
+                        routePathOperands = qualifySameFileOperands(operands, functionNode, moduleConstants);
+                    }
+                }
+                for (const httpMethod of methods) {
+                    routes.push({
+                        filePath,
+                        routePath,
+                        httpMethod,
+                        decoratorName,
+                        lineNumber: annotation.startPosition.row + lineOffset,
+                        ...(ownerMapping.prefix ? { prefix: ownerMapping.prefix } : {}),
+                        handlerName,
+                        ...(routePathExpr === undefined
+                            ? {}
+                            : {
+                                routePathExpr,
+                                routePathOperands,
+                            }),
+                    });
+                }
+            }
+        }
+    }
+    return routes;
+}

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

@@ -946,6 +946,7 @@ export function extractORMQueries(filePath, content, out) {
 // import the function and its types directly from `route-extractors/`.
 import { extractFastAPIRouterBindings } from '../route-extractors/fastapi-router-bindings.js';
 import { parseConstOperands, } from '../route-extractors/python-const-resolver.js';
+import { unfoldableDeclarationsOf } from '../route-extractors/constant-resolver.js';
 /**
  * Report a non-fatal worker issue to the pool over IPC so a caught error is not
  * invisible to the operator (#2264). The pool logs it on the main thread AND
@@ -2331,10 +2332,13 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         // without booting a worker.
         if (provider.extractModuleConstants && shouldHarvestModuleConstants(provider, parseContent)) {
             const constants = provider.extractModuleConstants(tree);
+            const topLevelDeclarations = constants.topLevelDeclarations;
             if (constants.literals.size > 0 ||
                 constants.exprs.size > 0 ||
                 constants.imports.size > 0 ||
-                (constants.wildcardImports?.length ?? 0) > 0) {
+                (constants.wildcardImports?.length ?? 0) > 0 ||
+                unfoldableDeclarationsOf(constants).size > 0 ||
+                (topLevelDeclarations instanceof Set && topLevelDeclarations.size > 0)) {
                 (result.moduleConstants ??= []).push({ filePath: file.path, constants });
             }
         }

package/dist/storage/parse-cache.js

@@ -711,7 +711,11 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // (89) and above every in-flight claim found by scanning open PRs'
 // parse-cache.ts at their exact head SHAs (highest other open claim was still
 // ≤88). RE-CHECK AGAINST origin/main AND OPEN PRs IMMEDIATELY BEFORE MERGING.
-const SCHEMA_BUMP = 90;
+// 90 -> 91 (#3130): Kotlin providers now emit Spring decoratorRoutes plus
+// ModuleConstants shadow metadata. A warm v90 cache would replay unchanged
+// Kotlin files with neither route candidates nor the constant declarations
+// needed to fold them, leaving the new ingestion path silently inert.
+const SCHEMA_BUMP = 91;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.11-rc.32",
+  "version": "1.6.11-rc.33",
   "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",