gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/ingestion/frameworks/spring/analysis-features.d.ts

@@ -7,3 +7,8 @@ export declare const SPRING_CONDITIONALS_FEATURE: AnalysisFeatureDescriptor;
 export declare const SPRING_AOP_FEATURE: AnalysisFeatureDescriptor;
 /** Durable completeness contract for scheduled, event, messaging, and job entry points (#2417). */
 export declare const SPRING_NON_HTTP_HANDLERS_FEATURE: AnalysisFeatureDescriptor;
+/**
+ * Route/handler binding extraction, including vendor `@Win*Mapping` aliases.
+ * Existing indexes keep a stale Route set until this version is stamped.
+ */
+export declare const SPRING_ROUTE_BINDINGS_FEATURE: AnalysisFeatureDescriptor;

package/dist/core/ingestion/frameworks/spring/analysis-features.js

@@ -39,3 +39,12 @@ export const SPRING_NON_HTTP_HANDLERS_FEATURE = {
     version: 1,
     appliesTo: (filePaths) => filePaths.some(isJvmSourceFile),
 };
+/**
+ * Route/handler binding extraction, including vendor `@Win*Mapping` aliases.
+ * Existing indexes keep a stale Route set until this version is stamped.
+ */
+export const SPRING_ROUTE_BINDINGS_FEATURE = {
+    id: 'spring.route-bindings',
+    version: 2,
+    appliesTo: (filePaths) => filePaths.some(isJvmSourceFile),
+};

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/frameworks/spring/argument-facts.d.ts

@@ -0,0 +1,80 @@
+/**
+ * One argument of a Spring annotation or of a messaging-template call, captured
+ * exactly as it is written in source.
+ *
+ * Capture-time facts are deliberately UNRESOLVED. When these facts are produced
+ * the file's imports are not finalized, constants declared in sibling files do
+ * not exist yet, and no configuration source has been read — so a captured
+ * `text` may be a string literal, a constant reference (`Destinations.ORDERS`),
+ * a property placeholder (`"${app.orders.topic}"`), or an arbitrary expression.
+ * Turning any of those into an address is a separate, later phase; nothing here
+ * may call a resolver.
+ *
+ * NOT the same thing as `SpringAnnotationArgument` in `annotation-arguments.ts`,
+ * and the two are deliberately not merged:
+ *
+ *  - Source. This fact is built from AST nodes while the tree is in hand;
+ *    `parseSpringAnnotationArguments` re-parses an annotation's `text` much
+ *    later, from a string, with a hand-written delimiter scanner.
+ *  - Failure. The text parser returns `null` when its scanner cannot balance
+ *    the input, and a caller must decide what that means. There is no such
+ *    state here: the grammar has already decided where each argument begins
+ *    and ends.
+ *  - Absence. The text parser answers `[]` both for `@Scheduled` and for
+ *    `@Scheduled()`, because a string cannot tell "no list" from "empty list"
+ *    without re-deriving it. Capture keeps the two apart — absent versus `[]` —
+ *    so downstream code can rely on the distinction wherever arguments were
+ *    read at all. A capture that reads them for only some of its facts says so
+ *    on its own `args` field.
+ *  - Scope. This fact also describes CALL arguments (`template.send(topic, p)`),
+ *    which the annotation parser has no notion of.
+ *
+ * Collapsing them would mean giving the text parser a failure mode it cannot
+ * produce, or taking the three-state distinction away from capture.
+ */
+export interface SpringArgumentFact {
+    /**
+     * Argument name for a named argument, absent for a positional one.
+     *
+     * Both forms occur, and where the destination sits differs by construct. An
+     * annotation names it (`@KafkaListener(topics = ...)` versus
+     * `@RabbitListener(queues = ...)`). A call normally gives it by position
+     * (`kafkaTemplate.send(topic, payload)`) — always so in Java, which has no
+     * named arguments — but a Kotlin call may name its arguments whenever the
+     * callee is itself declared in Kotlin, and then the key is captured too.
+     */
+    readonly name?: string;
+    /**
+     * Argument value in its source spelling — quotes, braces and casts intact,
+     * nothing resolved — after `normalizeSpringFactText`. That pass trims the
+     * text and collapses whitespace around the dots of a multi-line expression,
+     * so one destination written two ways yields one fact. It is the only
+     * rewrite; see the function for why formatting must not reach the data.
+     */
+    readonly text: string;
+}
+/**
+ * Join an expression that the source wrapped across lines, so that one
+ * expression has one spelling no matter where it was written.
+ *
+ * A receiver chain written as `outer\n    .inner\n    .kafkaTemplate`, and an
+ * argument written as `Destinations\n    .ORDERS`, are the same expressions as
+ * their single-line spellings. Raw node text would carry the newline and the
+ * ENCLOSING BLOCK's indentation across the worker boundary, so the same
+ * expression at two nesting depths — or in a CRLF checkout — would not compare
+ * equal downstream. Receivers and arguments get the identical treatment on
+ * purpose: an inconsistent rule inside one fact is a trap for the phase that
+ * has to match a publish against a subscription.
+ *
+ * Only a run of whitespace that CONTAINS A NEWLINE and sits next to a dot is
+ * removed, and only OUTSIDE a string literal. Single-line spacing is left
+ * alone, so `registry.get("a . b").template` keeps its argument exactly as
+ * written; literal-awareness extends that to Java text blocks and Kotlin raw
+ * strings, whose embedded newlines are part of the value and must survive
+ * (`"""line-a\n.line-b"""` is not the same string as `"""line-a.line-b"""`).
+ *
+ * Wraps that are not adjacent to a dot (`"a" +\n  "b"`) are left as written:
+ * normalizing them would have to reason about operators, and the same
+ * conservatism already applies to receivers.
+ */
+export declare function normalizeSpringFactText(text: string): string;

