gitnexus 1.6.6-rc.85 → 1.6.6-rc.87

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

@@ -9,18 +9,22 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
  * named annotation arguments (`@GetMapping(value = "/x")` and
  * `@GetMapping(path = "/x")`) are supported.
  *
- * **Consumers** (this PR) — three call-site patterns common in Kotlin
+ * **Consumers** — four call-site patterns common in Kotlin
  * Spring projects:
  *
- *   1. `restTemplate.getForObject("/x", ...)` and friends
- *   2. `webClient.get().uri("/x")` (short form, 1 verb hop + 1 uri hop)
- *   3. `Request.Builder().url("/x")` (OkHttp)
+ *   1. `restTemplate.getForObject("/x", ...)` and friends (#1855)
+ *   2. `webClient.get().uri("/x")` — short form (#1855)
+ *   3. `Request.Builder().url("/x")` — OkHttp (#1855)
+ *   4. `webClient.method(HttpMethod.X).uri("/y")` — long form (this PR)
  *
- * The long-form `webClient.method(HttpMethod.X).uri("/y")` chain is
- * intentionally deferred to a follow-up: it requires walk-up logic
- * to recover the verb from a sibling `call_expression`, and we can
- * land 80% of real-world Kotlin Spring consumer coverage with the
- * three simpler patterns above.
+ * The long form puts the verb on a sibling `call_expression` two hops
+ * away from the path. Rather than introducing imperative walk-up logic,
+ * we use a single deeper tree-sitter query that matches the full chain
+ * structurally — see `WEB_CLIENT_LONG_PATTERNS` below. The verb is
+ * captured directly as the `simple_identifier` of `HttpMethod.X`, so
+ * variable-bound verbs (`val verb = HttpMethod.PATCH; webClient.method(verb)...`)
+ * are intentionally NOT picked up — those need a graph-aware resolver
+ * and are out of scope for source-scan.
  *
  * tree-sitter-kotlin (fwcd) AST shapes used here:
  *   class_declaration
@@ -96,6 +100,15 @@ const WEB_CLIENT_SHORT_TO_HTTP = {
     delete: 'DELETE',
     patch: 'PATCH',
 };
+/**
+ * Allowed HTTP verbs for the WebClient long-form path
+ * `webClient.method(HttpMethod.X).uri("/y")`. Compiled once at module
+ * load (instead of inside the scan loop) per maintainer feedback on
+ * PR #1884. Mirrors the keys of `WEB_CLIENT_SHORT_TO_HTTP` above —
+ * keeping HEAD/OPTIONS/TRACE intentionally excluded for symmetry
+ * with the short form and the Java plugin.
+ */
+const WEB_CLIENT_LONG_VERB_RE = /^(GET|POST|PUT|DELETE|PATCH)$/;
 /**
  * Build the plugin only if the Kotlin grammar is available. Compiling
  * the queries against a null grammar would throw at module load time
@@ -249,8 +262,9 @@ function buildKotlinPlugin(language) {
     //   - outer call's first value_argument is a string literal
     //
     // The long-form `webClient.method(HttpMethod.GET).uri("/x")` chain
-    // uses an extra navigation hop and an enum field access — it's
-    // intentionally out of scope here (see file header).
+    // uses an extra navigation hop and an enum field access — handled
+    // by `WEB_CLIENT_LONG_PATTERNS` below, separately so each query is
+    // straightforward to reason about.
     const WEB_CLIENT_SHORT_PATTERNS = compilePatterns({
         name: 'kotlin-web-client-short',
         language,
@@ -273,6 +287,58 @@ function buildKotlinPlugin(language) {
             },
         ],
     });
+    // ─── Consumer: Spring WebClient (long form) ───────────────────────────
+    // The fluent long form passes the verb as a `HttpMethod.X` enum field
+    // access through `.method(...)`, then carries the path on a separate
+    // `.uri(...)` hop further down the chain:
+    //
+    //   webClient.method(HttpMethod.GET).uri("/x").retrieve().awaitBody<T>()
+    //
+    // Compared to the short form there are two extra structural hops:
+    //   - the inner `.method(...)` `call_expression` has a `value_argument`
+    //     whose payload is itself a `navigation_expression` (HttpMethod → .GET)
+    //   - the outer `.uri(...)` is reached via one more
+    //     `navigation_expression` wrapping that inner call
+    //
+    // We capture the verb at the `simple_identifier` under `HttpMethod`'s
+    // `navigation_suffix`. That `simple_identifier` is the literal field
+    // name (`GET`, `POST`, ...) used in source — Kotlin enum fields by
+    // convention are upper-case, matching `HttpMethod` from
+    // `org.springframework.http`. We forward the captured text as-is.
+    //
+    // Variable-bound verbs (`val verb = HttpMethod.PATCH; webClient.method(verb)...`)
+    // do NOT match — they fail the `(navigation_expression ...)` shape
+    // because the value_argument carries a bare `simple_identifier` instead
+    // of a `HttpMethod.X` field access. This is intentional: source-scan
+    // can't follow the binding without graph context. Pinned by an
+    // anti-overreach test in the consumer suite.
+    const WEB_CLIENT_LONG_PATTERNS = compilePatterns({
+        name: 'kotlin-web-client-long',
+        language,
+        patterns: [
+            {
+                meta: {},
+                query: `
+          (call_expression
+            (navigation_expression
+              (call_expression
+                (navigation_expression
+                  (simple_identifier) @obj (#eq? @obj "webClient")
+                  (navigation_suffix
+                    (simple_identifier) @method_call (#eq? @method_call "method")))
+                (call_suffix
+                  (value_arguments
+                    . (value_argument
+                        (navigation_expression
+                          (simple_identifier) @httpMethodCls (#eq? @httpMethodCls "HttpMethod")
+                          (navigation_suffix (simple_identifier) @verb))))))
+              (navigation_suffix (simple_identifier) @uri (#eq? @uri "uri")))
+            (call_suffix
+              (value_arguments . (value_argument . (string_literal) @path))))
+        `,
+            },
+        ],
+    });
     // ─── Consumer: OkHttp Request.Builder().url("/x") ─────────────────────
     // Kotlin parses `Request.Builder()` as a `call_expression` whose
     // callee is a `navigation_expression` (Request → .Builder), NOT as
@@ -425,6 +491,35 @@ function buildKotlinPlugin(language) {
                     confidence: 0.7,
                 });
             }
+            // ─── Consumers: WebClient long form (.method(HttpMethod.X) → .uri) ─
+            for (const match of runCompiledPatterns(WEB_CLIENT_LONG_PATTERNS, tree)) {
+                const verbNode = match.captures.verb;
+                const pathNode = match.captures.path;
+                if (!verbNode || !pathNode)
+                    continue;
+                // The captured text is the literal `HttpMethod.X` field name.
+                // Spring's `org.springframework.http.HttpMethod` defines GET,
+                // POST, PUT, DELETE, PATCH, HEAD, OPTIONS, TRACE — we only
+                // emit for the five verbs we already handle elsewhere, so
+                // exotic ones are silently skipped (consistent with the
+                // short form's WEB_CLIENT_SHORT_TO_HTTP guard). The accepted
+                // verb regex is hoisted to module scope (see
+                // `WEB_CLIENT_LONG_VERB_RE` near the top of this file).
+                const verbText = verbNode.text;
+                if (!WEB_CLIENT_LONG_VERB_RE.test(verbText))
+                    continue;
+                const path = unquoteLiteral(pathNode.text);
+                if (path === null)
+                    continue;
+                out.push({
+                    role: 'consumer',
+                    framework: 'spring-web-client',
+                    method: verbText,
+                    path,
+                    name: null,
+                    confidence: 0.7,
+                });
+            }
             // ─── Consumers: OkHttp Request.Builder().url("path") ────────────
             for (const match of runCompiledPatterns(OK_HTTP_PATTERNS, tree)) {
                 const pathNode = match.captures.path;

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

@@ -101,9 +101,26 @@ export const processCobol = (graph, files, allPathSet) => {
         const entry = copybookMap.get(name.toUpperCase());
         return entry ? entry.path : null;
     };
+    // Memoize preprocessed copybook content for the duration of this
+    // processCobol call. A single copybook is COPYed by many programs (and at
+    // many COPY sites within a program); without this cache
+    // preprocessCobolSource would re-run once per COPY site —
+    // O(programs × copybooks) preprocessing passes over the same content.
+    // Keyed by the resolved copybook path. REPLACING is applied later by the
+    // expander on the returned (pre-REPLACING) content (see
+    // cobol-copy-expander.ts readFile→applyReplacing), so caching the
+    // pre-REPLACING preprocessed text here is safe and per-call-scoped.
+    const preprocessedCopyCache = new Map();
     const readCopy = (copyPath) => {
+        const cached = preprocessedCopyCache.get(copyPath);
+        if (cached !== undefined)
+            return cached;
         const content = copybookByPath.get(copyPath);
-        return content ? preprocessCobolSource(content) : null;
+        if (!content)
+            return null; // preserves original falsy→null (missing/empty)
+        const preprocessed = preprocessCobolSource(content);
+        preprocessedCopyCache.set(copyPath, preprocessed);
+        return preprocessed;
     };
     // Track module names for cross-program CALL resolution
     const moduleNodeIds = new Map(); // uppercase program name -> node id

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

@@ -59,7 +59,7 @@ export function emitCobolScopeCaptures(sourceText, _filePath, _cachedTree) {
             ? rangeOf(progIdLine, 7, progIdLine, lines[progIdLine - 1]?.length ?? endCol)
             : rangeOf(startLine, startCol, endLine, endCol);
         const grouped = {
-            '@scope.module': capture('@scope.module', nameRange, name),
+            '@scope.module': capture('@scope.module', rangeOf(startLine, startCol, endLine, endCol), name),
             '@declaration.program': capture('@declaration.program', rangeOf(startLine, startCol, endLine, endCol), name),
             '@declaration.name': capture('@declaration.name', nameRange, name),
         };
@@ -83,7 +83,7 @@ export function emitCobolScopeCaptures(sourceText, _filePath, _cachedTree) {
             ? rangeOf(progIdLine, 7, progIdLine, lines[progIdLine - 1]?.length ?? endCol)
             : rangeOf(startLine, startCol, endLine, endCol);
         const grouped = {
-            '@scope.module': capture('@scope.module', nameRange, prog.name),
+            '@scope.module': capture('@scope.module', rangeOf(startLine, startCol, endLine, endCol), prog.name),
             '@declaration.program': capture('@declaration.program', rangeOf(startLine, startCol, endLine, endCol), prog.name),
             '@declaration.name': capture('@declaration.name', nameRange, prog.name),
         };

package/dist/core/ingestion/registry-primary-flag.js

@@ -79,6 +79,7 @@ export const MIGRATED_LANGUAGES = new Set([
     SupportedLanguages.Java,
     SupportedLanguages.Rust,
     SupportedLanguages.Ruby,
+    SupportedLanguages.Cobol,
 ]);
 /**
  * Return the env-var name that controls a given language's registry-

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

@@ -81,6 +81,20 @@ export const scopeResolutionPhase = {
         for (const pf of workerParsedFiles) {
             preExtractedByPath.set(pf.filePath, pf);
         }
+        // Drop pre-extracted entries for standalone providers — these
+        // languages are skipped by the canonical guard below (line 164)
+        // and never consume preExtractedByPath, so holding onto their
+        // entries leaks memory until the cleanup loop at 262-264 which
+        // also never runs for skipped providers.
+        for (const [path] of preExtractedByPath) {
+            const lang = getLanguageFromFilename(path);
+            if (lang === null)
+                continue;
+            const provider = SCOPE_RESOLVERS.get(lang);
+            if (provider?.languageProvider.parseStrategy === 'standalone') {
+                preExtractedByPath.delete(path);
+            }
+        }
         let totalFiles = 0;
         let totalImports = 0;
         let totalRefs = 0;
@@ -114,6 +128,14 @@ export const scopeResolutionPhase = {
         for (const [lang, provider] of SCOPE_RESOLVERS) {
             if (!isRegistryPrimary(lang))
                 continue;
+            // Standalone providers (COBOL, JCL) don't emit graph edges yet
+            // through the scope-resolution path. This is the canonical guard:
+            // runScopeResolution is never called for standalone providers, which
+            // keeps cobolPhase as the sole IMPORTS edge producer. Keep this guard
+            // in sync with any additional standalone providers added to
+            // SCOPE_RESOLVERS.
+            if (provider.languageProvider.parseStrategy === 'standalone')
+                continue;
             const langFiles = scannedFiles.filter((f) => getLanguageFromFilename(f.path) === lang);
             if (langFiles.length === 0)
                 continue;

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

@@ -473,9 +473,29 @@ const processBatch = (files, onProgress) => {
     for (const [language, langFiles] of byLanguage) {
         const provider = getProvider(language);
         const queryString = provider.treeSitterQueries;
-        if (!queryString)
+        if (!queryString) {
+            // Standalone providers (regex-based, no tree-sitter) that implement
+            // emitScopeCaptures feed into the scope-resolution pipeline via
+            // extractParsedFile directly — no tree-sitter involved.
+            if (provider.emitScopeCaptures) {
+                for (const file of langFiles) {
+                    const parsedFile = extractParsedFile(provider, file.content, file.path, (message) => {
+                        if (parentPort) {
+                            parentPort.postMessage({ type: 'warning', message });
+                        }
+                        else {
+                            logger.warn(message);
+                        }
+                    }, undefined);
+                    if (parsedFile !== undefined) {
+                        result.parsedFiles.push(parsedFile);
+                        result.fileCount++;
+                        onFileProcessed?.();
+                    }
+                }
+            }
             continue;
-        // Track if we need to handle tsx separately
+        }
         const tsxFiles = [];
         const regularFiles = [];
         if (language === SupportedLanguages.TypeScript) {

package/package.json

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