gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/ingestion/languages/java/lombok-synthesizer.js

@@ -0,0 +1,439 @@
+/**
+ * Lombok accessor synthesizer for Java.
+ *
+ * Lombok generates getters/setters at compile time. They are absent from the
+ * AST, so calls like `obj.getOrderId()` on a `@Data` class would otherwise
+ * leave unresolved CALLS edges. This module walks the tree-sitter Java AST
+ * and synthesizes Method graph members for the accessors Lombok would emit
+ * under the supported subset.
+ *
+ * ## Supported subset (v1)
+ * - Proven `lombok.Data` / `lombok.Getter` / `lombok.Setter` (FQN or import).
+ * - Class- or field-level enable; `AccessLevel.NONE` disables.
+ * - Default JavaBeans naming; primitive `boolean isX` → `isX` / `setX`.
+ * - Access levels PUBLIC/PROTECTED/PRIVATE/PACKAGE.
+ * - `@Accessors(chain=true)` modeled as setter return = declaring type.
+ * - `@Accessors(fluent=true)` / `prefix=…`: omit affected accessors (names
+ *   cannot be proven without full Lombok config).
+ * - External `lombok.config`: unsupported (may change semantics invisibly).
+ *
+ * ## Identity
+ * Owner lookup uses in-memory AST node ids only. Method ids are derived from
+ * the stable declaring-owner graph key (the Class node id's name segment),
+ * never from persisted tree-sitter node ids.
+ */
+import { jvmGetterName, jvmSetterName } from '../jvm/beanspec.js';
+import { createExistingMethodIndex, createJvmAccessorSynthesis, hasExistingMethod, rememberExistingMethodRange, } from '../jvm/accessor-synthesis.js';
+const JAVA_TYPE_DECLS = new Set([
+    'class_declaration',
+    'enum_declaration',
+    'interface_declaration',
+    'record_declaration',
+]);
+const LOMBOK_ANNOTATION_PACKAGE = new Map([
+    ['Data', 'lombok'],
+    ['Getter', 'lombok'],
+    ['Setter', 'lombok'],
+    ['Accessors', 'lombok.experimental'],
+    ['Tolerate', 'lombok.experimental'],
+]);
+export function getterName(fieldName, fieldType) {
+    return jvmGetterName(fieldName, fieldType === 'boolean');
+}
+export function setterName(fieldName, fieldType) {
+    return jvmSetterName(fieldName, fieldType === 'boolean');
+}
+// ── Provenance / imports ──────────────────────────────────────────────────
+function annotationSimpleName(nameText) {
+    return nameText.split('.').pop() ?? nameText;
+}
+/**
+ * Compilation-unit imports only — Java `import` is never nested in a type body.
+ */
+function collectLombokImports(root) {
+    const bySimple = new Map();
+    const starPackages = new Set();
+    const shadowedSimpleNames = new Set();
+    for (const child of root.children) {
+        if (!JAVA_TYPE_DECLS.has(child.type) && child.type !== 'annotation_type_declaration')
+            continue;
+        const name = child.childForFieldName('name')?.text;
+        if (name)
+            shadowedSimpleNames.add(name);
+    }
+    for (const child of root.children) {
+        if (child.type !== 'import_declaration')
+            continue;
+        if (/^import\s+static\b/.test(child.text))
+            continue;
+        const text = child.text
+            .replace(/^import\s+/, '')
+            .replace(/;\s*$/, '')
+            .replace(/\/\*[\s\S]*?\*\//g, '')
+            .replace(/\s+/g, '')
+            .trim();
+        if (text === 'lombok.*') {
+            starPackages.add('lombok');
+        }
+        else if (text === 'lombok.experimental.*') {
+            starPackages.add('lombok.experimental');
+        }
+        else if (!text.endsWith('.*')) {
+            bySimple.set(annotationSimpleName(text), text);
+        }
+    }
+    return { bySimple, starPackages, shadowedSimpleNames };
+}
+function isProvenLombokAnnotation(nameText, imports) {
+    const simple = annotationSimpleName(nameText);
+    const packageName = LOMBOK_ANNOTATION_PACKAGE.get(simple);
+    if (packageName === undefined)
+        return false;
+    if (nameText.includes('.'))
+        return nameText === `${packageName}.${simple}`;
+    const imported = imports.bySimple.get(simple);
+    if (imported !== undefined)
+        return imported === `${packageName}.${simple}`;
+    if (imports.shadowedSimpleNames.has(simple))
+        return false;
+    return imports.starPackages.has(packageName);
+}
+// ── AccessLevel / Accessors structural parse ──────────────────────────────
+function parseAccessLevelToken(text) {
+    const simple = annotationSimpleName(text.trim());
+    switch (simple) {
+        case 'PUBLIC':
+            return 'public';
+        case 'PROTECTED':
+            return 'protected';
+        case 'PRIVATE':
+            return 'private';
+        case 'PACKAGE':
+        case 'MODULE': // treated as package-private for graph metadata
+            return 'package';
+        case 'NONE':
+            return 'none';
+        default:
+            return null;
+    }
+}
+function findAccessLevelInAnnotation(ann) {
+    // Positional: @Getter(AccessLevel.PROTECTED) or @Getter(lombok.AccessLevel.NONE)
+    // Named: @Getter(value = AccessLevel.PRIVATE)
+    const stack = [...ann.children];
+    while (stack.length > 0) {
+        const n = stack.pop();
+        if (!n)
+            break;
+        if (n.type === 'field_access' || n.type === 'identifier') {
+            const level = parseAccessLevelToken(n.text);
+            if (level !== null)
+                return level;
+        }
+        for (const c of n.children)
+            stack.push(c);
+    }
+    return null;
+}
+function defaultAccessors() {
+    return { fluent: false, hasPrefix: false, chain: false };
+}
+function parseAccessorsAnnotation(ann) {
+    const opts = defaultAccessors();
+    const stack = [...ann.children];
+    while (stack.length > 0) {
+        const n = stack.pop();
+        if (!n)
+            break;
+        if (n.type === 'element_value_pair') {
+            const key = n.childForFieldName('key')?.text ?? n.children.find((c) => c.type === 'identifier')?.text;
+            const valueNode = n.childForFieldName('value') ??
+                n.children.find((c) => c.type === 'true' || c.type === 'false' || c.type === 'element_value_array_initializer');
+            if (key === 'fluent' && (valueNode?.type === 'true' || valueNode?.type === 'false')) {
+                opts.fluent = valueNode.type === 'true';
+            }
+            if (key === 'chain' && (valueNode?.type === 'true' || valueNode?.type === 'false')) {
+                opts.chain = valueNode.type === 'true';
+            }
+            if (key === 'prefix')
+                opts.hasPrefix = true;
+        }
+        for (const c of n.children)
+            stack.push(c);
+    }
+    const text = ann.text;
+    if (/\bprefix\s*=/.test(text))
+        opts.hasPrefix = true;
+    if (/\bfluent\s*=\s*true\b/.test(text))
+        opts.fluent = true;
+    if (/\bfluent\s*=\s*false\b/.test(text))
+        opts.fluent = false;
+    if (/\bchain\s*=\s*true\b/.test(text))
+        opts.chain = true;
+    if (/\bchain\s*=\s*false\b/.test(text))
+        opts.chain = false;
+    return opts;
+}
+function parseModifierAnnotations(modifiersNode, imports) {
+    const result = {
+        getter: null,
+        setter: null,
+        accessors: defaultAccessors(),
+        accessorsPresent: false,
+        tolerate: false,
+    };
+    if (!modifiersNode)
+        return result;
+    for (const child of modifiersNode.children) {
+        if (child.type !== 'marker_annotation' && child.type !== 'annotation')
+            continue;
+        const nameNode = child.childForFieldName('name');
+        const nameText = nameNode?.text ?? '';
+        if (!isProvenLombokAnnotation(nameText, imports))
+            continue;
+        const simple = annotationSimpleName(nameText);
+        if (simple === 'Tolerate') {
+            result.tolerate = true;
+            continue;
+        }
+        if (simple === 'Accessors') {
+            result.accessors = parseAccessorsAnnotation(child);
+            result.accessorsPresent = true;
+            continue;
+        }
+        if (simple === 'Data') {
+            result.getter ??= { enabled: true, visibility: 'public' };
+            result.setter ??= { enabled: true, visibility: 'public' };
+            continue;
+        }
+        if (simple === 'Getter' || simple === 'Setter') {
+            const level = child.type === 'annotation' ? findAccessLevelInAnnotation(child) : null;
+            const cfg = level === 'none'
+                ? { enabled: false, visibility: 'public' }
+                : { enabled: true, visibility: level ?? 'public' };
+            if (simple === 'Getter')
+                result.getter = cfg;
+            else
+                result.setter = cfg;
+        }
+    }
+    return result;
+}
+function mergeAccessors(classOpts, fieldOpts, fieldAccessorsPresent) {
+    return fieldAccessorsPresent ? fieldOpts : classOpts;
+}
+function effectiveAccessor(classCfg, fieldCfg) {
+    if (fieldCfg !== null)
+        return fieldCfg;
+    return classCfg;
+}
+// ── Field / method collection ─────────────────────────────────────────────
+function parseFieldDeclaration(fieldNode, imports) {
+    const typeNode = fieldNode.childForFieldName('type');
+    const fieldType = typeNode?.text ?? 'Object';
+    const modifiers = fieldNode.children.find((c) => c.type === 'modifiers') ?? null;
+    let isStatic = false;
+    let isFinal = false;
+    if (modifiers) {
+        for (const mod of modifiers.children) {
+            if (mod.text === 'static')
+                isStatic = true;
+            else if (mod.text === 'final')
+                isFinal = true;
+        }
+    }
+    const fieldAnn = parseModifierAnnotations(modifiers, imports);
+    const declarators = [];
+    const declaratorField = fieldNode.childForFieldName('declarator');
+    if (declaratorField)
+        declarators.push(declaratorField);
+    for (const child of fieldNode.children) {
+        if (child.type === 'variable_declarator' && child !== declaratorField) {
+            declarators.push(child);
+        }
+    }
+    const startLine = fieldNode.startPosition.row + 1;
+    const endLine = fieldNode.endPosition.row + 1;
+    const out = [];
+    for (const declaratorNode of declarators) {
+        const nameNode = declaratorNode.childForFieldName('name');
+        if (!nameNode)
+            continue;
+        out.push({
+            name: nameNode.text,
+            type: fieldType,
+            isStatic,
+            isFinal,
+            startLine,
+            endLine,
+            declaratorNode,
+            fieldGetter: fieldAnn.getter,
+            fieldSetter: fieldAnn.setter,
+            accessors: fieldAnn.accessors,
+            accessorsPresent: fieldAnn.accessorsPresent,
+        });
+    }
+    return out;
+}
+function methodArityRange(methodNode) {
+    const params = methodNode.childForFieldName('parameters');
+    if (!params)
+        return { min: 0, max: 0 };
+    let count = 0;
+    for (const child of params.namedChildren) {
+        if (child.type === 'spread_parameter')
+            return { min: count, max: Number.POSITIVE_INFINITY };
+        if (child.type === 'formal_parameter')
+            count += 1;
+    }
+    return { min: count, max: count };
+}
+function collectExistingMethods(classBody, imports) {
+    const index = createExistingMethodIndex('case-folded');
+    if (!classBody)
+        return index;
+    const scan = (container) => {
+        for (const child of container.children) {
+            if (child.type === 'enum_body_declarations') {
+                scan(child);
+                continue;
+            }
+            if (child.type !== 'method_declaration')
+                continue;
+            const mods = child.children.find((c) => c.type === 'modifiers') ?? null;
+            const ann = parseModifierAnnotations(mods, imports);
+            if (ann.tolerate)
+                continue;
+            const nameNode = child.childForFieldName('name');
+            if (!nameNode)
+                continue;
+            const arity = methodArityRange(child);
+            rememberExistingMethodRange(index, nameNode.text, arity.min, arity.max);
+        }
+    };
+    scan(classBody);
+    return index;
+}
+const TYPE_BODIES = new Set(['class_body', 'enum_body']);
+function findTypeBody(node) {
+    return node.children.find((c) => TYPE_BODIES.has(c.type)) ?? null;
+}
+function findLombokClasses(root, imports) {
+    const classes = [];
+    function walk(node) {
+        if (node.type === 'class_declaration' || node.type === 'enum_declaration') {
+            const modifiers = node.children.find((c) => c.type === 'modifiers') ?? null;
+            const classAnn = parseModifierAnnotations(modifiers, imports);
+            const nameNode = node.childForFieldName('name');
+            const className = nameNode?.text ?? '';
+            if (className) {
+                const body = findTypeBody(node);
+                const fields = [];
+                if (body) {
+                    const collectFields = (container) => {
+                        for (const child of container.children) {
+                            if (child.type === 'field_declaration') {
+                                for (const f of parseFieldDeclaration(child, imports)) {
+                                    if (f.isStatic)
+                                        continue;
+                                    fields.push(f);
+                                }
+                            }
+                            else if (child.type === 'enum_body_declarations') {
+                                collectFields(child);
+                            }
+                        }
+                    };
+                    collectFields(body);
+                }
+                const anyFieldEnable = fields.some((f) => f.fieldGetter?.enabled === true || f.fieldSetter?.enabled === true);
+                const classEnable = classAnn.getter?.enabled === true || classAnn.setter?.enabled === true;
+                // Class-level NONE alone is not enable — getter/setter configs may be disabled
+                if (classEnable || anyFieldEnable) {
+                    classes.push({
+                        node,
+                        name: className,
+                        classGetter: classAnn.getter,
+                        classSetter: classAnn.setter,
+                        classAccessors: classAnn.accessors,
+                        fields,
+                        existingMethods: collectExistingMethods(body, imports),
+                    });
+                }
+            }
+        }
+        for (const child of node.children)
+            walk(child);
+    }
+    walk(root);
+    return classes;
+}
+function planAccessors(cls) {
+    const planned = [];
+    for (const field of cls.fields) {
+        const accessors = mergeAccessors(cls.classAccessors, field.accessors, field.accessorsPresent);
+        // fluent/prefix change names — omit rather than invent wrong names
+        if (accessors.fluent || accessors.hasPrefix)
+            continue;
+        const getterCfg = effectiveAccessor(cls.classGetter, field.fieldGetter);
+        const setterCfg = effectiveAccessor(cls.classSetter, field.fieldSetter);
+        if (getterCfg?.enabled) {
+            const gName = getterName(field.name, field.type);
+            if (!hasExistingMethod(cls.existingMethods, gName, 0)) {
+                planned.push({
+                    kind: 'getter',
+                    name: gName,
+                    returnType: field.type,
+                    parameterTypes: [],
+                    visibility: getterCfg.visibility,
+                    isStatic: false,
+                    isAbstract: false,
+                    startLine: field.startLine,
+                    endLine: field.endLine,
+                    declaratorNode: field.declaratorNode,
+                });
+            }
+        }
+        if (setterCfg?.enabled && !field.isFinal) {
+            const sName = setterName(field.name, field.type);
+            if (!hasExistingMethod(cls.existingMethods, sName, 1)) {
+                // chain=true → setter returns declaring type; never emit void in that case
+                const returnType = accessors.chain ? cls.name : 'void';
+                planned.push({
+                    kind: 'setter',
+                    name: sName,
+                    returnType,
+                    parameterTypes: [field.type],
+                    visibility: setterCfg.visibility,
+                    isStatic: false,
+                    isAbstract: false,
+                    startLine: field.startLine,
+                    endLine: field.endLine,
+                    declaratorNode: field.declaratorNode,
+                });
+            }
+        }
+    }
+    return planned;
+}
+function planLombokAccessorOwners(root) {
+    const imports = collectLombokImports(root);
+    return findLombokClasses(root, imports).map((cls) => ({
+        node: cls.node,
+        name: cls.name,
+        accessors: planAccessors(cls),
+    }));
+}
+const lombokAccessorSynthesis = createJvmAccessorSynthesis({
+    language: 'java',
+    synthetic: 'lombok',
+    planOwners: planLombokAccessorOwners,
+});
+// ── Main API ──────────────────────────────────────────────────────────────
+export function synthesizeLombokAccessors(tree, filePath, classOwnersById) {
+    return lombokAccessorSynthesis.synthesize(tree, filePath, classOwnersById);
+}
+/** Scope captures for Lombok accessors (dual-path parity with record components). */
+export function synthesizeLombokAccessorCaptures(rootNode) {
+    return lombokAccessorSynthesis.captures(rootNode);
+}

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

@@ -19,6 +19,7 @@ import { attachJavaSpringConfigBindings } from './spring-config-bindings.js';
 import { attachJavaSpringConditionalMetadata } from './spring-conditionals.js';
 import { attachJavaSpringDiMetadata } from './spring-di.js';
 import { attachJavaSpringNonHttpHandlerMetadata } from './spring-non-http-handlers.js';
+import { attachJavaSpringDynamicLookup } from './spring-dynamic-lookup.js';
 import { applyJavaCaptureSideChannel, clearJavaClassAnnotationFacts, } from './capture-side-channel.js';
 import { clearJavaPackageFacts } from './package-facts.js';
 const javaScopeResolver = {
@@ -65,6 +66,7 @@ const javaScopeResolver = {
         attachJavaSpringDiMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachJavaSpringNonHttpHandlerMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachJavaSpringConfigBindings(graph, parsedFiles, nodeLookup, indexes, ctx);
+        attachJavaSpringDynamicLookup(graph, parsedFiles, nodeLookup, indexes);
     },
 };
 export { javaScopeResolver };

package/dist/core/ingestion/languages/java/spring-actuator.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeSymbolStrategy } from '../../language-provider.js';
+export declare const javaRuntimeSymbolStrategy: RuntimeSymbolStrategy;