package/dist/core/ingestion/frameworks/spring/argument-facts.js

@@ -0,0 +1,85 @@
+/**
+ * Join an expression that the source wrapped across lines, so that one
+ * expression has one spelling no matter where it was written.
+ *
+ * A receiver chain written as `outer\n    .inner\n    .kafkaTemplate`, and an
+ * argument written as `Destinations\n    .ORDERS`, are the same expressions as
+ * their single-line spellings. Raw node text would carry the newline and the
+ * ENCLOSING BLOCK's indentation across the worker boundary, so the same
+ * expression at two nesting depths — or in a CRLF checkout — would not compare
+ * equal downstream. Receivers and arguments get the identical treatment on
+ * purpose: an inconsistent rule inside one fact is a trap for the phase that
+ * has to match a publish against a subscription.
+ *
+ * Only a run of whitespace that CONTAINS A NEWLINE and sits next to a dot is
+ * removed, and only OUTSIDE a string literal. Single-line spacing is left
+ * alone, so `registry.get("a . b").template` keeps its argument exactly as
+ * written; literal-awareness extends that to Java text blocks and Kotlin raw
+ * strings, whose embedded newlines are part of the value and must survive
+ * (`"""line-a\n.line-b"""` is not the same string as `"""line-a.line-b"""`).
+ *
+ * Wraps that are not adjacent to a dot (`"a" +\n  "b"`) are left as written:
+ * normalizing them would have to reason about operators, and the same
+ * conservatism already applies to receivers.
+ */
+export function normalizeSpringFactText(text) {
+    const trimmed = text.trim();
+    // Fast path: the overwhelming majority of captured text is single-line.
+    if (!trimmed.includes('\n') && !trimmed.includes('\r'))
+        return trimmed;
+    let out = '';
+    let index = 0;
+    let quote = null;
+    while (index < trimmed.length) {
+        const char = trimmed[index];
+        if (quote === '"""') {
+            if (trimmed.startsWith('"""', index)) {
+                out += '"""';
+                index += 3;
+                quote = null;
+                continue;
+            }
+            out += char;
+            index += 1;
+            continue;
+        }
+        if (quote !== null) {
+            // A backslash escape is copied whole so that `"\\"` ends the literal and
+            // `"\""` does not.
+            if (char === '\\' && index + 1 < trimmed.length) {
+                out += trimmed.slice(index, index + 2);
+                index += 2;
+                continue;
+            }
+            if (char === quote)
+                quote = null;
+            out += char;
+            index += 1;
+            continue;
+        }
+        if (trimmed.startsWith('"""', index)) {
+            quote = '"""';
+            out += '"""';
+            index += 3;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            out += char;
+            index += 1;
+            continue;
+        }
+        if (char === '.' || /\s/.test(char)) {
+            const separator = /^\s*\.\s*/.exec(trimmed.slice(index));
+            if (separator !== null) {
+                const matched = separator[0];
+                out += matched.includes('\n') ? '.' : matched;
+                index += matched.length;
+                continue;
+            }
+        }
+        out += char;
+        index += 1;
+    }
+    return out;
+}

package/dist/core/ingestion/frameworks/spring/config-bindings.d.ts

@@ -1,5 +1,6 @@
 import type { KnowledgeGraph } from '../../../graph/types.js';
 export declare const SPRING_CONFIG_DESCRIPTION = "Spring configuration property";
+export declare const SPRING_CONFIG_UNRESOLVED_PREFIX = "Spring config unresolved: ";
 export interface SpringValueConsumer {
     readonly kind: 'value';
     readonly fieldName: string;

package/dist/core/ingestion/frameworks/spring/config-bindings.js

@@ -1,5 +1,6 @@
 import { generateId } from '../../../../lib/utils.js';
 export const SPRING_CONFIG_DESCRIPTION = 'Spring configuration property';
+export const SPRING_CONFIG_UNRESOLVED_PREFIX = 'Spring config unresolved: ';
 function closestNode(candidates, filePath, name, line) {
     return candidates
         .filter((node) => node.properties.filePath === filePath && node.properties.name === name)
@@ -7,7 +8,7 @@ function closestNode(candidates, filePath, name, line) {
         Math.abs(Number(right.properties.startLine ?? 0) - line))[0];
 }
 function markUnresolved(node, key) {
-    const marker = `Spring config unresolved: ${key}`;
+    const marker = `${SPRING_CONFIG_UNRESOLVED_PREFIX}${key}`;
     const existing = typeof node.properties.description === 'string' ? node.properties.description : '';
     if (existing.includes(marker))
         return;