gitnexus 1.6.10-rc.69 → 1.6.10-rc.70

package/dist/core/ingestion/frameworks/spring/bean-candidates.d.ts

@@ -20,5 +20,11 @@ export interface SpringBeanCandidateAdapter {
     getClassAnnotationFacts(filePath: string): readonly ClassAnnotationFact[];
     isPackageVisibilityIncomplete(filePath: string): boolean;
 }
+type RecognizedAnnotationNames = {
+    readonly has: (value: string) => boolean;
+};
+/** Build a scope-aware Spring annotation resolver shared by framework hooks. */
+export declare function createSpringAnnotationNameResolver(indexes: ScopeResolutionIndexes): (rawName: string, parsed: ParsedFile, enclosingScope: ScopeId | null, recognizedAnnotations: RecognizedAnnotationNames, isPackageVisibilityIncomplete: boolean) => string | undefined;
 /** Build a language hook that enriches Class nodes after scope resolution. */
 export declare function createSpringBeanCandidateAttacher(adapter: SpringBeanCandidateAdapter): (graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes) => void;
+export {};

package/dist/core/ingestion/frameworks/spring/bean-candidates.js

@@ -114,7 +114,7 @@ function hasVisibleTypeBinding(startScope, simpleName, indexes) {
     }
     return false;
 }