package/dist/core/ingestion/languages/java/spring-actuator.js

@@ -0,0 +1,62 @@
+const JVM_PRIMITIVES = {
+    B: 'byte',
+    C: 'char',
+    D: 'double',
+    F: 'float',
+    I: 'int',
+    J: 'long',
+    S: 'short',
+    Z: 'boolean',
+};
+function normalizedType(value, runtime) {
+    let erased = value.trim();
+    let arrayDimensions = 0;
+    if (erased.endsWith('...')) {
+        arrayDimensions++;
+        erased = erased.slice(0, -3);
+    }
+    while (erased.endsWith('[]')) {
+        arrayDimensions++;
+        erased = erased.slice(0, -2);
+    }
+    erased = erased.replace(/<.*>$/, '').replaceAll('$', '.').replaceAll('/', '.');
+    const simple = erased.slice(erased.lastIndexOf('.') + 1);
+    const base = runtime ? (JVM_PRIMITIVES[simple] ?? simple) : simple;
+    return `${base}${'[]'.repeat(arrayDimensions)}`;
+}
+function sourceTypeIsUnknown(value) {
+    const type = normalizedType(value, false).replace(/(?:\[\])+$/, '');
+    return type === '?' || /^[A-Z]$/.test(type);
+}
+function matchesJavaCallable(node, runtime) {
+    if (node.label !== 'Method' || node.properties.name !== runtime.name)
+        return false;
+    const descriptorTypes = runtime.descriptorParameterTypes;
+    if (descriptorTypes === undefined)
+        return true;
+    const parameterCount = node.properties.parameterCount;
+    if (typeof parameterCount === 'number' && parameterCount !== descriptorTypes.length)
+        return false;
+    const sourceTypes = node.properties.parameterTypes;
+    if (!Array.isArray(sourceTypes) ||
+        sourceTypes.length !== descriptorTypes.length ||
+        !sourceTypes.every((type) => typeof type === 'string')) {
+        return true;
+    }
+    return sourceTypes.every((sourceType, index) => {
+        if (sourceTypeIsUnknown(sourceType))
+            return true;
+        const source = normalizedType(sourceType, false);
+        const descriptor = normalizedType(descriptorTypes[index] ?? '', true);
+        if (source === descriptor)
+            return true;
+        // Java parser metadata currently drops the ellipsis from varargs and also
+        // leaves parameterCount open-ended. Only in that shape may T match JVM T[].
+        return (typeof parameterCount !== 'number' &&
+            descriptor.endsWith('[]') &&
+            source === descriptor.slice(0, -2));
+    });
+}
+export const javaRuntimeSymbolStrategy = {
+    matchesCallable: matchesJavaCallable,
+};

