gitnexus 1.6.11-rc.16 → 1.6.11-rc.18

package/dist/core/group/extractors/java-workspace-extractor.js

@@ -1,7 +1,20 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { XMLParser } from 'fast-xml-parser';
 import { shouldIgnorePath, loadIgnoreRules } from '../../../config/ignore-service.js';
 import { logger } from '../../logger.js';
+// POMs are static metadata. Parse hierarchy with a real XML parser, but do not
+// invoke Maven or resolve the effective model. Properties, profiles, and remote
+// parent resolution remain outside this extractor's deterministic boundary.
+const pomParser = new XMLParser({
+    ignoreAttributes: true,
+    removeNSPrefix: true,
+    trimValues: true,
+    parseTagValue: false,
+    processEntities: false,
+    ignoreDeclaration: true,
+    ignorePiTags: true,
+});
 async function parseJavaManifest(repoPath) {
     const pomPath = path.join(repoPath, 'pom.xml');
     try {
@@ -9,13 +22,14 @@ async function parseJavaManifest(repoPath) {
         return parsePom(content);
     }
     catch {
-        // fall through to Gradle
+        // Missing pom.xml — fall through to Gradle.
     }
+    const gradleSidecars = await readGradleSidecars(repoPath);
     for (const name of ['build.gradle.kts', 'build.gradle']) {
         const gradlePath = path.join(repoPath, name);
         try {
             const content = await fs.readFile(gradlePath, 'utf-8');
-            return parseGradle(content, repoPath);
+            return parseGradle(content, repoPath, gradleSidecars);
         }
         catch {
             continue;
@@ -23,45 +37,244 @@ async function parseJavaManifest(repoPath) {
     }
     return null;
 }
+async function readIfPresent(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readGradleSidecars(repoPath) {
+    const [properties, settingsKts, settingsGroovy, catalog] = await Promise.all([
+        readIfPresent(path.join(repoPath, 'gradle.properties')),
+        readIfPresent(path.join(repoPath, 'settings.gradle.kts')),
+        readIfPresent(path.join(repoPath, 'settings.gradle')),
+        readIfPresent(path.join(repoPath, 'gradle', 'libs.versions.toml')),
+    ]);
+    const sidecars = {
+        catalogLibraries: new Map(),
+        catalogBundles: new Map(),
+    };
+    const groupMatch = properties?.match(/(?:^|\n)\s*group\s*=\s*([^\s#]+)/);
+    if (groupMatch)
+        sidecars.propertiesGroup = groupMatch[1];
+    const settings = settingsKts ?? settingsGroovy;
+    const nameMatch = settings?.match(/rootProject\.name\s*=\s*['"]([^'"]+)['"]/);
+    if (nameMatch)
+        sidecars.rootProjectName = nameMatch[1];
+    if (catalog) {
+        const parsed = parseGradleVersionCatalog(catalog);
+        sidecars.catalogLibraries = parsed.libraries;
+        sidecars.catalogBundles = parsed.bundles;
+    }
+    return sidecars;
+}
+function catalogAccessors(alias) {
+    const dotted = alias.replace(/[-_]/g, '.');
+    const camel = alias.replace(/[-_]+([A-Za-z0-9])/g, (_, char) => char.toUpperCase());
+    return [...new Set([alias, dotted, camel])];
+}
+function projectAccessorToArtifactId(accessor) {
+    const last = accessor.split('.').pop();
+    return last.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`).replace(/^-/, '');
+}
+function moduleToGa(module) {
+    const parts = module.split(':');
+    return parts.length >= 2 ? `${parts[0]}:${parts[1]}` : undefined;
+}
+function parseInlineTomlTable(rhs) {
+    const fields = {};
+    for (const match of rhs.matchAll(/([A-Za-z0-9_-]+)\s*=\s*['"]([^'"]+)['"]/g)) {
+        fields[match[1]] = match[2];
+    }
+    return fields;
+}
+/** Default Gradle catalog (`gradle/libs.versions.toml`) — aliases only, no version resolution. */
+function parseGradleVersionCatalog(toml) {
+    const libraries = new Map();
+    const bundles = new Map();
+    let section = 'other';
+    const addLibrary = (alias, ga) => {
+        for (const accessor of catalogAccessors(alias))
+            libraries.set(accessor, ga);
+    };
+    for (const raw of toml.split(/\r?\n/)) {
+        const line = raw.replace(/#.*$/, '').trim();
+        if (!line)
+            continue;
+        const header = line.match(/^\[([^\]]+)\]$/);
+        if (header) {
+            const name = header[1];
+            section =
+                name === 'libraries' || name.endsWith('.libraries')
+                    ? 'libraries'
+                    : name === 'bundles' || name.endsWith('.bundles')
+                        ? 'bundles'
+                        : 'other';
+            continue;
+        }
+        if (section === 'libraries') {
+            const dottedModule = line.match(/^([A-Za-z0-9._-]+)\.module\s*=\s*['"]([^'"]+)['"]$/);
+            if (dottedModule) {
+                const ga = moduleToGa(dottedModule[2]);
+                if (ga)
+                    addLibrary(dottedModule[1], ga);
+                continue;
+            }
+            const assignment = line.match(/^([A-Za-z0-9._-]+)\s*=\s*(.+)$/);
+            if (!assignment)
+                continue;
+            const alias = assignment[1];
+            const rhs = assignment[2].trim();
+            const quoted = rhs.match(/^['"]([^'"]+)['"]$/);
+            if (quoted) {
+                const ga = moduleToGa(quoted[1]);
+                if (ga)
+                    addLibrary(alias, ga);
+                continue;
+            }
+            const table = parseInlineTomlTable(rhs);
+            const ga = table.module
+                ? moduleToGa(table.module)
+                : table.group && table.name
+                    ? `${table.group}:${table.name}`
+                    : undefined;
+            if (ga)
+                addLibrary(alias, ga);
+            continue;
+        }
+        if (section === 'bundles') {
+            const assignment = line.match(/^([A-Za-z0-9._-]+)\s*=\s*\[([^\]]*)\]$/);
+            if (!assignment)
+                continue;
+            const members = [...assignment[2].matchAll(/['"]([^'"]+)['"]/g)].map((match) => match[1]);
+            for (const accessor of catalogAccessors(assignment[1]))
+                bundles.set(accessor, members);
+        }
+    }
+    return { libraries, bundles };
+}
+const GRADLE_GROUP_PATTERNS = [
+    /(?:^|[\n{;])\s*(?:rootProject\.)?group\s*=\s*['"]([^'"]+)['"]/,
+    /(?:^|[\n{;])\s*group\s+['"]([^'"]+)['"]/,
+];
+const GRADLE_COORD_CONFIGS = 'implementation|api|compileOnly|runtimeOnly|testImplementation|testApi|testCompileOnly|compile|kapt|ksp|commonMainImplementation|commonMainApi';
+const CATALOG_ALIAS = '([A-Za-z0-9_]+(?:\\.[A-Za-z0-9_]+)*)(?:\\.get\\(\\)|\\.asProvider\\(\\))?';
+function gradleDepRe(suffix) {
+    return new RegExp(`(?:${GRADLE_COORD_CONFIGS})\\s*${suffix}`, 'g');
+}
+function parseGradleGroup(content) {
+    for (const pattern of GRADLE_GROUP_PATTERNS) {
+        const match = content.match(pattern);
+        if (match?.[1])
+            return match[1];
+    }
+    return undefined;
+}
+function asXmlNode(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function xmlText(value) {
+    if (typeof value === 'string' || typeof value === 'number') {
+        const text = String(value).trim();
+        return text || undefined;
+    }
+    const nested = asXmlNode(value)?.['#text'];
+    if (nested === undefined)
+        return undefined;
+    return xmlText(nested);
+}
+function xmlChildText(node, name) {
+    return node ? xmlText(node[name]) : undefined;
+}
+function asList(value) {
+    if (value === undefined || value === null)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+/** Direct project dependencies only — not BOM, profiles, or plugin classpath. */
+function collectProjectDependencies(project, deps) {
+    const dependencies = asXmlNode(project.dependencies);
+    if (!dependencies)
+        return;
+    for (const dep of asList(dependencies.dependency)) {
+        const depNode = asXmlNode(dep);
+        const groupId = xmlChildText(depNode, 'groupId');
+        const artifactId = xmlChildText(depNode, 'artifactId');
+        if (groupId && artifactId)
+            deps.push(`${groupId}:${artifactId}`);
+    }
+}
 function parsePom(content) {
-    const projectGroupMatch = content.match(/<project[^>]*>[\s\S]*?<groupId>([^<]+)<\/groupId>/);
-    const projectArtifactMatch = content.match(/<project[^>]*>[\s\S]*?<artifactId>([^<]+)<\/artifactId>/);
-    if (!projectGroupMatch || !projectArtifactMatch)
+    let parsed;
+    try {
+        // parseSourceSafe guards tree-sitter's Windows SIGSEGV by switching to a
+        // chunked input callback above 16 KB; XMLParser only accepts XML text, so
+        // routing POMs through it silently yields an empty document.
+        // eslint-disable-next-line gitnexus/require-safe-parse
+        parsed = pomParser.parse(content);
+    }
+    catch {
         return null;
-    const groupId = projectGroupMatch[1].trim();
-    const artifactId = projectArtifactMatch[1].trim();
-    const deps = [];
-    const depBlocks = content.matchAll(/<dependency>\s*([\s\S]*?)<\/dependency>/g);
-    for (const block of depBlocks) {
-        const gMatch = block[1].match(/<groupId>([^<]+)<\/groupId>/);
-        const aMatch = block[1].match(/<artifactId>([^<]+)<\/artifactId>/);
-        if (gMatch && aMatch) {
-            deps.push(`${gMatch[1].trim()}:${aMatch[1].trim()}`);
-        }
     }
+    const project = asXmlNode(asXmlNode(parsed)?.project);
+    if (!project)
+        return null;
+    // Maven inherits groupId from <parent>, but artifactId is always the
+    // project's own direct child and must never fall back to parent.artifactId.
+    const groupId = xmlChildText(project, 'groupId') ?? xmlChildText(asXmlNode(project.parent), 'groupId');
+    const artifactId = xmlChildText(project, 'artifactId');
+    if (!groupId || !artifactId)
+        return null;
+    const deps = [];
+    collectProjectDependencies(project, deps);
     return { groupId, artifactId, deps: [...new Set(deps)] };
 }
-function parseGradle(content, repoPath) {
-    const groupMatch = content.match(/group\s*=\s*['"]([^'"]+)['"]/);
-    const dirName = path.basename(repoPath);
-    const groupId = groupMatch ? groupMatch[1] : '';
+function parseGradle(content, repoPath, sidecars = { catalogLibraries: new Map(), catalogBundles: new Map() }) {
+    // Static text + default catalog file. Do not execute Gradle.
+    const groupId = parseGradleGroup(content) ?? sidecars.propertiesGroup ?? '';
     if (!groupId)
         return null;
-    const artifactId = dirName;
+    const artifactId = sidecars.rootProjectName ?? path.basename(repoPath);
+    const { catalogLibraries, catalogBundles } = sidecars;
     const deps = [];
-    // implementation("group:artifact:version") or api("group:artifact:version")
-    const depMatches = content.matchAll(/(?:implementation|api|compileOnly|runtimeOnly)\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
-    for (const m of depMatches) {
-        const parts = m[1].split(':');
-        if (parts.length >= 2) {
-            deps.push(`${parts[0]}:${parts[1]}`);
+    const pushCatalogAlias = (alias) => {
+        const ga = catalogLibraries.get(alias);
+        if (ga)
+            deps.push(ga);
+    };
+    const namedPattern = gradleDepRe(`(?:\\(\\s*)?(?:group\\s*=\\s*['"](?<group1>[^'"]+)['"]\\s*,\\s*name\\s*=\\s*['"](?<name1>[^'"]+)['"]|name\\s*=\\s*['"](?<name2>[^'"]+)['"]\\s*,\\s*group\\s*=\\s*['"](?<group2>[^'"]+)['"]|group:\\s*['"](?<group3>[^'"]+)['"]\\s*,\\s*name:\\s*['"](?<name3>[^'"]+)['"]|name:\\s*['"](?<name4>[^'"]+)['"]\\s*,\\s*group:\\s*['"](?<group4>[^'"]+)['"])`);
+    for (const match of content.matchAll(namedPattern)) {
+        const group = match.groups?.group1 ?? match.groups?.group2 ?? match.groups?.group3 ?? match.groups?.group4;
+        const name = match.groups?.name1 ?? match.groups?.name2 ?? match.groups?.name3 ?? match.groups?.name4;
+        if (group && name)
+            deps.push(`${group}:${name}`);
+    }
+    for (const match of content.matchAll(gradleDepRe(`(?:\\(\\s*)?libs(?:\\.libraries)?\\.(?!bundles\\.|plugins\\.)${CATALOG_ALIAS}`))) {
+        pushCatalogAlias(match[1]);
+    }
+    for (const match of content.matchAll(gradleDepRe(`(?:\\(\\s*)?libs\\.bundles\\.${CATALOG_ALIAS}`))) {
+        for (const member of catalogBundles.get(match[1]) ?? []) {
+            for (const accessor of catalogAccessors(member))
+                pushCatalogAlias(accessor);
         }
     }
-    // implementation(project(":subproject"))
-    const projDeps = content.matchAll(/(?:implementation|api)\s*\(\s*project\s*\(\s*['"]([^'"]+)['"]\s*\)\s*\)/g);
-    for (const m of projDeps) {
-        const subName = m[1].replace(/^:/, '');
-        deps.push(`${groupId}:${subName}`);
+    for (const match of content.matchAll(gradleDepRe(`\\(\\s*projects\\.([A-Za-z][A-Za-z0-9.]*)`))) {
+        deps.push(`${groupId}:${projectAccessorToArtifactId(match[1])}`);
+    }
+    for (const match of content.matchAll(gradleDepRe(`(?:\\(\\s*['"]([^'"]+)['"]\\s*\\)|['"]([^'"]+)['"])`))) {
+        const coord = match[1] ?? match[2];
+        if (!coord)
+            continue;
+        const parts = coord.split(':');
+        if (parts.length >= 2)
+            deps.push(`${parts[0]}:${parts[1]}`);
+    }
+    for (const match of content.matchAll(gradleDepRe(`(?:\\(\\s*)?project\\s*\\(\\s*['"]([^'"]+)['"]\\s*\\)`))) {
+        deps.push(`${groupId}:${match[1].replace(/^:/, '')}`);
     }
     return { groupId, artifactId, deps: [...new Set(deps)] };
 }

package/dist/core/ingestion/frameworks/spring/dynamic-lookups.d.ts

@@ -0,0 +1,22 @@
+import type { ParsedFile, Range, ScopeId } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { DiInjectionMatch } from '../../di-extractors/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+export interface SpringDynamicLookupFact {
+    readonly ownerScopeId: ScopeId;
+    readonly ownerRange: Range;
+    readonly receiverName: string;
+    readonly methodName: string;
+    readonly targetTypeName: string;
+}
+export declare function springDynamicLookupCardinality(receiverName: string, methodName: string): DiInjectionMatch['cardinality'] | null;
+export interface SpringDynamicLookupMetadataAdapter {
+    getFacts(filePath: string): readonly SpringDynamicLookupFact[];
+}
+/**
+ * Attach AST-captured programmatic Spring lookups to the framework-neutral DI
+ * resolver. Java/Kotlin own syntax capture; this shared JVM/Spring seam owns
+ * import-aware type binding and metadata attachment.
+ */
+export declare function createSpringDynamicLookupMetadataAttacher(adapter: SpringDynamicLookupMetadataAdapter): (graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes) => void;

package/dist/core/ingestion/frameworks/spring/dynamic-lookups.js

@@ -0,0 +1,124 @@
+import { SPRING_DI_INJECTION_SITES_PROPERTY } from '../../di-extractors/spring.js';
+import { resolveCallerGraphId, resolveDefGraphId, } from '../../scope-resolution/graph-bridge/ids.js';
+import { isClassLike, lookupBindingsAt } from '../../scope-resolution/scope/walkers.js';
+const COLLECTION_LOOKUP_METHODS = new Set(['getBeans', 'getBeansOfType']);
+const SINGLE_LOOKUP_METHODS = new Set(['getBean']);
+/**
+ * Distinctive utility names plus conventional Spring context variable names.
+ * Generic locals remain recall-oriented because repositories often omit the
+ * third-party context type from the index; AST call/class-literal gates and
+ * import-aware target resolution prevent the raw-text false-positive class.
+ */
+const KNOWN_RECEIVERS = new Set([
+    'SpringContextUtil',
+    'SpringContextHolder',
+    'SpringBeanUtil',
+    'ApplicationContextProvider',
+    'BeanFactoryProvider',
+    'ApplicationContext',
+    'BeanFactory',
+    'ListableBeanFactory',
+    'applicationContext',
+    'context',
+    'ctx',
+    'appContext',
+    'beanFactory',
+]);
+export function springDynamicLookupCardinality(receiverName, methodName) {
+    const receiverSimpleName = receiverName.slice(receiverName.lastIndexOf('.') + 1);
+    if (!KNOWN_RECEIVERS.has(receiverSimpleName))
+        return null;
+    if (COLLECTION_LOOKUP_METHODS.has(methodName))
+        return 'collection';
+    if (SINGLE_LOOKUP_METHODS.has(methodName))
+        return 'single';
+    return null;
+}
+function visibleTypeDefinitions(fact, indexes) {
+    const simpleName = fact.targetTypeName.slice(fact.targetTypeName.lastIndexOf('.') + 1);
+    let scopeId = fact.ownerScopeId;
+    while (scopeId !== null) {
+        const visible = lookupBindingsAt(scopeId, simpleName, indexes)
+            .map(({ def }) => def)
+            .filter((def) => isClassLike(def.type))
+            .filter((def) => !fact.targetTypeName.includes('.') || def.qualifiedName === fact.targetTypeName);
+        if (visible.length > 0) {
+            const unique = new Map(visible.map((def) => [def.nodeId, def]));
+            return [...unique.values()];
+        }
+        scopeId = indexes.scopeTree.getScope(scopeId)?.parent ?? null;
+    }
+    return [];
+}
+function resolveTargetTypeName(graph, fact, callerLanguage, nodeLookup, indexes) {
+    const graphIds = new Set();
+    for (const definition of visibleTypeDefinitions(fact, indexes)) {
+        const graphId = resolveDefGraphId(definition.filePath, definition, nodeLookup);
+        if (graphId === undefined)
+            continue;
+        const node = graph.getNode(graphId);
+        if ((node?.label === 'Class' ||
+            node?.label === 'Interface' ||
+            node?.label === 'Record' ||
+            node?.label === 'Enum') &&
+            node.properties.language === callerLanguage) {
+            graphIds.add(graphId);
+        }
+    }
+    if (graphIds.size !== 1)
+        return undefined;
+    const targetId = graphIds.values().next().value;
+    if (targetId === undefined)
+        return undefined;
+    const target = graph.getNode(targetId);
+    if (target === undefined)
+        return undefined;
+    const qualifiedName = target.properties.qualifiedName;
+    return typeof qualifiedName === 'string' ? qualifiedName : target.properties.name;
+}
+/**
+ * Attach AST-captured programmatic Spring lookups to the framework-neutral DI
+ * resolver. Java/Kotlin own syntax capture; this shared JVM/Spring seam owns
+ * import-aware type binding and metadata attachment.
+ */
+export function createSpringDynamicLookupMetadataAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        for (const parsed of parsedFiles) {
+            for (const fact of adapter.getFacts(parsed.filePath)) {
+                const cardinality = springDynamicLookupCardinality(fact.receiverName, fact.methodName);
+                if (cardinality === null)
+                    continue;
+                const callerId = resolveCallerGraphId(fact.ownerScopeId, indexes, nodeLookup, {
+                    startLine: fact.ownerRange.startLine,
+                    startCol: fact.ownerRange.startCol,
+                });
+                if (callerId === undefined)
+                    continue;
+                const caller = graph.getNode(callerId);
+                if (caller === undefined ||
+                    (caller.label !== 'Function' &&
+                        caller.label !== 'Method' &&
+                        caller.label !== 'Constructor')) {
+                    continue;
+                }
+                const targetTypeName = resolveTargetTypeName(graph, fact, caller.properties.language, nodeLookup, indexes);
+                if (targetTypeName === undefined)
+                    continue;
+                const match = {
+                    targetTypeName,
+                    cardinality,
+                    edgeSource: 'site',
+                    reason: `Spring dynamic lookup: ${fact.receiverName}.${fact.methodName}(${fact.targetTypeName})`,
+                };
+                // Singular lookups intentionally use the shared DI selection policy:
+                // a unique/@Primary candidate wins; unresolved multiplicity is an
+                // explicit 0.5-confidence fan-out rather than a guessed runtime winner.
+                const existing = caller.properties[SPRING_DI_INJECTION_SITES_PROPERTY];
+                caller.properties[SPRING_DI_INJECTION_SITES_PROPERTY] = [
+                    ...(Array.isArray(existing) ? existing : []),
+                    match,
+                ];
+            }
+        }
+    };
+}

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

@@ -5,6 +5,7 @@ import type { JavaSpringConfigConsumerFact } from './spring-config-bindings.js';
 import type { JavaSpringAopFact } from './spring-aop.js';
 import type { JavaSpringConditionalFact } from './spring-conditionals.js';
 import type { JavaSpringDiClassFact } from './spring-di.js';
+import type { SpringDynamicLookupFact } from '../../frameworks/spring/dynamic-lookups.js';
 import type { JavaSpringNonHttpHandlerFact } from './spring-non-http-handlers.js';
 export type JavaClassAnnotationFact = ClassAnnotationFact;
 export interface JavaCaptureSideChannel {
@@ -15,6 +16,7 @@ export interface JavaCaptureSideChannel {
     readonly springConfigConsumers?: readonly JavaSpringConfigConsumerFact[];
     readonly springConditionalFacts?: readonly JavaSpringConditionalFact[];
     readonly springDiFacts?: readonly JavaSpringDiClassFact[];
+    readonly springDynamicLookupFacts?: readonly SpringDynamicLookupFact[];
     readonly springNonHttpHandlerFacts?: readonly JavaSpringNonHttpHandlerFact[];
 }
 /** Clear facts retained by a prior workspace pass in a long-lived process. */
@@ -29,6 +31,8 @@ export declare function setJavaSpringConditionalFacts(filePath: string, facts: r
 export declare function getJavaSpringConditionalFacts(filePath: string): readonly JavaSpringConditionalFact[];
 export declare function setJavaSpringDiFacts(filePath: string, facts: readonly JavaSpringDiClassFact[]): void;
 export declare function getJavaSpringDiFacts(filePath: string): readonly JavaSpringDiClassFact[];
+export declare function setJavaSpringDynamicLookupFacts(filePath: string, facts: readonly SpringDynamicLookupFact[]): void;
+export declare function getJavaSpringDynamicLookupFacts(filePath: string): readonly SpringDynamicLookupFact[];
 export declare function setJavaSpringNonHttpHandlerFacts(filePath: string, facts: readonly JavaSpringNonHttpHandlerFact[]): void;
 export declare function getJavaSpringNonHttpHandlerFacts(filePath: string): readonly JavaSpringNonHttpHandlerFact[];
 /** Snapshot worker-local Java annotation facts for ParsedFile serialization. */

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

@@ -6,6 +6,7 @@ const springAopFacts = new Map();
 const springConfigConsumers = new Map();
 const springConditionalFacts = new Map();
 const springDiFacts = new Map();
+const springDynamicLookupFacts = new Map();
 const springNonHttpHandlerFacts = new Map();
 /** Clear facts retained by a prior workspace pass in a long-lived process. */
 export function clearJavaClassAnnotationFacts() {
@@ -14,6 +15,7 @@ export function clearJavaClassAnnotationFacts() {
     springConfigConsumers.clear();
     springConditionalFacts.clear();
     springDiFacts.clear();
+    springDynamicLookupFacts.clear();
     springNonHttpHandlerFacts.clear();
 }
 export function setJavaSpringAopFacts(filePath, facts) {
@@ -56,6 +58,15 @@ export function setJavaSpringDiFacts(filePath, facts) {
 export function getJavaSpringDiFacts(filePath) {
     return springDiFacts.get(filePath) ?? [];
 }
+export function setJavaSpringDynamicLookupFacts(filePath, facts) {
+    if (facts.length === 0)
+        springDynamicLookupFacts.delete(filePath);
+    else
+        springDynamicLookupFacts.set(filePath, facts);
+}
+export function getJavaSpringDynamicLookupFacts(filePath) {
+    return springDynamicLookupFacts.get(filePath) ?? [];
+}
 export function setJavaSpringNonHttpHandlerFacts(filePath, facts) {
     if (facts.length === 0)
         springNonHttpHandlerFacts.delete(filePath);
@@ -72,6 +83,7 @@ export function collectJavaCaptureSideChannel(filePath) {
     const configConsumers = springConfigConsumers.get(filePath) ?? [];
     const conditionFacts = springConditionalFacts.get(filePath) ?? [];
     const diFacts = springDiFacts.get(filePath) ?? [];
+    const dynamicLookupFacts = springDynamicLookupFacts.get(filePath) ?? [];
     const nonHttpHandlerFacts = springNonHttpHandlerFacts.get(filePath) ?? [];
     const packageFact = getJavaPackageFact(filePath);
     if (facts.length === 0 &&
@@ -79,6 +91,7 @@ export function collectJavaCaptureSideChannel(filePath) {
         configConsumers.length === 0 &&
         conditionFacts.length === 0 &&
         diFacts.length === 0 &&
+        dynamicLookupFacts.length === 0 &&
         nonHttpHandlerFacts.length === 0 &&
         packageFact === undefined) {
         return undefined;
@@ -91,6 +104,7 @@ export function collectJavaCaptureSideChannel(filePath) {
         ...(configConsumers.length > 0 ? { springConfigConsumers: configConsumers } : {}),
         ...(conditionFacts.length > 0 ? { springConditionalFacts: conditionFacts } : {}),
         ...(diFacts.length > 0 ? { springDiFacts: diFacts } : {}),
+        ...(dynamicLookupFacts.length > 0 ? { springDynamicLookupFacts: dynamicLookupFacts } : {}),
         ...(nonHttpHandlerFacts.length > 0 ? { springNonHttpHandlerFacts: nonHttpHandlerFacts } : {}),
     };
 }
@@ -110,6 +124,7 @@ export function applyJavaCaptureSideChannel(parsed) {
         setJavaSpringConfigConsumerFacts(parsed.filePath, []);
         setJavaSpringConditionalFacts(parsed.filePath, []);
         setJavaSpringDiFacts(parsed.filePath, []);
+        setJavaSpringDynamicLookupFacts(parsed.filePath, []);
         setJavaSpringNonHttpHandlerFacts(parsed.filePath, []);
         setJavaPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
@@ -119,6 +134,7 @@ export function applyJavaCaptureSideChannel(parsed) {
     setJavaSpringConfigConsumerFacts(parsed.filePath, Array.isArray(data.springConfigConsumers) ? data.springConfigConsumers : []);
     setJavaSpringConditionalFacts(parsed.filePath, Array.isArray(data.springConditionalFacts) ? data.springConditionalFacts : []);
     setJavaSpringDiFacts(parsed.filePath, Array.isArray(data.springDiFacts) ? data.springDiFacts : []);
+    setJavaSpringDynamicLookupFacts(parsed.filePath, Array.isArray(data.springDynamicLookupFacts) ? data.springDynamicLookupFacts : []);
     setJavaSpringNonHttpHandlerFacts(parsed.filePath, Array.isArray(data.springNonHttpHandlerFacts) ? data.springNonHttpHandlerFacts : []);
     setJavaPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
 }

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

@@ -7,11 +7,12 @@ 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, setJavaSpringAopFacts, setJavaSpringConfigConsumerFacts, setJavaSpringConditionalFacts, setJavaSpringDiFacts, setJavaSpringNonHttpHandlerFacts, } from './capture-side-channel.js';
+import { setJavaClassAnnotationFacts, setJavaSpringAopFacts, setJavaSpringConfigConsumerFacts, setJavaSpringConditionalFacts, setJavaSpringDiFacts, setJavaSpringDynamicLookupFacts, setJavaSpringNonHttpHandlerFacts, } 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';
 import { captureJavaSpringDiClassFact } from './spring-di.js';
+import { captureJavaSpringDynamicLookupFact } from './spring-dynamic-lookup.js';
 import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 import { captureJavaSpringAopFacts } from './spring-aop.js';
 import { captureJavaSpringConditionalFacts, } from './spring-conditionals.js';
@@ -98,6 +99,8 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
     const springDiFacts = [];
     const springNonHttpHandlerFacts = [];
     const springDiClassNodeIds = new Set();
+    const springDynamicLookupFacts = [];
+    const springDynamicLookupNodeIds = new Set();
     for (const m of rawMatches) {
         const grouped = {};
         // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
@@ -116,6 +119,13 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
         }
         if (Object.keys(grouped).length === 0)
             continue;
+        const dynamicLookupNode = nodeIfType(nodeMap['@reference.call.member'], 'method_invocation');
+        if (dynamicLookupNode !== null && !springDynamicLookupNodeIds.has(dynamicLookupNode.id)) {
+            springDynamicLookupNodeIds.add(dynamicLookupNode.id);
+            const fact = captureJavaSpringDynamicLookupFact(dynamicLookupNode, filePath);
+            if (fact !== null)
+                springDynamicLookupFacts.push(fact);
+        }
         const springAopTypeNode = [
             nodeIfType(nodeMap['@scope.class'], 'class_declaration'),
             nodeIfType(nodeMap['@scope.class'], 'interface_declaration'),
@@ -287,6 +297,7 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
     setJavaSpringAopFacts(filePath, springAopFacts);
     setJavaSpringConditionalFacts(filePath, springConditionalFacts);
     setJavaSpringDiFacts(filePath, springDiFacts);
+    setJavaSpringDynamicLookupFacts(filePath, springDynamicLookupFacts);
     setJavaSpringNonHttpHandlerFacts(filePath, springNonHttpHandlerFacts);
     return [
         ...resolveVarTypeBindings(out),

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-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;

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

@@ -0,0 +1,62 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringDynamicLookupMetadataAttacher, springDynamicLookupCardinality, } from '../../frameworks/spring/dynamic-lookups.js';
+import { findAncestorBeforeBoundary, nodeToCapture, } from '../../utils/ast-helpers.js';
+import { getJavaSpringDynamicLookupFacts } from './capture-side-channel.js';
+const CALLABLE_NODE_TYPES = new Set([
+    'method_declaration',
+    'constructor_declaration',
+    'compact_constructor_declaration',
+]);
+const NO_CALLABLE_BOUNDARIES = new Set();
+function classLiteralTypeName(argument) {
+    if (argument.type !== 'class_literal' || argument.namedChildCount !== 1)
+        return null;
+    return argument.namedChild(0)?.text.trim() ?? null;
+}
+/** Capture real Java method invocations; comments and literals are never visited as calls. */
+export function captureJavaSpringDynamicLookupFact(node, filePath) {
+    if (node.type !== 'method_invocation')
+        return null;
+    const receiverName = node.childForFieldName('object')?.text.trim();
+    const methodName = node.childForFieldName('name')?.text.trim();
+    const argumentsNode = node.childForFieldName('arguments');
+    if (receiverName === undefined || methodName === undefined || argumentsNode === null)
+        return null;
+    if (springDynamicLookupCardinality(receiverName, methodName) === null)
+        return null;
+    const argumentsWithoutComments = argumentsNode.namedChildren.filter((child) => child.type !== 'line_comment' && child.type !== 'block_comment');
+    if (argumentsWithoutComments.length !== 1)
+        return null;
+    const argument = argumentsWithoutComments[0];
+    if (argument === undefined)
+        return null;
+    const targetTypeName = classLiteralTypeName(argument);
+    if (targetTypeName === null)
+        return null;
+    const owner = findAncestorBeforeBoundary(node, CALLABLE_NODE_TYPES, NO_CALLABLE_BOUNDARIES);
+    if (owner === null)
+        return null;
+    const ownerCapture = nodeToCapture('@spring-dynamic-lookup.owner', owner);
+    return {
+        ownerScopeId: makeScopeId({
+            filePath,
+            range: ownerCapture.range,
+            kind: 'Function',
+        }),
+        ownerRange: ownerCapture.range,
+        receiverName,
+        methodName,
+        targetTypeName,
+    };
+}
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export function captureJavaSpringDynamicLookupFacts(rootNode, filePath) {
+    return rootNode
+        .descendantsOfType('method_invocation')
+        .map((node) => captureJavaSpringDynamicLookupFact(node, filePath))
+        .filter((fact) => fact !== null);
+}
+/** Attach Java lookup facts for later resolution by the shared DI phase. */
+export const attachJavaSpringDynamicLookup = createSpringDynamicLookupMetadataAttacher({
+    getFacts: getJavaSpringDynamicLookupFacts,
+});

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

@@ -39,6 +39,7 @@
 import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
 import { type ClassAnnotationFact } from '../../frameworks/spring/bean-candidates.js';
 import { type JvmPackageFact } from '../jvm/package-facts.js';
+import type { SpringDynamicLookupFact } from '../../frameworks/spring/dynamic-lookups.js';
 import type { KotlinSpringAopFact } from './spring-aop.js';
 import type { KotlinSpringConditionalFact } from './spring-conditionals.js';
 import type { KotlinSpringDiClassFact } from './spring-di.js';
@@ -63,6 +64,8 @@ export interface KotlinCaptureSideChannel {
     readonly springConditionalFacts?: readonly KotlinSpringConditionalFact[];
     /** Constructor, property, and method injection syntax captured per class. */
     readonly springDiFacts?: readonly KotlinSpringDiClassFact[];
+    /** Programmatic Spring bean lookups captured per callable. */
+    readonly springDynamicLookupFacts?: readonly SpringDynamicLookupFact[];
     /** Scheduled, event, messaging, and managed-job handler syntax captured per callable. */
     readonly springNonHttpHandlerFacts?: readonly KotlinSpringNonHttpHandlerFact[];
 }
@@ -75,6 +78,8 @@ export declare function setKotlinSpringConditionalFacts(filePath: string, facts:
 export declare function getKotlinSpringConditionalFacts(filePath: string): readonly KotlinSpringConditionalFact[];
 export declare function setKotlinSpringDiFacts(filePath: string, facts: readonly KotlinSpringDiClassFact[]): void;
 export declare function getKotlinSpringDiFacts(filePath: string): readonly KotlinSpringDiClassFact[];
+export declare function setKotlinSpringDynamicLookupFacts(filePath: string, facts: readonly SpringDynamicLookupFact[]): void;
+export declare function getKotlinSpringDynamicLookupFacts(filePath: string): readonly SpringDynamicLookupFact[];
 export declare function setKotlinSpringNonHttpHandlerFacts(filePath: string, facts: readonly KotlinSpringNonHttpHandlerFact[]): void;
 export declare function getKotlinSpringNonHttpHandlerFacts(filePath: string): readonly KotlinSpringNonHttpHandlerFact[];
 /**

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

@@ -44,12 +44,14 @@ const classAnnotations = createClassAnnotationFactStore();
 const springAopFacts = new Map();
 const springConditionalFacts = new Map();
 const springDiFacts = new Map();
+const springDynamicLookupFacts = new Map();
 const springNonHttpHandlerFacts = new Map();
 export function clearKotlinClassAnnotationFacts() {
     classAnnotations.clear();
     springAopFacts.clear();
     springConditionalFacts.clear();
     springDiFacts.clear();
+    springDynamicLookupFacts.clear();
     springNonHttpHandlerFacts.clear();
 }
 export function setKotlinSpringAopFacts(filePath, facts) {
@@ -85,6 +87,15 @@ export function setKotlinSpringDiFacts(filePath, facts) {
 export function getKotlinSpringDiFacts(filePath) {
     return springDiFacts.get(filePath) ?? [];
 }
+export function setKotlinSpringDynamicLookupFacts(filePath, facts) {
+    if (facts.length === 0)
+        springDynamicLookupFacts.delete(filePath);
+    else
+        springDynamicLookupFacts.set(filePath, facts);
+}
+export function getKotlinSpringDynamicLookupFacts(filePath) {
+    return springDynamicLookupFacts.get(filePath) ?? [];
+}
 export function setKotlinSpringNonHttpHandlerFacts(filePath, facts) {
     if (facts.length === 0)
         springNonHttpHandlerFacts.delete(filePath);
@@ -105,6 +116,7 @@ export function collectKotlinCaptureSideChannel(filePath) {
     const aopFacts = springAopFacts.get(filePath) ?? [];
     const conditionFacts = springConditionalFacts.get(filePath) ?? [];
     const diFacts = springDiFacts.get(filePath) ?? [];
+    const dynamicLookupFacts = springDynamicLookupFacts.get(filePath) ?? [];
     const nonHttpHandlerFacts = springNonHttpHandlerFacts.get(filePath) ?? [];
     const packageFact = getKotlinPackageFact(filePath);
     if (companionScopes.length === 0 &&
@@ -112,6 +124,7 @@ export function collectKotlinCaptureSideChannel(filePath) {
         aopFacts.length === 0 &&
         conditionFacts.length === 0 &&
         diFacts.length === 0 &&
+        dynamicLookupFacts.length === 0 &&
         nonHttpHandlerFacts.length === 0 &&
         packageFact === undefined) {
         return undefined;
@@ -124,6 +137,7 @@ export function collectKotlinCaptureSideChannel(filePath) {
         ...(aopFacts.length > 0 ? { springAopFacts: aopFacts } : {}),
         ...(conditionFacts.length > 0 ? { springConditionalFacts: conditionFacts } : {}),
         ...(diFacts.length > 0 ? { springDiFacts: diFacts } : {}),
+        ...(dynamicLookupFacts.length > 0 ? { springDynamicLookupFacts: dynamicLookupFacts } : {}),
         ...(nonHttpHandlerFacts.length > 0 ? { springNonHttpHandlerFacts: nonHttpHandlerFacts } : {}),
     };
 }
@@ -147,6 +161,7 @@ export function applyKotlinCaptureSideChannel(parsed) {
         setKotlinSpringAopFacts(parsed.filePath, []);
         setKotlinSpringConditionalFacts(parsed.filePath, []);
         setKotlinSpringDiFacts(parsed.filePath, []);
+        setKotlinSpringDynamicLookupFacts(parsed.filePath, []);
         setKotlinSpringNonHttpHandlerFacts(parsed.filePath, []);
         setKotlinPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
@@ -158,6 +173,7 @@ export function applyKotlinCaptureSideChannel(parsed) {
     setKotlinSpringAopFacts(parsed.filePath, Array.isArray(data.springAopFacts) ? data.springAopFacts : []);
     setKotlinSpringConditionalFacts(parsed.filePath, Array.isArray(data.springConditionalFacts) ? data.springConditionalFacts : []);
     setKotlinSpringDiFacts(parsed.filePath, Array.isArray(data.springDiFacts) ? data.springDiFacts : []);
+    setKotlinSpringDynamicLookupFacts(parsed.filePath, Array.isArray(data.springDynamicLookupFacts) ? data.springDynamicLookupFacts : []);
     setKotlinSpringNonHttpHandlerFacts(parsed.filePath, Array.isArray(data.springNonHttpHandlerFacts) ? data.springNonHttpHandlerFacts : []);
     setKotlinPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
 }

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

@@ -10,10 +10,11 @@ import { normalizeKotlinType } from './interpret.js';
 import { synthesizeKotlinReceiverBinding } from './receiver-binding.js';
 import { getKotlinParser, getKotlinScopeQuery } from './query.js';
 import { markCompanionScope } from './companion-scopes.js';
-import { setKotlinClassAnnotationFacts, setKotlinSpringAopFacts, setKotlinSpringConditionalFacts, setKotlinSpringDiFacts, setKotlinSpringNonHttpHandlerFacts, } from './capture-side-channel.js';
+import { setKotlinClassAnnotationFacts, setKotlinSpringAopFacts, setKotlinSpringConditionalFacts, setKotlinSpringDiFacts, setKotlinSpringDynamicLookupFacts, setKotlinSpringNonHttpHandlerFacts, } from './capture-side-channel.js';
 import { captureKotlinPackageFact } from './package-facts.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
 import { captureKotlinSpringDiClassFact } from './spring-di.js';
+import { captureKotlinSpringDynamicLookupFact } from './spring-dynamic-lookup.js';
 import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 import { captureKotlinSpringAopFacts } from './spring-aop.js';
 import { captureKotlinSpringConditionalFacts, } from './spring-conditionals.js';
@@ -75,6 +76,8 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     const springNonHttpHandlerFacts = [];
     const springNonHttpHandlerTypeNodeIds = new Set();
     const springDiClassNodeIds = new Set();
+    const springDynamicLookupFacts = [];
+    const springDynamicLookupNodeIds = new Set();
     const returnTypes = collectKotlinReturnTypeTexts(tree.rootNode);
     out.push(...synthesizeKotlinLocalAssignmentBindings(tree.rootNode, returnTypes));
     out.push(...synthesizeKotlinLoopBindings(tree.rootNode, returnTypes));
@@ -97,6 +100,13 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
         }
         if (Object.keys(grouped).length === 0)
             continue;
+        const dynamicLookupNode = nodeIfType(groupedNodes['@reference.call.member'], 'call_expression');
+        if (dynamicLookupNode !== null && !springDynamicLookupNodeIds.has(dynamicLookupNode.id)) {
+            springDynamicLookupNodeIds.add(dynamicLookupNode.id);
+            const fact = captureKotlinSpringDynamicLookupFact(dynamicLookupNode, filePath);
+            if (fact !== null)
+                springDynamicLookupFacts.push(fact);
+        }
         // tree-sitter-kotlin represents both classes and interfaces with
         // `class_declaration`; `object_declaration` is the separate object form.
         const springAopTypeNode = [
@@ -279,6 +289,7 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     setKotlinSpringAopFacts(filePath, springAopFacts);
     setKotlinSpringConditionalFacts(filePath, springConditionalFacts);
     setKotlinSpringDiFacts(filePath, springDiFacts);
+    setKotlinSpringDynamicLookupFacts(filePath, springDynamicLookupFacts);
     setKotlinSpringNonHttpHandlerFacts(filePath, springNonHttpHandlerFacts);
     out.push(...synthesizeCallableFlowCaptures(tree.rootNode, KOTLIN_CALLABLE_CAPTURE_OPTIONS));
     return out;

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

@@ -15,6 +15,7 @@ import { clearKotlinPackageFacts } from './package-facts.js';
 import { attachKotlinSpringDiMetadata } from './spring-di.js';
 import { attachKotlinSpringConditionalMetadata } from './spring-conditionals.js';
 import { attachKotlinSpringNonHttpHandlerMetadata } from './spring-non-http-handlers.js';
+import { attachKotlinSpringDynamicLookup } from './spring-dynamic-lookup.js';
 /**
  * Kotlin scope resolver for RFC #909 Ring 3.
  *
@@ -121,6 +122,7 @@ export const kotlinScopeResolver = {
         attachKotlinSpringConditionalMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachKotlinSpringDiMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachKotlinSpringNonHttpHandlerMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachKotlinSpringDynamicLookup(graph, parsedFiles, nodeLookup, indexes);
     },
 };
 /**

package/dist/core/ingestion/languages/kotlin/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 Kotlin calls using `Type::class` or `Type::class.java`. */
+export declare function captureKotlinSpringDynamicLookupFact(node: SyntaxNode, filePath: string): SpringDynamicLookupFact | null;
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export declare function captureKotlinSpringDynamicLookupFacts(rootNode: SyntaxNode, filePath: string): SpringDynamicLookupFact[];
+/** Attach Kotlin lookup facts for later resolution by the shared DI phase. */
+export declare const attachKotlinSpringDynamicLookup: (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;

package/dist/core/ingestion/languages/kotlin/spring-dynamic-lookup.js

@@ -0,0 +1,77 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringDynamicLookupMetadataAttacher, springDynamicLookupCardinality, } from '../../frameworks/spring/dynamic-lookups.js';
+import { findAncestorBeforeBoundary, nodeToCapture, } from '../../utils/ast-helpers.js';
+import { getKotlinSpringDynamicLookupFacts } from './capture-side-channel.js';
+// Kotlin emits graph callables for functions and secondary constructors.
+// `init {}` / primary-constructor bodies have no independent callable node, so
+// attributing their lookups to the enclosing Class would violate graph semantics.
+const CALLABLE_NODE_TYPES = new Set(['function_declaration', 'secondary_constructor']);
+const NO_CALLABLE_BOUNDARIES = new Set();
+const KOTLIN_CLASS_LITERAL = /^([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*)::class(?:\.java)?$/;
+function navigationParts(node) {
+    if (node.type !== 'navigation_expression')
+        return null;
+    const text = node.text.trim();
+    const separator = text.lastIndexOf('.');
+    if (separator <= 0 || separator === text.length - 1)
+        return null;
+    return {
+        receiverName: text.slice(0, separator),
+        methodName: text.slice(separator + 1),
+    };
+}
+function singleClassLiteralArgument(node) {
+    const suffix = node.namedChildren.find((child) => child.type === 'call_suffix');
+    const argumentsNode = suffix?.namedChildren.find((child) => child.type === 'value_arguments');
+    if (argumentsNode === undefined)
+        return null;
+    const argumentsWithoutComments = argumentsNode.namedChildren.filter((child) => child.type !== 'line_comment' && child.type !== 'multiline_comment');
+    if (argumentsWithoutComments.length !== 1)
+        return null;
+    const value = argumentsWithoutComments[0];
+    if (value?.type !== 'value_argument' || value.namedChildCount !== 1)
+        return null;
+    return value.namedChild(0)?.text.trim().match(KOTLIN_CLASS_LITERAL)?.[1] ?? null;
+}
+/** Capture real Kotlin calls using `Type::class` or `Type::class.java`. */
+export function captureKotlinSpringDynamicLookupFact(node, filePath) {
+    if (node.type !== 'call_expression')
+        return null;
+    const callee = node.namedChildren.find((child) => child.type === 'navigation_expression');
+    if (callee === undefined)
+        return null;
+    const parts = navigationParts(callee);
+    if (parts === null)
+        return null;
+    if (springDynamicLookupCardinality(parts.receiverName, parts.methodName) === null)
+        return null;
+    const targetTypeName = singleClassLiteralArgument(node);
+    if (targetTypeName === null)
+        return null;
+    const owner = findAncestorBeforeBoundary(node, CALLABLE_NODE_TYPES, NO_CALLABLE_BOUNDARIES);
+    if (owner === null)
+        return null;
+    const ownerCapture = nodeToCapture('@spring-dynamic-lookup.owner', owner);
+    return {
+        ownerScopeId: makeScopeId({
+            filePath,
+            range: ownerCapture.range,
+            kind: 'Function',
+        }),
+        ownerRange: ownerCapture.range,
+        receiverName: parts.receiverName,
+        methodName: parts.methodName,
+        targetTypeName,
+    };
+}
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export function captureKotlinSpringDynamicLookupFacts(rootNode, filePath) {
+    return rootNode
+        .descendantsOfType('call_expression')
+        .map((node) => captureKotlinSpringDynamicLookupFact(node, filePath))
+        .filter((fact) => fact !== null);
+}
+/** Attach Kotlin lookup facts for later resolution by the shared DI phase. */
+export const attachKotlinSpringDynamicLookup = createSpringDynamicLookupMetadataAttacher({
+    getFacts: getKotlinSpringDynamicLookupFacts,
+});

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

@@ -48,6 +48,9 @@ function providerCandidates(ids, providers) {
     // candidates when none are known instead of dropping the injection entirely.
     return recognized.length > 0 ? recognized : all;
 }
+function isConcreteTypeNode(node) {
+    return node?.label === 'Class' || node?.label === 'Record' || node?.label === 'Enum';
+}
 export const diPhase = {
     name: 'di',
     deps: ['mro'],
@@ -103,21 +106,25 @@ export const diPhase = {
                 ambiguousInjections: 0,
             };
         }
-        const interfaceToImplementers = new Map();
+        const directSubtypes = new Map();
         const directSupertypes = new Map();
         for (const rel of ctx.graph.iterRelationshipsByType('IMPLEMENTS')) {
-            const set = interfaceToImplementers.get(rel.targetId) ?? new Set();
-            set.add(rel.sourceId);
-            interfaceToImplementers.set(rel.targetId, set);
+            const subtypes = directSubtypes.get(rel.targetId) ?? new Set();
+            subtypes.add(rel.sourceId);
+            directSubtypes.set(rel.targetId, subtypes);
             const supertypes = directSupertypes.get(rel.sourceId) ?? new Set();
             supertypes.add(rel.targetId);
             directSupertypes.set(rel.sourceId, supertypes);
         }
         for (const rel of ctx.graph.iterRelationshipsByType('EXTENDS')) {
+            const subtypes = directSubtypes.get(rel.targetId) ?? new Set();
+            subtypes.add(rel.sourceId);
+            directSubtypes.set(rel.targetId, subtypes);
             const supertypes = directSupertypes.get(rel.sourceId) ?? new Set();
             supertypes.add(rel.targetId);
             directSupertypes.set(rel.sourceId, supertypes);
         }
+        const orderedDirectSubtypes = new Map([...directSubtypes].map(([typeId, subtypes]) => [typeId, [...subtypes].sort().reverse()]));
         const memberToClass = new Map();
         for (const relationType of ['HAS_PROPERTY', 'HAS_METHOD']) {
             for (const rel of ctx.graph.iterRelationshipsByType(relationType)) {
@@ -128,18 +135,45 @@ export const diPhase = {
         const interfacesByLanguage = new Map();
         const classesByLanguage = new Map();
         ctx.graph.forEachNode((node) => {
-            if (node.label !== 'Class' && node.label !== 'Interface')
+            const concreteType = isConcreteTypeNode(node);
+            if (!concreteType && node.label !== 'Interface')
                 return;
             const language = node.properties.language;
             if (typeof language !== 'string' || !candidateLanguages.has(language))
                 return;
-            const indexes = node.label === 'Class' ? classesByLanguage : interfacesByLanguage;
+            const indexes = concreteType ? classesByLanguage : interfacesByLanguage;
             const index = indexes.get(language) ?? emptyNameIndex();
             addIndexedName(index, node);
             indexes.set(language, index);
-            if (node.label === 'Class')
+            if (concreteType)
                 providerNodes.set(node.id, node);
         });
+        const concreteSubtypesByRoot = new Map();
+        const concreteSubtypes = (rootTypeId, language) => {
+            const cacheKey = `${language}\0${rootTypeId}`;
+            const cached = concreteSubtypesByRoot.get(cacheKey);
+            if (cached !== undefined)
+                return cached;
+            const concrete = new Set();
+            const queue = [rootTypeId];
+            const visited = new Set();
+            while (queue.length > 0) {
+                const typeId = queue.pop();
+                if (typeId === undefined || visited.has(typeId))
+                    continue;
+                visited.add(typeId);
+                const typeNode = ctx.graph.getNode(typeId);
+                if (typeNode !== undefined &&
+                    isConcreteTypeNode(typeNode) &&
+                    typeNode.properties.language === language) {
+                    concrete.add(typeId);
+                }
+                const children = orderedDirectSubtypes.get(typeId) ?? [];
+                queue.push(...children);
+            }
+            concreteSubtypesByRoot.set(cacheKey, concrete);
+            return concrete;
+        };
         // A declaration returning a concrete class is assignable to every class or
         // interface that type extends/implements. Expand once per language+type and
         // register the declaration under those ancestor names. This keeps named
@@ -227,13 +261,12 @@ export const diPhase = {
                 ambiguousTypeNames.add(candidate.targetTypeName);
                 continue;
             }
-            const structural = new Set();
-            if (typeof classEntry === 'string')
-                structural.add(classEntry);
-            if (typeof interfaceEntry === 'string') {
-                for (const id of interfaceToImplementers.get(interfaceEntry) ?? [])
-                    structural.add(id);
-            }
+            const rootTypeId = typeof classEntry === 'string'
+                ? classEntry
+                : typeof interfaceEntry === 'string'
+                    ? interfaceEntry
+                    : undefined;
+            const structural = new Set(rootTypeId === undefined ? [] : concreteSubtypes(rootTypeId, candidate.language));
             for (const id of providedTypes.get(candidate.language)?.get(candidate.targetTypeName) ?? []) {
                 structural.add(id);
             }

package/dist/storage/parse-cache.js

@@ -663,7 +663,11 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // each (no JSON/path/generation siblings). A v80 index still names `.json`
 // keys and would skip workers while scope-resolution found nothing — the
 // #1983 main-thread reparse. origin/main at allocation is 80.
-const SCHEMA_BUMP = 81;
+// 81 -> 82: Java and Kotlin ParsedFile capture side channels now carry
+// programmatic Spring lookup facts. A warm v81 cache has no such facts, so it
+// would skip workers and silently omit the new INJECTS edges. origin/main at
+// allocation is 81.
+const SCHEMA_BUMP = 82;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.11-rc.16",
+  "version": "1.6.11-rc.18",
   "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",
@@ -66,6 +66,7 @@
     "cors": "^2.8.5",
     "express": "^5.2.1",
     "express-rate-limit": "^8.4.1",
+    "fast-xml-parser": "^5.11.1",
     "glob": "^13.0.6",
     "graphology": "^0.26.0",
     "graphology-indices": "^0.17.0",