-function wildcardImportTarget(parsed, simpleName) {
+function wildcardImportTarget(parsed, simpleName, recognizedAnnotations) {
     const wildcardPackages = new Set(parsed.parsedImports
         .filter((entry) => entry.kind === 'wildcard')
         .map((entry) => entry.targetRaw.replace(/\.\*$/, '')));
@@ -122,33 +122,37 @@ function wildcardImportTarget(parsed, simpleName) {
         return undefined;
     const [packageName] = wildcardPackages;
     const target = `${packageName}.${simpleName}`;
-    return SPRING_BEAN_STEREOTYPES.has(target) ? target : undefined;
+    return recognizedAnnotations.has(target) ? target : undefined;
 }
-function resolveSpringAnnotation(rawName, parsed, enclosingScope, indexes, ownedTypeNamesByOwner, isPackageVisibilityIncomplete) {
-    if (rawName.includes('.')) {
-        return SPRING_BEAN_STEREOTYPES.has(rawName) ? rawName : undefined;
-    }
-    if (hasLexicalTypeDeclaration(enclosingScope, rawName, indexes))
-        return undefined;
-    if (hasInheritedTypeDeclaration(enclosingScope, rawName, indexes, ownedTypeNamesByOwner)) {
-        return undefined;
-    }
-    const explicitImports = explicitImportTargets(parsed, rawName);
-    if (explicitImports.size > 0) {
-        if (explicitImports.size !== 1)
+/** Build a scope-aware Spring annotation resolver shared by framework hooks. */
+export function createSpringAnnotationNameResolver(indexes) {
+    const ownedTypeNamesByOwner = buildOwnedTypeNamesByOwner(indexes);
+    return (rawName, parsed, enclosingScope, recognizedAnnotations, isPackageVisibilityIncomplete) => {
+        if (rawName.includes('.')) {
+            return recognizedAnnotations.has(rawName) ? rawName : undefined;
+        }
+        if (hasLexicalTypeDeclaration(enclosingScope, rawName, indexes))
             return undefined;
-        const [imported] = explicitImports;
-        return SPRING_BEAN_STEREOTYPES.has(imported) ? imported : undefined;
-    }
-    const wildcardTarget = wildcardImportTarget(parsed, rawName);
-    if (wildcardTarget === undefined || isPackageVisibilityIncomplete)
-        return undefined;
-    return hasVisibleTypeBinding(enclosingScope, rawName, indexes) ? undefined : wildcardTarget;
+        if (hasInheritedTypeDeclaration(enclosingScope, rawName, indexes, ownedTypeNamesByOwner)) {
+            return undefined;
+        }
+        const explicitImports = explicitImportTargets(parsed, rawName);
+        if (explicitImports.size > 0) {
+            if (explicitImports.size !== 1)
+                return undefined;
+            const [imported] = explicitImports;
+            return recognizedAnnotations.has(imported) ? imported : undefined;
+        }
+        const wildcardTarget = wildcardImportTarget(parsed, rawName, recognizedAnnotations);
+        if (wildcardTarget === undefined || isPackageVisibilityIncomplete)
+            return undefined;
+        return hasVisibleTypeBinding(enclosingScope, rawName, indexes) ? undefined : wildcardTarget;
+    };
 }
 /** Build a language hook that enriches Class nodes after scope resolution. */
 export function createSpringBeanCandidateAttacher(adapter) {
     return (graph, parsedFiles, nodeLookup, indexes) => {
-        const ownedTypeNamesByOwner = buildOwnedTypeNamesByOwner(indexes);
+        const resolveSpringAnnotation = createSpringAnnotationNameResolver(indexes);
         for (const parsed of parsedFiles) {
             for (const fact of adapter.getClassAnnotationFacts(parsed.filePath)) {
                 const classScope = indexes.scopeTree.getScope(fact.classScopeId);
@@ -165,7 +169,7 @@ export function createSpringBeanCandidateAttacher(adapter) {
                     continue;
                 const recognized = new Set();
                 for (const rawName of fact.annotationNames) {
-                    const annotation = resolveSpringAnnotation(rawName, parsed, classScope.parent, indexes, ownedTypeNamesByOwner, adapter.isPackageVisibilityIncomplete(parsed.filePath));
+                    const annotation = resolveSpringAnnotation(rawName, parsed, classScope.parent, SPRING_BEAN_STEREOTYPES, adapter.isPackageVisibilityIncomplete(parsed.filePath));
                     if (annotation !== undefined)
                         recognized.add(annotation);
                 }

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

@@ -0,0 +1,24 @@
+import type { KnowledgeGraph } from '../../../graph/types.js';
+export declare const SPRING_CONFIG_DESCRIPTION = "Spring configuration property";
+export interface SpringValueConsumer {
+    readonly kind: 'value';
+    readonly fieldName: string;
+    readonly line: number;
+    readonly keys: readonly string[];
+}
+export interface SpringConfigurationPropertiesConsumer {
+    readonly kind: 'configuration-properties';
+    readonly className: string;
+    readonly line: number;
+    readonly prefix: string;
+}
+export type SpringConfigConsumer = SpringValueConsumer | SpringConfigurationPropertiesConsumer;
+export interface SpringConfigConsumerBatch {
+    readonly filePath: string;
+    readonly consumers: readonly SpringConfigConsumer[];
+}
+/**
+ * Attach normalized, language-provider-produced Spring consumers to config
+ * keys already present in the shared graph.
+ */
+export declare function bindSpringConfigConsumers(graph: KnowledgeGraph, batches: readonly SpringConfigConsumerBatch[]): void;

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

@@ -0,0 +1,115 @@
+import { generateId } from '../../../../lib/utils.js';
+export const SPRING_CONFIG_DESCRIPTION = 'Spring configuration property';
+function closestNode(candidates, filePath, name, line) {
+    return candidates
+        .filter((node) => node.properties.filePath === filePath && node.properties.name === name)
+        .sort((left, right) => Math.abs(Number(left.properties.startLine ?? 0) - line) -
+        Math.abs(Number(right.properties.startLine ?? 0) - line))[0];
+}
+function markUnresolved(node, key) {
+    const marker = `Spring config unresolved: ${key}`;
+    const existing = typeof node.properties.description === 'string' ? node.properties.description : '';
+    if (existing.includes(marker))
+        return;
+    node.properties.description = existing.length > 0 ? `${existing}; ${marker}` : marker;
+}
+function relaxedName(value) {
+    return value.toLowerCase().replace(/[-_.]/g, '');
+}
+function isSpringConfigNode(node) {
+    return (node.label === 'Property' &&
+        typeof node.properties.description === 'string' &&
+        node.properties.description.startsWith(SPRING_CONFIG_DESCRIPTION));
+}
+/**
+ * Attach normalized, language-provider-produced Spring consumers to config
+ * keys already present in the shared graph.
+ */
+export function bindSpringConfigConsumers(graph, batches) {
+    if (batches.length === 0)
+        return;
+    const configNodes = [];
+    const propertyNodes = [];
+    const classNodes = [];
+    for (const node of graph.iterNodes()) {
+        if (isSpringConfigNode(node))
+            configNodes.push(node);
+        else if (node.label === 'Property')
+            propertyNodes.push(node);
+        else if (node.label === 'Class' || node.label === 'Record')
+            classNodes.push(node);
+    }
+    const keyNodes = new Map();
+    for (const node of configNodes) {
+        const key = String(node.properties.name);
+        const bucket = keyNodes.get(key) ?? [];
+        bucket.push(node);
+        keyNodes.set(key, bucket);
+    }
+    const propertiesByOwner = new Map();
+    for (const rel of graph.iterRelationshipsByType('HAS_PROPERTY')) {
+        const property = graph.getNode(rel.targetId);
+        if (property?.label !== 'Property' || isSpringConfigNode(property))
+            continue;
+        const members = propertiesByOwner.get(rel.sourceId) ?? [];
+        members.push(property);
+        propertiesByOwner.set(rel.sourceId, members);
+    }
+    const addBinding = (source, target, reason, confidence) => {
+        const edgeId = generateId('USES', `${source.id}->${target.id}:${reason}`);
+        graph.addRelationship({
+            id: edgeId,
+            sourceId: source.id,
+            targetId: target.id,
+            type: 'USES',
+            confidence,
+            reason,
+        });
+    };
+    for (const { filePath, consumers } of batches) {
+        for (const consumer of consumers) {
+            if (consumer.kind === 'value') {
+                const field = closestNode(propertyNodes, filePath, consumer.fieldName, consumer.line);
+                if (field === undefined)
+                    continue;
+                for (const key of consumer.keys) {
+                    const matches = keyNodes.get(key) ?? [];
+                    if (matches.length === 0) {
+                        markUnresolved(field, key);
+                        continue;
+                    }
+                    for (const match of matches) {
+                        addBinding(field, match, `spring-config:@Value ${key}`, 1);
+                    }
+                }
+                continue;
+            }
+            const owner = closestNode(classNodes, filePath, consumer.className, consumer.line);
+            if (owner === undefined)
+                continue;
+            const prefix = `${consumer.prefix}.`;
+            const matches = configNodes.filter((node) => {
+                const key = String(node.properties.name);
+                return key === consumer.prefix || key.startsWith(prefix);
+            });
+            if (matches.length === 0) {
+                markUnresolved(owner, consumer.prefix);
+                continue;
+            }
+            for (const match of matches) {
+                addBinding(owner, match, `spring-config:@ConfigurationProperties ${consumer.prefix}`, 0.95);
+            }
+            for (const field of propertiesByOwner.get(owner.id) ?? []) {
+                const fieldName = relaxedName(String(field.properties.name));
+                for (const match of matches) {
+                    const key = String(match.properties.name);
+                    const suffix = key === consumer.prefix ? '' : key.slice(prefix.length);
+                    const firstSegment = suffix.split(/[.\[]/, 1)[0];
+                    if (firstSegment.length === 0 || relaxedName(firstSegment) !== fieldName)
+                        continue;
+                    addBinding(field, match, `spring-config:@ConfigurationProperties field ${consumer.prefix}`, 0.95);
+                }
+            }
+        }
+    }
+}

package/dist/core/ingestion/languages/java/analysis-features.d.ts

@@ -0,0 +1,3 @@
+import type { AnalysisFeatureDescriptor } from '../../../analysis-features.js';
+/** Durable completeness contract for Java Spring configuration bindings. */
+export declare const SPRING_CONFIG_BINDINGS_FEATURE: AnalysisFeatureDescriptor;

package/dist/core/ingestion/languages/java/analysis-features.js

@@ -0,0 +1,13 @@
+function isSpringApplicationConfig(filePath) {
+    const base = filePath.replaceAll('\\', '/').split('/').pop() ?? '';
+    return /^application(?:-[^.]+)?\.(?:properties|ya?ml)$/i.test(base);
+}
+/** Durable completeness contract for Java Spring configuration bindings. */
+export const SPRING_CONFIG_BINDINGS_FEATURE = {
+    id: 'spring.config-bindings',
+    version: 1,
+    // Java sources need consumer extraction even without config files (missing
+    // placeholders still get unresolved markers). Config-only repositories also
+    // need a one-time rebuild to backfill language-agnostic Property nodes.
+    appliesTo: (filePaths) => filePaths.some((filePath) => filePath.toLowerCase().endsWith('.java') || isSpringApplicationConfig(filePath)),
+};

package/dist/core/ingestion/languages/java/capture-side-channel.d.ts

@@ -1,16 +1,20 @@
 import type { ParsedFile } from '../../../../_shared/index.js';
 import { type ClassAnnotationFact } from '../../frameworks/spring/bean-candidates.js';
 import { type JvmPackageFact } from '../jvm/package-facts.js';
+import type { JavaSpringConfigConsumerFact } from './spring-config-bindings.js';
 export type JavaClassAnnotationFact = ClassAnnotationFact;
 export interface JavaCaptureSideChannel {
     readonly kind: 'java';
     readonly packageFact: JvmPackageFact;
     readonly classAnnotations: readonly JavaClassAnnotationFact[];
+    readonly springConfigConsumers?: readonly JavaSpringConfigConsumerFact[];
 }
 /** Clear facts retained by a prior workspace pass in a long-lived process. */
 export declare function clearJavaClassAnnotationFacts(): void;
 /** Store the annotation syntax collected by Java's existing scope-query traversal. */
 export declare function setJavaClassAnnotationFacts(filePath: string, facts: readonly JavaClassAnnotationFact[]): void;
+export declare function setJavaSpringConfigConsumerFacts(filePath: string, facts: readonly JavaSpringConfigConsumerFact[]): void;
+export declare function getJavaSpringConfigConsumerFacts(filePath: string): readonly JavaSpringConfigConsumerFact[];
 /** Snapshot worker-local Java annotation facts for ParsedFile serialization. */
 export declare function collectJavaCaptureSideChannel(filePath: string): JavaCaptureSideChannel | undefined;
 export declare function getJavaClassAnnotationFacts(filePath: string): readonly JavaClassAnnotationFact[];

package/dist/core/ingestion/languages/java/capture-side-channel.js

@@ -2,24 +2,38 @@ import { createClassAnnotationFactStore, } from '../../frameworks/spring/bean-ca
 import { isJvmPackageFact, UNKNOWN_JVM_PACKAGE_FACT, } from '../jvm/package-facts.js';
 import { getJavaPackageFact, setJavaPackageFact } from './package-facts.js';
 const classAnnotations = createClassAnnotationFactStore();
+const springConfigConsumers = new Map();
 /** Clear facts retained by a prior workspace pass in a long-lived process. */
 export function clearJavaClassAnnotationFacts() {
     classAnnotations.clear();
+    springConfigConsumers.clear();
 }
 /** Store the annotation syntax collected by Java's existing scope-query traversal. */
 export function setJavaClassAnnotationFacts(filePath, facts) {
     classAnnotations.set(filePath, facts);
 }
+export function setJavaSpringConfigConsumerFacts(filePath, facts) {
+    if (facts.length === 0)
+        springConfigConsumers.delete(filePath);
+    else
+        springConfigConsumers.set(filePath, facts);
+}
+export function getJavaSpringConfigConsumerFacts(filePath) {
+    return springConfigConsumers.get(filePath) ?? [];
+}
 /** Snapshot worker-local Java annotation facts for ParsedFile serialization. */
 export function collectJavaCaptureSideChannel(filePath) {
     const facts = classAnnotations.get(filePath);
+    const configConsumers = springConfigConsumers.get(filePath) ?? [];
     const packageFact = getJavaPackageFact(filePath);
-    if (facts.length === 0 && packageFact === undefined)
+    if (facts.length === 0 && configConsumers.length === 0 && packageFact === undefined) {
         return undefined;
+    }
     return {
         kind: 'java',
         packageFact: packageFact ?? UNKNOWN_JVM_PACKAGE_FACT,
         classAnnotations: facts,
+        ...(configConsumers.length > 0 ? { springConfigConsumers: configConsumers } : {}),
     };
 }
 export function getJavaClassAnnotationFacts(filePath) {
@@ -34,9 +48,11 @@ export function applyJavaCaptureSideChannel(parsed) {
         data.kind !== 'java' ||
         !Array.isArray(data.classAnnotations)) {
         setJavaClassAnnotationFacts(parsed.filePath, []);
+        setJavaSpringConfigConsumerFacts(parsed.filePath, []);
         setJavaPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
     }
     setJavaClassAnnotationFacts(parsed.filePath, data.classAnnotations);
+    setJavaSpringConfigConsumerFacts(parsed.filePath, Array.isArray(data.springConfigConsumers) ? data.springConfigConsumers : []);
     setJavaPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
 }

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

@@ -7,9 +7,10 @@ import { getJavaParser, getJavaScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
-import { setJavaClassAnnotationFacts } from './capture-side-channel.js';
+import { setJavaClassAnnotationFacts, setJavaSpringConfigConsumerFacts, } from './capture-side-channel.js';
 import { captureJavaPackageFact } from './package-facts.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { captureJavaSpringConfigConsumerFacts } from './spring-config-bindings.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.constructor'];
 /** tree-sitter-java node types that the method extractor accepts. */
@@ -195,6 +196,7 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
         out.push(grouped);
     }
     setJavaClassAnnotationFacts(filePath, materializeClassAnnotationFacts(classAnnotations));
+    setJavaSpringConfigConsumerFacts(filePath, captureJavaSpringConfigConsumerFacts(tree.rootNode, filePath));
     return [
         ...resolveVarTypeBindings(out),
         ...synthesizeJavaInheritanceReferences(tree.rootNode),

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

@@ -14,6 +14,7 @@ import { javaProvider } from '../java.js';
 import { javaArityCompatibility, javaMergeBindings, resolveJavaImportTarget, } from './index.js';
 import { populateJavaPackageSiblings } from './package-siblings.js';
 import { attachSpringBeanCandidateMetadata } from './spring-bean-metadata.js';
+import { attachJavaSpringConfigBindings } from './spring-config-bindings.js';
 import { applyJavaCaptureSideChannel, clearJavaClassAnnotationFacts, } from './capture-side-channel.js';
 import { clearJavaPackageFacts } from './package-facts.js';
 const javaScopeResolver = {
@@ -51,7 +52,10 @@ const javaScopeResolver = {
     freeCallsRequireInstanceOwnership: true,
     populateNamespaceSiblings: populateJavaPackageSiblings,
     populateRangeBindings: populateJavaCrossFileReturnTypes,
-    emitPostResolutionEdges: attachSpringBeanCandidateMetadata,
+    emitPostResolutionEdges: (graph, parsedFiles, nodeLookup, indexes, ctx) => {
+        attachSpringBeanCandidateMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachJavaSpringConfigBindings(graph, parsedFiles, nodeLookup, indexes, ctx);
+    },
 };
 export { javaScopeResolver };
 function populateJavaCrossFileReturnTypes(parsedFiles, indexes) {

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

@@ -0,0 +1,23 @@
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import { type ParsedFile, type ScopeId } from '../../../../_shared/index.js';
+import { type SpringConfigConsumer } from '../../frameworks/spring/config-bindings.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+export interface JavaSpringConfigConsumerFact {
+    readonly consumer: SpringConfigConsumer;
+    readonly annotationName: string;
+    readonly classScopeId: ScopeId;
+}
+/** Extract statically readable Spring placeholder keys from a Java annotation. */
+export declare function parseValuePlaceholderKeys(annotation: SyntaxNode): string[];
+/** Extract `prefix`/`value` (or the positional value) from the annotation. */
+export declare function parseConfigurationPropertiesPrefix(annotation: SyntaxNode): string | null;
+/** Collect config facts from the Java parser's existing AST (no reparse). */
+export declare function captureJavaSpringConfigConsumerFacts(root: SyntaxNode, filePath: string): JavaSpringConfigConsumerFact[];
+/** Parse Java consumers for focused unit tests; production reuses the worker AST. */
+export declare function extractJavaSpringConfigConsumers(source: string): SpringConfigConsumer[];
+/** Java ScopeResolver post-resolution hook for Spring configuration consumers. */
+export declare function attachJavaSpringConfigBindings(graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], _nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes, _ctx: {
+    readonly fileContents: ReadonlyMap<string, string>;
+}): void;

package/dist/core/ingestion/languages/java/spring-config-bindings.js

@@ -0,0 +1,215 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { bindSpringConfigConsumers, } from '../../frameworks/spring/config-bindings.js';
+import { createSpringAnnotationNameResolver } from '../../frameworks/spring/bean-candidates.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getJavaParser } from './query.js';
+import { getJavaSpringConfigConsumerFacts } from './capture-side-channel.js';
+import { isJavaPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+const VALUE_ANNOTATION = 'org.springframework.beans.factory.annotation.Value';
+const CONFIGURATION_PROPERTIES_ANNOTATION = 'org.springframework.boot.context.properties.ConfigurationProperties';
+function collectJavaImports(root) {
+    const exact = new Set();
+    const wildcard = new Set();
+    const localTypes = new Set();
+    for (const node of root.descendantsOfType('import_declaration')) {
+        const imported = node.text
+            .replace(/^\s*import\s+(?:static\s+)?/, '')
+            .replace(/;\s*$/, '')
+            .trim();
+        if (imported.endsWith('.*'))
+            wildcard.add(imported.slice(0, -2));
+        else
+            exact.add(imported);
+    }
+    for (const type of [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+        'annotation_type_declaration',
+    ]) {
+        for (const node of root.descendantsOfType(type)) {
+            const name = node.childForFieldName('name')?.text;
+            if (name)
+                localTypes.add(name);
+        }
+    }
+    return { exact, wildcard, localTypes };
+}
+function annotationsOn(node) {
+    const modifiers = node.namedChildren.find((child) => child.type === 'modifiers');
+    if (modifiers === undefined)
+        return [];
+    const annotations = [];
+    for (const child of modifiers.namedChildren) {
+        if (child.type !== 'annotation' && child.type !== 'marker_annotation')
+            continue;
+        const name = child.childForFieldName('name')?.text ?? child.firstNamedChild?.text;
+        if (name)
+            annotations.push({ name, node: child });
+    }
+    return annotations;
+}
+function resolvesToAnnotation(rawName, canonicalName, imports) {
+    if (rawName.includes('.'))
+        return rawName === canonicalName;
+    if (imports.localTypes.has(rawName))
+        return false;
+    if (imports.exact.has(canonicalName))
+        return true;
+    const packageName = canonicalName.slice(0, canonicalName.lastIndexOf('.'));
+    return imports.wildcard.has(packageName);
+}
+function decodeJavaStringLiteral(literal) {
+    const delimiterLength = literal.startsWith('"""') && literal.endsWith('"""') ? 3 : 1;
+    return literal
+        .slice(delimiterLength, -delimiterLength)
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_match, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+        .replace(/\\(["'\\btnfr])/g, (_match, escaped) => {
+        const controls = {
+            b: '\b',
+            t: '\t',
+            n: '\n',
+            f: '\f',
+            r: '\r',
+        };
+        return controls[escaped] ?? escaped;
+    });
+}
+function javaStringLiterals(annotation) {
+    return annotation
+        .descendantsOfType('string_literal')
+        .map((literal) => decodeJavaStringLiteral(literal.text));
+}
+/** Extract statically readable Spring placeholder keys from a Java annotation. */
+export function parseValuePlaceholderKeys(annotation) {
+    const keys = new Set();
+    for (const literal of javaStringLiterals(annotation)) {
+        for (const match of literal.matchAll(/\$\{([^{}]+)\}/g)) {
+            const key = match[1].split(':', 1)[0].trim();
+            if (/^[A-Za-z0-9_.-]+$/.test(key))
+                keys.add(key);
+        }
+    }
+    return [...keys];
+}
+/** Extract `prefix`/`value` (or the positional value) from the annotation. */
+export function parseConfigurationPropertiesPrefix(annotation) {
+    const named = annotation.descendantsOfType('element_value_pair').find((pair) => {
+        const key = pair.childForFieldName('key')?.text;
+        return key === 'prefix' || key === 'value';
+    });
+    const namedValue = named?.childForFieldName('value');
+    const argumentsNode = annotation.childForFieldName('arguments');
+    const literalNode = (namedValue?.type === 'string_literal'
+        ? namedValue
+        : namedValue?.descendantsOfType('string_literal')[0]) ??
+        (named === undefined
+            ? argumentsNode?.namedChildren.find((child) => child.type === 'string_literal')
+            : undefined);
+    if (literalNode === undefined)
+        return null;
+    const prefix = decodeJavaStringLiteral(literalNode.text)
+        .trim()
+        .replace(/^\.+|\.+$/g, '');
+    return /^[A-Za-z0-9_.-]+$/.test(prefix) ? prefix : null;
+}
+function classScopeId(filePath, declaration) {
+    return makeScopeId({
+        filePath,
+        range: nodeToCapture('@scope.class', declaration).range,
+        kind: 'Class',
+    });
+}
+function enclosingClass(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'class_declaration' || current.type === 'record_declaration') {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+/** Collect config facts from the Java parser's existing AST (no reparse). */
+export function captureJavaSpringConfigConsumerFacts(root, filePath) {
+    const imports = collectJavaImports(root);
+    const facts = [];
+    for (const field of root.descendantsOfType('field_declaration')) {
+        const annotations = annotationsOn(field).filter((annotation) => resolvesToAnnotation(annotation.name, VALUE_ANNOTATION, imports));
+        if (annotations.length === 0)
+            continue;
+        const owner = enclosingClass(field);
+        if (owner === undefined)
+            continue;
+        for (const declarator of field.namedChildren.filter((child) => child.type === 'variable_declarator')) {
+            const fieldName = declarator.childForFieldName('name')?.text;
+            if (!fieldName)
+                continue;
+            for (const annotation of annotations) {
+                const keys = parseValuePlaceholderKeys(annotation.node);
+                if (keys.length > 0) {
+                    facts.push({
+                        consumer: { kind: 'value', fieldName, line: field.startPosition.row + 1, keys },
+                        annotationName: annotation.name,
+                        classScopeId: classScopeId(filePath, owner),
+                    });
+                }
+            }
+        }
+    }
+    for (const type of ['class_declaration', 'record_declaration']) {
+        for (const declaration of root.descendantsOfType(type)) {
+            const className = declaration.childForFieldName('name')?.text;
+            if (!className)
+                continue;
+            for (const annotation of annotationsOn(declaration)) {
+                if (!resolvesToAnnotation(annotation.name, CONFIGURATION_PROPERTIES_ANNOTATION, imports)) {
+                    continue;
+                }
+                const prefix = parseConfigurationPropertiesPrefix(annotation.node);
+                if (prefix !== null) {
+                    facts.push({
+                        consumer: {
+                            kind: 'configuration-properties',
+                            className,
+                            line: declaration.startPosition.row + 1,
+                            prefix,
+                        },
+                        annotationName: annotation.name,
+                        classScopeId: classScopeId(filePath, declaration),
+                    });
+                }
+            }
+        }
+    }
+    return facts;
+}
+/** Parse Java consumers for focused unit tests; production reuses the worker AST. */
+export function extractJavaSpringConfigConsumers(source) {
+    const tree = parseSourceSafe(getJavaParser(), source);
+    return captureJavaSpringConfigConsumerFacts(tree.rootNode, '<memory>').map((fact) => fact.consumer);
+}
+/** Java ScopeResolver post-resolution hook for Spring configuration consumers. */
+export function attachJavaSpringConfigBindings(graph, parsedFiles, _nodeLookup, indexes, _ctx) {
+    const resolveAnnotation = createSpringAnnotationNameResolver(indexes);
+    const recognizedAnnotations = new Set([VALUE_ANNOTATION, CONFIGURATION_PROPERTIES_ANNOTATION]);
+    const batches = [];
+    for (const parsed of parsedFiles) {
+        const consumers = [];
+        for (const fact of getJavaSpringConfigConsumerFacts(parsed.filePath)) {
+            const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+            if (classScope === undefined || classScope.kind !== 'Class')
+                continue;
+            const expectedAnnotation = fact.consumer.kind === 'value' ? VALUE_ANNOTATION : CONFIGURATION_PROPERTIES_ANNOTATION;
+            const enclosingScope = fact.consumer.kind === 'value' ? classScope.id : classScope.parent;
+            const resolved = resolveAnnotation(fact.annotationName, parsed, enclosingScope, recognizedAnnotations, isJavaPackageSiblingVisibilityIncomplete(parsed.filePath));
+            if (resolved === expectedAnnotation)
+                consumers.push(fact.consumer);
+        }
+        if (consumers.length > 0)
+            batches.push({ filePath: parsed.filePath, consumers });
+    }
+    bindSpringConfigConsumers(graph, batches);
+}

package/dist/core/ingestion/pipeline-phases/index.d.ts

@@ -14,6 +14,7 @@ export { toolsPhase, type ToolsOutput, type ToolDef } from './tools.js';
 export { ormPhase, type ORMOutput } from './orm.js';
 export { crossFilePhase, type CrossFileOutput } from './cross-file.js';
 export { scopeResolutionPhase, type ScopeResolutionOutput, } from '../scope-resolution/pipeline/phase.js';
+export { springConfigPhase, type SpringConfigOutput } from './spring-config.js';
 export { pruneLocalSymbolsPhase, type PruneLocalSymbolsOutput } from './prune-local-symbols.js';
 export { taintSummariesPhase, type TaintSummariesOutput } from './taint-summaries.js';
 export { callSummariesPhase, type CallSummariesOutput } from './call-summaries.js';

package/dist/core/ingestion/pipeline-phases/index.js

@@ -15,6 +15,7 @@ export { toolsPhase } from './tools.js';
 export { ormPhase } from './orm.js';
 export { crossFilePhase } from './cross-file.js';
 export { scopeResolutionPhase, } from '../scope-resolution/pipeline/phase.js';
+export { springConfigPhase } from './spring-config.js';
 export { pruneLocalSymbolsPhase } from './prune-local-symbols.js';
 export { taintSummariesPhase } from './taint-summaries.js';
 export { callSummariesPhase } from './call-summaries.js';

package/dist/core/ingestion/pipeline-phases/spring-config.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Phase: springConfig
+ *
+ * Adds key-only nodes for statically readable Spring
+ * `application*.properties` / `application*.yml` / `application*.yaml` files.
+ * Language-specific ScopeResolver hooks attach consumers later. Configuration
+ * values are deliberately never copied into the graph because they may contain
+ * credentials and key identity is sufficient for impact analysis.
+ *
+ * @deps    structure
+ * @reads   Spring application configuration files
+ * @writes  Property nodes and DEFINES edges
+ */
+import type { PipelinePhase } from './types.js';
+export interface SpringConfigKey {
+    readonly key: string;
+    readonly filePath: string;
+    readonly line: number;
+    readonly profile?: string;
+    readonly format: 'properties' | 'yaml';
+}
+interface SpringConfigFile {
+    readonly filePath: string;
+    readonly profile?: string;
+    readonly format: SpringConfigKey['format'];
+}
+export interface SpringConfigOutput {
+    readonly configKeys: number;
+}
+/** Match only Spring Boot's conventional application config file names. */
+export declare function classifySpringConfigFile(filePath: string): SpringConfigFile | null;
+/** Parse `.properties` keys without retaining their values. */
+export declare function parseSpringProperties(content: string, filePath: string, profile?: string): SpringConfigKey[];
+/** Parse and flatten YAML leaves without retaining their values. */
+export declare function parseSpringYaml(content: string, filePath: string, profile?: string): SpringConfigKey[];
+export declare const springConfigPhase: PipelinePhase<SpringConfigOutput>;
+export {};

package/dist/core/ingestion/pipeline-phases/spring-config.js

@@ -0,0 +1,303 @@
+/**
+ * Phase: springConfig
+ *
+ * Adds key-only nodes for statically readable Spring
+ * `application*.properties` / `application*.yml` / `application*.yaml` files.
+ * Language-specific ScopeResolver hooks attach consumers later. Configuration
+ * values are deliberately never copied into the graph because they may contain
+ * credentials and key identity is sufficient for impact analysis.
+ *
+ * @deps    structure
+ * @reads   Spring application configuration files
+ * @writes  Property nodes and DEFINES edges
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { SPRING_CONFIG_DESCRIPTION } from '../frameworks/spring/config-bindings.js';
+import { generateId } from '../../../lib/utils.js';
+import { getPhaseOutput } from './types.js';
+const require = createRequire(import.meta.url);
+const yaml = require('js-yaml');
+const MAX_CONFIG_FILE_BYTES = 2 * 1024 * 1024;
+const MAX_YAML_TRAVERSAL_DEPTH = 128;
+const MAX_YAML_TRAVERSAL_NODES = 100_000;
+/** Match only Spring Boot's conventional application config file names. */
+export function classifySpringConfigFile(filePath) {
+    const base = path.posix.basename(filePath.replaceAll('\\', '/'));
+    const match = /^application(?:-([^.]+))?\.(properties|ya?ml)$/i.exec(base);
+    if (match === null)
+        return null;
+    return {
+        filePath,
+        ...(match[1] ? { profile: match[1] } : {}),
+        format: match[2].toLowerCase() === 'properties' ? 'properties' : 'yaml',
+    };
+}
+function unescapePropertyKey(raw) {
+    return raw
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_match, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+        .replace(/\\([:=#!\\ ])/g, '$1');
+}
+function logicalPropertiesLines(content) {
+    const physical = content.split(/\r?\n/);
+    const logical = [];
+    let current = '';
+    let startLine = 1;
+    for (let index = 0; index < physical.length; index++) {
+        const line = physical[index];
+        if (current.length === 0)
+            startLine = index + 1;
+        current += current.length === 0 ? line : line.trimStart();
+        let trailingBackslashes = 0;
+        for (let cursor = current.length - 1; cursor >= 0 && current[cursor] === '\\'; cursor--) {
+            trailingBackslashes++;
+        }
+        if (trailingBackslashes % 2 === 1) {
+            current = current.slice(0, -1);
+            continue;
+        }
+        logical.push({ text: current, line: startLine });
+        current = '';
+    }
+    if (current.length > 0)
+        logical.push({ text: current, line: startLine });
+    return logical;
+}
+/** Parse `.properties` keys without retaining their values. */
+export function parseSpringProperties(content, filePath, profile) {
+    const keys = [];
+    const seen = new Set();
+    for (const logical of logicalPropertiesLines(content)) {
+        const trimmed = logical.text.trimStart();
+        if (trimmed.length === 0 || trimmed.startsWith('#') || trimmed.startsWith('!'))
+            continue;
+        let separator = -1;
+        let escaped = false;
+        for (let index = 0; index < trimmed.length; index++) {
+            const char = trimmed[index];
+            if (!escaped && (char === '=' || char === ':' || /\s/.test(char))) {
+                separator = index;
+                break;
+            }
+            escaped = !escaped && char === '\\';
+            if (char !== '\\')
+                escaped = false;
+        }
+        const rawKey = (separator === -1 ? trimmed : trimmed.slice(0, separator)).trim();
+        const key = unescapePropertyKey(rawKey);
+        if (key.length === 0 || seen.has(key))
+            continue;
+        seen.add(key);
+        keys.push({
+            key,
+            filePath,
+            line: logical.line,
+            ...(profile ? { profile } : {}),
+            format: 'properties',
+        });
+    }
+    return keys;
+}
+function consumeYamlTraversalBudget(state, depth) {
+    if (depth > MAX_YAML_TRAVERSAL_DEPTH) {
+        throw new Error(`Spring YAML traversal depth exceeds ${MAX_YAML_TRAVERSAL_DEPTH}`);
+    }
+    state.remainingNodes--;
+    if (state.remainingNodes < 0) {
+        throw new Error(`Spring YAML traversal exceeds ${MAX_YAML_TRAVERSAL_NODES} nodes`);
+    }
+}
+function isObjectValue(value) {
+    return value !== null && typeof value === 'object';
+}
+function resolveYamlAliasEvent(event, objectEvents) {
+    if (event?.kind !== null || !isObjectValue(event.result))
+        return event;
+    return objectEvents.get(event.result) ?? event;
+}
+function yamlMappingPairs(event) {
+    const pairs = [];
+    for (let index = 0; index + 1 < event.children.length; index += 2) {
+        const keyEvent = event.children[index];
+        const valueEvent = event.children[index + 1];
+        if (keyEvent.kind !== 'scalar')
+            continue;
+        pairs.push({ key: String(keyEvent.result), keyEvent, valueEvent });
+    }
+    return pairs;
+}
+function findYamlMappingLocation(event, key, objectEvents, traversal, visited = new Set(), depth = 0) {
+    consumeYamlTraversalBudget(traversal, depth);
+    const resolved = resolveYamlAliasEvent(event, objectEvents);
+    if (resolved === undefined || visited.has(resolved))
+        return undefined;
+    visited.add(resolved);
+    if (resolved.kind === 'sequence') {
+        for (const child of resolved.children) {
+            const found = findYamlMappingLocation(child, key, objectEvents, traversal, visited, depth + 1);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    }
+    if (resolved.kind !== 'mapping')
+        return undefined;
+    const pairs = yamlMappingPairs(resolved);
+    const direct = pairs.find((pair) => pair.key === key);
+    if (direct !== undefined) {
+        return { valueEvent: direct.valueEvent, line: direct.keyEvent.startLine };
+    }
+    for (const merge of pairs.filter((pair) => pair.key === '<<')) {
+        const found = findYamlMappingLocation(merge.valueEvent, key, objectEvents, traversal, visited, depth + 1);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+function flattenYamlValue(value, event, prefix, out, objectEvents, traversal, sourceLine = event?.startLine ?? 1, depth = 0) {
+    consumeYamlTraversalBudget(traversal, depth);
+    const resolvedEvent = resolveYamlAliasEvent(event, objectEvents);
+    const trackedObject = isObjectValue(value) ? value : undefined;
+    if (trackedObject !== undefined && traversal.activeObjects.has(trackedObject))
+        return;
+    if (trackedObject !== undefined)
+        traversal.activeObjects.add(trackedObject);
+    try {
+        if (Array.isArray(value)) {
+            if (value.length === 0 && prefix.length > 0 && !out.has(prefix))
+                out.set(prefix, sourceLine);
+            value.forEach((item, index) => flattenYamlValue(item, resolvedEvent?.children[index], `${prefix}[${index}]`, out, objectEvents, traversal, sourceLine, depth + 1));
+            return;
+        }
+        if (value !== null &&
+            typeof value === 'object' &&
+            (resolvedEvent?.kind === 'mapping' || resolvedEvent === undefined)) {
+            const entries = Object.entries(value);
+            if (entries.length === 0 && prefix.length > 0 && !out.has(prefix))
+                out.set(prefix, sourceLine);
+            for (const [key, nested] of entries) {
+                const next = prefix.length === 0 ? key : `${prefix}.${key}`;
+                const location = findYamlMappingLocation(resolvedEvent, key, objectEvents, traversal);
+                flattenYamlValue(nested, location?.valueEvent, next, out, objectEvents, traversal, location?.line ?? sourceLine, depth + 1);
+            }
+            return;
+        }
+        if (prefix.length > 0 && !out.has(prefix))
+            out.set(prefix, sourceLine);
+    }
+    finally {
+        if (trackedObject !== undefined)
+            traversal.activeObjects.delete(trackedObject);
+    }
+}
+/** Parse and flatten YAML leaves without retaining their values. */
+export function parseSpringYaml(content, filePath, profile) {
+    const flattened = new Map();
+    const eventStack = [];
+    const documentEvents = [];
+    const objectEvents = new WeakMap();
+    const documents = [];
+    const traversal = {
+        remainingNodes: MAX_YAML_TRAVERSAL_NODES,
+        activeObjects: new Set(),
+    };
+    yaml.loadAll(content, (document) => documents.push(document), {
+        schema: yaml.DEFAULT_SCHEMA,
+        json: true,
+        listener: (eventType, state) => {
+            if (eventType === 'open') {
+                eventStack.push({
+                    startLine: state.line + 1,
+                    kind: null,
+                    result: undefined,
+                    tag: null,
+                    children: [],
+                });
+                return;
+            }
+            const event = eventStack.pop();
+            if (event === undefined)
+                return;
+            event.kind = state.kind ?? null;
+            event.result = state.result;
+            event.tag = state.tag ?? null;
+            if (isObjectValue(event.result) && event.kind !== null) {
+                objectEvents.set(event.result, event);
+            }
+            const parent = eventStack[eventStack.length - 1];
+            if (parent === undefined)
+                documentEvents.push(event);
+            else
+                parent.children.push(event);
+        },
+    });
+    documents.forEach((document, index) => flattenYamlValue(document, documentEvents[index], '', flattened, objectEvents, traversal));
+    return [...flattened.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, line]) => ({
+        key,
+        filePath,
+        line,
+        ...(profile ? { profile } : {}),
+        format: 'yaml',
+    }));
+}
+function configKeyNodeId(entry) {
+    return generateId('Property', `spring-config:${entry.filePath}:${entry.key}`);
+}
+async function readConfigKeys(repoPath, scannedFiles) {
+    const keys = [];
+    for (const scanned of scannedFiles) {
+        const classified = classifySpringConfigFile(scanned.path);
+        if (classified === null || scanned.size > MAX_CONFIG_FILE_BYTES)
+            continue;
+        try {
+            const content = await fs.readFile(path.join(repoPath, scanned.path), 'utf8');
+            keys.push(...(classified.format === 'properties'
+                ? parseSpringProperties(content, classified.filePath, classified.profile)
+                : parseSpringYaml(content, classified.filePath, classified.profile)));
+        }
+        catch {
+            // Malformed configuration is not a reason to fail the entire code index.
+            // Fail closed: no keys and therefore no misleading bindings for this file.
+        }
+    }
+    return keys;
+}
+export const springConfigPhase = {
+    name: 'springConfig',
+    deps: ['structure'],
+    async execute(ctx, deps) {
+        const { scannedFiles } = getPhaseOutput(deps, 'structure');
+        const configKeys = await readConfigKeys(ctx.repoPath, scannedFiles);
+        for (const entry of configKeys) {
+            const nodeId = configKeyNodeId(entry);
+            ctx.graph.addNode({
+                id: nodeId,
+                label: 'Property',
+                properties: {
+                    name: entry.key,
+                    filePath: entry.filePath,
+                    startLine: entry.line,
+                    endLine: entry.line,
+                    description: entry.profile
+                        ? `${SPRING_CONFIG_DESCRIPTION} (profile: ${entry.profile})`
+                        : SPRING_CONFIG_DESCRIPTION,
+                },
+            });
+            const fileId = generateId('File', entry.filePath);
+            if (ctx.graph.getNode(fileId) !== undefined) {
+                ctx.graph.addRelationship({
+                    id: generateId('DEFINES', `${fileId}->${nodeId}`),
+                    sourceId: fileId,
+                    targetId: nodeId,
+                    type: 'DEFINES',
+                    confidence: 1,
+                    reason: 'spring-config:key',
+                });
+            }
+        }
+        return { configKeys: configKeys.length };
+    },
+};

package/dist/core/ingestion/pipeline.d.ts

@@ -201,7 +201,7 @@ export interface PipelineOptions {
  *
  * Phase dependency graph:
  *
- *   scan → structure → [markdown, cobol] → parse → [routes, tools, orm]
+ *   scan → structure → [springConfig, markdown, cobol] → parse → [routes, tools, orm]
  *     → crossFile → scopeResolution → pruneLocalSymbols
  *     → mro → di → communities → processes
  *

package/dist/core/ingestion/pipeline.js

@@ -15,14 +15,14 @@
  * See ARCHITECTURE.md for the full phase dependency diagram.
  */
 import { createKnowledgeGraph } from '../graph/graph.js';
-import { runPipeline, getPhaseOutput, scanPhase, structurePhase, markdownPhase, cobolPhase, parsePhase, routesPhase, toolsPhase, ormPhase, crossFilePhase, scopeResolutionPhase, pruneLocalSymbolsPhase, taintSummariesPhase, callSummariesPhase, mroPhase, diPhase, communitiesPhase, processesPhase, PhaseRegistry, } from './pipeline-phases/index.js';
+import { runPipeline, getPhaseOutput, scanPhase, structurePhase, markdownPhase, cobolPhase, parsePhase, routesPhase, toolsPhase, ormPhase, crossFilePhase, scopeResolutionPhase, springConfigPhase, pruneLocalSymbolsPhase, taintSummariesPhase, callSummariesPhase, mroPhase, diPhase, communitiesPhase, processesPhase, PhaseRegistry, } from './pipeline-phases/index.js';
 // ── Phase registry ─────────────────────────────────────────────────────────
 /**
  * All pipeline phases with their dependency relationships.
  *
  * Phase dependency graph:
  *
- *   scan → structure → [markdown, cobol] → parse → [routes, tools, orm]
+ *   scan → structure → [springConfig, markdown, cobol] → parse → [routes, tools, orm]
  *     → crossFile → scopeResolution → pruneLocalSymbols
  *     → mro → di → communities → processes
  *
@@ -40,6 +40,7 @@ export function buildPhaseList(options) {
     return (new PhaseRegistry()
         .register(scanPhase)
         .register(structurePhase)
+        .register(springConfigPhase)
         .register(markdownPhase)
         .register(cobolPhase)
         .register(parsePhase)

package/dist/core/lbug/schema.d.ts

@@ -43,7 +43,7 @@ export declare const ROUTE_SCHEMA = "\nCREATE NODE TABLE Route (\n  id STRING,\n
 export declare const TOOL_SCHEMA = "\nCREATE NODE TABLE Tool (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
 export declare const SECTION_SCHEMA = "\nCREATE NODE TABLE Section (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  level INT64,\n  content STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
 export declare const BASICBLOCK_SCHEMA = "\nCREATE NODE TABLE BasicBlock (\n  id STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  text STRING,\n  callees STRING,\n  calleeIds STRING,\n  PRIMARY KEY (id)\n)";
-export declare const RELATION_SCHEMA = "\nCREATE REL TABLE CodeRelation (\n  FROM File TO File,\n  FROM File TO Folder,\n  FROM File TO Function,\n  FROM File TO Class,\n  FROM File TO Interface,\n  FROM File TO Method,\n  FROM File TO CodeElement,\n  FROM File TO `Struct`,\n  FROM File TO `Enum`,\n  FROM File TO `Macro`,\n  FROM File TO `Typedef`,\n  FROM File TO `Union`,\n  FROM File TO `Namespace`,\n  FROM File TO `Trait`,\n  FROM File TO `Impl`,\n  FROM File TO `TypeAlias`,\n  FROM File TO `Const`,\n  FROM File TO `Static`,\n  FROM File TO `Variable`,\n  FROM File TO `Property`,\n  FROM File TO `Record`,\n  FROM File TO `Delegate`,\n  FROM File TO `Annotation`,\n  FROM File TO `Constructor`,\n  FROM File TO `Template`,\n  FROM File TO `Module`,\n  FROM File TO Section,\n  FROM Folder TO Folder,\n  FROM Folder TO File,\n  FROM Function TO Function,\n  FROM Function TO Method,\n  FROM Function TO Class,\n  FROM Function TO Community,\n  FROM Function TO `Macro`,\n  FROM Function TO `Struct`,\n  FROM Function TO `Template`,\n  FROM Function TO `Enum`,\n  FROM Function TO `Namespace`,\n  FROM Function TO `TypeAlias`,\n  FROM Function TO `Module`,\n  FROM Function TO `Impl`,\n  FROM Function TO Interface,\n  FROM Function TO `Constructor`,\n  FROM Function TO `Const`,\n  FROM Function TO `Typedef`,\n  FROM Function TO `Union`,\n  FROM Function TO `Property`,\n  FROM Function TO CodeElement,\n  FROM Class TO Method,\n  FROM Class TO Function,\n  FROM Class TO Class,\n  FROM Class TO Interface,\n  FROM Class TO Community,\n  FROM Class TO `Template`,\n  FROM Class TO `TypeAlias`,\n  FROM Class TO `Struct`,\n  FROM Class TO `Enum`,\n  FROM Class TO `Annotation`,\n  FROM Class TO `Constructor`,\n  FROM Class TO `Trait`,\n  FROM Class TO `Macro`,\n  FROM Class TO `Impl`,\n  FROM Class TO `Union`,\n  FROM Class TO `Namespace`,\n  FROM Class TO `Typedef`,\n  FROM Class TO `Property`,\n  FROM Method TO Function,\n  FROM Method TO Method,\n  FROM Method TO Class,\n  FROM Method TO Community,\n  FROM Method TO `Template`,\n  FROM Method TO `Struct`,\n  FROM Method TO `TypeAlias`,\n  FROM Method TO `Enum`,\n  FROM Method TO `Macro`,\n  FROM Method TO `Namespace`,\n  FROM Method TO `Module`,\n  FROM Method TO `Impl`,\n  FROM Method TO Interface,\n  FROM Method TO `Constructor`,\n  FROM Method TO `Property`,\n  FROM Method TO CodeElement,\n  FROM `Template` TO `Template`,\n  FROM `Template` TO Function,\n  FROM `Template` TO Method,\n  FROM `Template` TO Class,\n  FROM `Template` TO `Struct`,\n  FROM `Template` TO `TypeAlias`,\n  FROM `Template` TO `Enum`,\n  FROM `Template` TO `Macro`,\n  FROM `Template` TO Interface,\n  FROM `Template` TO `Constructor`,\n  FROM `Module` TO `Module`,\n  FROM Section TO Section,\n  FROM Section TO File,\n  FROM File TO Route,\n  FROM Function TO Route,\n  FROM Method TO Route,\n  FROM File TO Tool,\n  FROM Function TO Tool,\n  FROM Method TO Tool,\n  FROM CodeElement TO Community,\n  FROM Interface TO Community,\n  FROM Interface TO Function,\n  FROM Interface TO Method,\n  FROM Interface TO Class,\n  FROM Interface TO Interface,\n  FROM Interface TO `TypeAlias`,\n  FROM Interface TO `Struct`,\n  FROM Interface TO `Constructor`,\n  FROM Interface TO `Property`,\n  FROM `Struct` TO Community,\n  FROM `Struct` TO `Trait`,\n  FROM `Struct` TO `Struct`,\n  FROM `Struct` TO Class,\n  FROM `Struct` TO `Enum`,\n  FROM `Struct` TO Function,\n  FROM `Struct` TO Method,\n  FROM `Struct` TO Interface,\n  FROM `Struct` TO `Constructor`,\n  FROM `Struct` TO `Property`,\n  FROM `Enum` TO `Enum`,\n  FROM `Enum` TO Community,\n  FROM `Enum` TO Class,\n  FROM `Enum` TO Interface,\n  FROM `Macro` TO Community,\n  FROM `Macro` TO Function,\n  FROM `Macro` TO Method,\n  FROM `Module` TO Function,\n  FROM `Module` TO Method,\n  FROM `Typedef` TO Community,\n  FROM `Union` TO Community,\n  FROM `Namespace` TO Community,\n  FROM `Namespace` TO `Struct`,\n  FROM `Trait` TO Method,\n  FROM `Trait` TO `Constructor`,\n  FROM `Trait` TO `Property`,\n  FROM `Trait` TO Community,\n  FROM `Impl` TO Method,\n  FROM `Impl` TO `Constructor`,\n  FROM `Impl` TO `Property`,\n  FROM `Impl` TO Community,\n  FROM `Impl` TO `Trait`,\n  FROM `Impl` TO `Struct`,\n  FROM `Impl` TO `Impl`,\n  FROM `TypeAlias` TO Community,\n  FROM `TypeAlias` TO `Trait`,\n  FROM `TypeAlias` TO Class,\n  FROM `Const` TO Community,\n  FROM `Static` TO Community,\n  FROM `Variable` TO Community,\n  FROM `Property` TO Community,\n  FROM `Record` TO Method,\n  FROM `Record` TO `Constructor`,\n  FROM `Record` TO `Property`,\n  FROM `Record` TO Community,\n  FROM `Delegate` TO Community,\n  FROM `Annotation` TO Community,\n  FROM `Constructor` TO Community,\n  FROM `Constructor` TO Interface,\n  FROM `Constructor` TO Class,\n  FROM `Constructor` TO Method,\n  FROM `Constructor` TO Function,\n  FROM `Constructor` TO `Constructor`,\n  FROM `Constructor` TO `Struct`,\n  FROM `Constructor` TO `Macro`,\n  FROM `Constructor` TO `Template`,\n  FROM `Constructor` TO `TypeAlias`,\n  FROM `Constructor` TO `Enum`,\n  FROM `Constructor` TO `Annotation`,\n  FROM `Constructor` TO `Impl`,\n  FROM `Constructor` TO `Namespace`,\n  FROM `Constructor` TO `Module`,\n  FROM `Constructor` TO `Property`,\n  FROM `Constructor` TO `Typedef`,\n  FROM `Template` TO Community,\n  FROM `Module` TO Community,\n  FROM Function TO Process,\n  FROM Method TO Process,\n  FROM Class TO Process,\n  FROM Interface TO Process,\n  FROM `Struct` TO Process,\n  FROM `Constructor` TO Process,\n  FROM `Module` TO Process,\n  FROM `Macro` TO Process,\n  FROM `Impl` TO Process,\n  FROM `Typedef` TO Process,\n  FROM `TypeAlias` TO Process,\n  FROM `Enum` TO Process,\n  FROM `Union` TO Process,\n  FROM `Namespace` TO Process,\n  FROM `Trait` TO Process,\n  FROM `Const` TO Process,\n  FROM `Static` TO Process,\n  FROM `Variable` TO Process,\n  FROM `Property` TO Process,\n  FROM `Record` TO Process,\n  FROM `Delegate` TO Process,\n  FROM `Annotation` TO Process,\n  FROM `Template` TO Process,\n  FROM CodeElement TO Process,\n  FROM Route TO Process,\n  FROM Tool TO Process,\n  FROM BasicBlock TO BasicBlock,\n  type STRING,\n  confidence DOUBLE,\n  reason STRING,\n  step INT32\n)";
+export declare const RELATION_SCHEMA = "\nCREATE REL TABLE CodeRelation (\n  FROM File TO File,\n  FROM File TO Folder,\n  FROM File TO Function,\n  FROM File TO Class,\n  FROM File TO Interface,\n  FROM File TO Method,\n  FROM File TO CodeElement,\n  FROM File TO `Struct`,\n  FROM File TO `Enum`,\n  FROM File TO `Macro`,\n  FROM File TO `Typedef`,\n  FROM File TO `Union`,\n  FROM File TO `Namespace`,\n  FROM File TO `Trait`,\n  FROM File TO `Impl`,\n  FROM File TO `TypeAlias`,\n  FROM File TO `Const`,\n  FROM File TO `Static`,\n  FROM File TO `Variable`,\n  FROM File TO `Property`,\n  FROM File TO `Record`,\n  FROM File TO `Delegate`,\n  FROM File TO `Annotation`,\n  FROM File TO `Constructor`,\n  FROM File TO `Template`,\n  FROM File TO `Module`,\n  FROM File TO Section,\n  FROM Folder TO Folder,\n  FROM Folder TO File,\n  FROM Function TO Function,\n  FROM Function TO Method,\n  FROM Function TO Class,\n  FROM Function TO Community,\n  FROM Function TO `Macro`,\n  FROM Function TO `Struct`,\n  FROM Function TO `Template`,\n  FROM Function TO `Enum`,\n  FROM Function TO `Namespace`,\n  FROM Function TO `TypeAlias`,\n  FROM Function TO `Module`,\n  FROM Function TO `Impl`,\n  FROM Function TO Interface,\n  FROM Function TO `Constructor`,\n  FROM Function TO `Const`,\n  FROM Function TO `Typedef`,\n  FROM Function TO `Union`,\n  FROM Function TO `Property`,\n  FROM Function TO CodeElement,\n  FROM Class TO Method,\n  FROM Class TO Function,\n  FROM Class TO Class,\n  FROM Class TO Interface,\n  FROM Class TO Community,\n  FROM Class TO `Template`,\n  FROM Class TO `TypeAlias`,\n  FROM Class TO `Struct`,\n  FROM Class TO `Enum`,\n  FROM Class TO `Annotation`,\n  FROM Class TO `Constructor`,\n  FROM Class TO `Trait`,\n  FROM Class TO `Macro`,\n  FROM Class TO `Impl`,\n  FROM Class TO `Union`,\n  FROM Class TO `Namespace`,\n  FROM Class TO `Typedef`,\n  FROM Class TO `Property`,\n  FROM Method TO Function,\n  FROM Method TO Method,\n  FROM Method TO Class,\n  FROM Method TO Community,\n  FROM Method TO `Template`,\n  FROM Method TO `Struct`,\n  FROM Method TO `TypeAlias`,\n  FROM Method TO `Enum`,\n  FROM Method TO `Macro`,\n  FROM Method TO `Namespace`,\n  FROM Method TO `Module`,\n  FROM Method TO `Impl`,\n  FROM Method TO Interface,\n  FROM Method TO `Constructor`,\n  FROM Method TO `Property`,\n  FROM Method TO CodeElement,\n  FROM `Template` TO `Template`,\n  FROM `Template` TO Function,\n  FROM `Template` TO Method,\n  FROM `Template` TO Class,\n  FROM `Template` TO `Struct`,\n  FROM `Template` TO `TypeAlias`,\n  FROM `Template` TO `Enum`,\n  FROM `Template` TO `Macro`,\n  FROM `Template` TO Interface,\n  FROM `Template` TO `Constructor`,\n  FROM `Module` TO `Module`,\n  FROM Section TO Section,\n  FROM Section TO File,\n  FROM File TO Route,\n  FROM Function TO Route,\n  FROM Method TO Route,\n  FROM File TO Tool,\n  FROM Function TO Tool,\n  FROM Method TO Tool,\n  FROM CodeElement TO Community,\n  FROM Interface TO Community,\n  FROM Interface TO Function,\n  FROM Interface TO Method,\n  FROM Interface TO Class,\n  FROM Interface TO Interface,\n  FROM Interface TO `TypeAlias`,\n  FROM Interface TO `Struct`,\n  FROM Interface TO `Constructor`,\n  FROM Interface TO `Property`,\n  FROM `Struct` TO Community,\n  FROM `Struct` TO `Trait`,\n  FROM `Struct` TO `Struct`,\n  FROM `Struct` TO Class,\n  FROM `Struct` TO `Enum`,\n  FROM `Struct` TO Function,\n  FROM `Struct` TO Method,\n  FROM `Struct` TO Interface,\n  FROM `Struct` TO `Constructor`,\n  FROM `Struct` TO `Property`,\n  FROM `Enum` TO `Enum`,\n  FROM `Enum` TO Community,\n  FROM `Enum` TO Class,\n  FROM `Enum` TO Interface,\n  FROM `Macro` TO Community,\n  FROM `Macro` TO Function,\n  FROM `Macro` TO Method,\n  FROM `Module` TO Function,\n  FROM `Module` TO Method,\n  FROM `Typedef` TO Community,\n  FROM `Union` TO Community,\n  FROM `Namespace` TO Community,\n  FROM `Namespace` TO `Struct`,\n  FROM `Trait` TO Method,\n  FROM `Trait` TO `Constructor`,\n  FROM `Trait` TO `Property`,\n  FROM `Trait` TO Community,\n  FROM `Impl` TO Method,\n  FROM `Impl` TO `Constructor`,\n  FROM `Impl` TO `Property`,\n  FROM `Impl` TO Community,\n  FROM `Impl` TO `Trait`,\n  FROM `Impl` TO `Struct`,\n  FROM `Impl` TO `Impl`,\n  FROM `TypeAlias` TO Community,\n  FROM `TypeAlias` TO `Trait`,\n  FROM `TypeAlias` TO Class,\n  FROM `Const` TO Community,\n  FROM `Static` TO Community,\n  FROM `Variable` TO Community,\n  FROM `Property` TO Community,\n  FROM `Property` TO `Property`,\n  FROM `Record` TO Method,\n  FROM `Record` TO `Constructor`,\n  FROM `Record` TO `Property`,\n  FROM `Record` TO Community,\n  FROM `Delegate` TO Community,\n  FROM `Annotation` TO Community,\n  FROM `Constructor` TO Community,\n  FROM `Constructor` TO Interface,\n  FROM `Constructor` TO Class,\n  FROM `Constructor` TO Method,\n  FROM `Constructor` TO Function,\n  FROM `Constructor` TO `Constructor`,\n  FROM `Constructor` TO `Struct`,\n  FROM `Constructor` TO `Macro`,\n  FROM `Constructor` TO `Template`,\n  FROM `Constructor` TO `TypeAlias`,\n  FROM `Constructor` TO `Enum`,\n  FROM `Constructor` TO `Annotation`,\n  FROM `Constructor` TO `Impl`,\n  FROM `Constructor` TO `Namespace`,\n  FROM `Constructor` TO `Module`,\n  FROM `Constructor` TO `Property`,\n  FROM `Constructor` TO `Typedef`,\n  FROM `Template` TO Community,\n  FROM `Module` TO Community,\n  FROM Function TO Process,\n  FROM Method TO Process,\n  FROM Class TO Process,\n  FROM Interface TO Process,\n  FROM `Struct` TO Process,\n  FROM `Constructor` TO Process,\n  FROM `Module` TO Process,\n  FROM `Macro` TO Process,\n  FROM `Impl` TO Process,\n  FROM `Typedef` TO Process,\n  FROM `TypeAlias` TO Process,\n  FROM `Enum` TO Process,\n  FROM `Union` TO Process,\n  FROM `Namespace` TO Process,\n  FROM `Trait` TO Process,\n  FROM `Const` TO Process,\n  FROM `Static` TO Process,\n  FROM `Variable` TO Process,\n  FROM `Property` TO Process,\n  FROM `Record` TO Process,\n  FROM `Delegate` TO Process,\n  FROM `Annotation` TO Process,\n  FROM `Template` TO Process,\n  FROM CodeElement TO Process,\n  FROM Route TO Process,\n  FROM Tool TO Process,\n  FROM BasicBlock TO BasicBlock,\n  type STRING,\n  confidence DOUBLE,\n  reason STRING,\n  step INT32\n)";
 export declare const EMBEDDING_DIMS: number;
 /** HNSW vector index name for the CodeEmbedding table. */
 export declare const EMBEDDING_INDEX_NAME = "code_embedding_idx";

package/dist/core/lbug/schema.js

@@ -380,6 +380,7 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM \`Static\` TO Community,
   FROM \`Variable\` TO Community,
   FROM \`Property\` TO Community,
+  FROM \`Property\` TO \`Property\`,
   FROM \`Record\` TO Method,
   FROM \`Record\` TO \`Constructor\`,
   FROM \`Record\` TO \`Property\`,

package/dist/core/run-analyze.js

@@ -42,11 +42,13 @@ import { EMBEDDING_TABLE_NAME } from './lbug/schema.js';
 import { STALE_HASH_SENTINEL } from './lbug/schema.js';
 import { isSpringBeanCandidateSourceFile } from './ingestion/frameworks/spring/bean-catalog.js';
 import { SPRING_BEAN_INVENTORY_FEATURE } from './ingestion/frameworks/spring/analysis-features.js';
+import { SPRING_CONFIG_BINDINGS_FEATURE } from './ingestion/languages/java/analysis-features.js';
 import { CLASS_FRAMEWORK_ANNOTATIONS_FEATURE, findAnalysisFeatureMismatches, resolveAnalysisFeatureVersions, } from './analysis-features.js';
 import { analyzerRunnerIdentitiesEqual, finalizeAnalyzerRunnerIdentity, resolveAnalyzerRunnerIdentity, } from './analyzer-identity.js';
 const ANALYSIS_FEATURES = [
     CLASS_FRAMEWORK_ANNOTATIONS_FEATURE,
     SPRING_BEAN_INVENTORY_FEATURE,
+    SPRING_CONFIG_BINDINGS_FEATURE,
 ];
 function stringList(value) {
     return Array.isArray(value)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.69",
+  "version": "1.6.10-rc.70",
   "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",