package/dist/core/ingestion/languages/java/spring-di.d.ts

@@ -1,13 +1,29 @@
 import { type SpringDiAnnotationFact, type SpringDiClassFact, type SpringDiDependencyFact, type SpringDiInjectionSiteFact } from '../../frameworks/spring/di-metadata.js';
+import { type SpringArgumentFact } from '../../frameworks/spring/argument-facts.js';
 import { type SyntaxNode } from '../../utils/ast-helpers.js';
 export interface JavaAnnotationSyntaxFact extends SpringDiAnnotationFact {
     readonly line: number;
+    /** Present only for callers that opt in via `javaSpringAnnotationFacts`. */
+    readonly args?: readonly SpringArgumentFact[];
+}
+/**
+ * Options for `javaSpringAnnotationFacts`.
+ *
+ * The STRUCTURED arguments are opt-in because DI captures every annotated
+ * field, constructor, and method in the repository, and none of its consumers
+ * reads them. Note what this does and does not save: every fact already carries
+ * `text`, the annotation's full source, so the argument TEXT crosses the worker
+ * boundary either way. What the opt-in avoids is a second, parsed copy of that
+ * same text on facts that would never look at it.
+ */
+export interface JavaSpringAnnotationFactOptions {
+    readonly includeArguments?: boolean;
 }
 export type JavaSpringDependencyFact = SpringDiDependencyFact<JavaAnnotationSyntaxFact>;
 type JavaSpringInjectionSiteKind = 'field' | 'constructor' | 'method';
 export type JavaSpringInjectionSiteFact = SpringDiInjectionSiteFact<JavaAnnotationSyntaxFact, JavaSpringInjectionSiteKind>;
 export type JavaSpringDiClassFact = SpringDiClassFact<JavaAnnotationSyntaxFact, JavaSpringInjectionSiteKind>;
-export declare function javaSpringAnnotationFacts(node: SyntaxNode): JavaAnnotationSyntaxFact[];
+export declare function javaSpringAnnotationFacts(node: SyntaxNode, options?: JavaSpringAnnotationFactOptions): JavaAnnotationSyntaxFact[];
 /**
  * Capture one class already surfaced by Java's scope query.
  *

package/dist/core/ingestion/languages/java/spring-di.js

@@ -1,11 +1,51 @@
 import { makeScopeId } from '../../../../_shared/index.js';
 import { createSpringDiMetadataAttacher, hasSpringDiRelevantAnnotation, hasSpringStereotypeSyntax, } from '../../frameworks/spring/di-metadata.js';
 import { hasSpringBeanFactorySyntax, } from '../../frameworks/spring/bean-factories.js';
+import { normalizeSpringFactText, } from '../../frameworks/spring/argument-facts.js';
 import { parseSpringInjectionType } from '../../di-extractors/spring.js';
-import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { hasRecoveredSyntax, nodeToCapture } from '../../utils/ast-helpers.js';
 import { isJavaPackageSiblingVisibilityIncomplete } from './package-siblings.js';
 import { getJavaSpringDiFacts } from './capture-side-channel.js';
-export function javaSpringAnnotationFacts(node) {
+const JAVA_COMMENT_NODE_TYPES = new Set(['line_comment', 'block_comment']);
+/**
+ * Annotation arguments as written, or `undefined` for a marker annotation.
+ *
+ * `@Scheduled` yields `undefined` (no argument list in the syntax) while
+ * `@Scheduled()` yields `[]` (an empty list was written). Named arguments keep
+ * their key, single-element ones stay positional, and array initializers are
+ * kept as one raw `{...}` text — splitting or dereferencing them would be
+ * resolution, which does not belong at capture time.
+ *
+ * An argument list that did not parse also yields `undefined`. Error recovery
+ * fills gaps with invented nodes — `@KafkaListener(topics = "orders", groupId =`
+ * hands back a `groupId` whose value is a `{}` that nobody wrote — and there is
+ * no fourth state here for "unreadable". Collapsing it into the marker case is
+ * deliberate: both tell a consumer there is nothing here to resolve, which is
+ * true, whereas a fabricated value would send it somewhere real and wrong.
+ */
+function javaAnnotationArgumentFacts(annotation) {
+    const argumentList = annotation.childForFieldName('arguments');
+    if (argumentList === null || hasRecoveredSyntax(argumentList))
+        return undefined;
+    const args = [];
+    for (const child of argumentList.namedChildren) {
+        if (JAVA_COMMENT_NODE_TYPES.has(child.type))
+            continue;
+        if (child.type === 'element_value_pair') {
+            const key = child.childForFieldName('key');
+            const value = child.childForFieldName('value');
+            if (key === null || value === null) {
+                args.push({ text: normalizeSpringFactText(child.text) });
+                continue;
+            }
+            args.push({ name: key.text.trim(), text: normalizeSpringFactText(value.text) });
+            continue;
+        }
+        args.push({ text: normalizeSpringFactText(child.text) });
+    }
+    return args;
+}
+export function javaSpringAnnotationFacts(node, options = {}) {
     const facts = [];
     for (const child of node.namedChildren) {
         if (child.type !== 'modifiers')
@@ -16,10 +56,12 @@ export function javaSpringAnnotationFacts(node) {
             const nameNode = modifier.childForFieldName('name') ?? modifier.firstNamedChild;
             if (nameNode === null)
                 continue;
+            const args = options.includeArguments === true ? javaAnnotationArgumentFacts(modifier) : undefined;
             facts.push({
                 name: nameNode.text.trim(),
                 text: modifier.text.trim(),
                 line: modifier.startPosition.row + 1,
+                ...(args === undefined ? {} : { args }),
             });
         }
     }

package/dist/core/ingestion/languages/java/spring-dynamic-lookup.d.ts

@@ -0,0 +1,8 @@
+import { type SpringDynamicLookupFact } from '../../frameworks/spring/dynamic-lookups.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/** Capture real Java method invocations; comments and literals are never visited as calls. */
+export declare function captureJavaSpringDynamicLookupFact(node: SyntaxNode, filePath: string): SpringDynamicLookupFact | null;
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export declare function captureJavaSpringDynamicLookupFacts(rootNode: SyntaxNode, filePath: string): SpringDynamicLookupFact[];
+/** Attach Java lookup facts for later resolution by the shared DI phase. */
+export declare const attachJavaSpringDynamicLookup: (graph: import("../../../graph/types.js").KnowledgeGraph, parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], nodeLookup: import("../../scope-resolution/graph-bridge/node-lookup.js").GraphNodeLookup, indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes) => void;