cgraphx 2.0.2 → 2.0.3

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

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPRING_CONFIG_DESCRIPTION = void 0;
+exports.bindSpringConfigConsumers = bindSpringConfigConsumers;
+const utils_js_1 = require("../../../../lib/utils.js");
+exports.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(exports.SPRING_CONFIG_DESCRIPTION));
+}
+/**
+ * Attach normalized, language-provider-produced Spring consumers to config
+ * keys already present in the shared graph.
+ */
+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 = (0, utils_js_1.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/code/engine/core/ingestion/frameworks/spring/di-metadata.js

@@ -0,0 +1,385 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.springAnnotationSimpleName = springAnnotationSimpleName;
+exports.hasSpringDiRelevantAnnotation = hasSpringDiRelevantAnnotation;
+exports.hasSpringStereotypeSyntax = hasSpringStereotypeSyntax;
+exports.createSpringDiMetadataAttacher = createSpringDiMetadataAttacher;
+const utils_js_1 = require("../../../../lib/utils.js");
+const spring_js_1 = require("../../di-extractors/spring.js");
+const ids_js_1 = require("../../scope-resolution/graph-bridge/ids.js");
+const bean_candidates_js_1 = require("./bean-candidates.js");
+const bean_catalog_js_1 = require("./bean-catalog.js");
+const bean_factories_js_1 = require("./bean-factories.js");
+const annotation_arguments_js_1 = require("./annotation-arguments.js");
+const resource_injection_js_1 = require("./resource-injection.js");
+const INJECTION_ANNOTATIONS = new Set([
+    'org.springframework.beans.factory.annotation.Autowired',
+    'jakarta.inject.Inject',
+    'javax.inject.Inject',
+]);
+const QUALIFIER_ANNOTATIONS = new Set([
+    'org.springframework.beans.factory.annotation.Qualifier',
+    'jakarta.inject.Named',
+    'javax.inject.Named',
+]);
+const PRIMARY_ANNOTATIONS = new Set(['org.springframework.context.annotation.Primary']);
+const RESOLVABLE_DI_ANNOTATIONS = new Set([
+    ...bean_catalog_js_1.SPRING_BEAN_STEREOTYPES.keys(),
+    ...INJECTION_ANNOTATIONS,
+    ...QUALIFIER_ANNOTATIONS,
+    ...PRIMARY_ANNOTATIONS,
+    ...resource_injection_js_1.SPRING_RESOURCE_ANNOTATIONS,
+    bean_factories_js_1.SPRING_BEAN_ANNOTATION,
+]);
+const CAPTURE_RELEVANT_ANNOTATIONS = new Set([
+    'Autowired',
+    'Inject',
+    'Qualifier',
+    'Named',
+    'Primary',
+    'Resource',
+    'Component',
+    'Service',
+    'Repository',
+    'Controller',
+    'RestController',
+    'Configuration',
+    'AutoConfiguration',
+]);
+const STEREOTYPE_SIMPLE_NAMES = new Set([...bean_catalog_js_1.SPRING_BEAN_STEREOTYPES.keys()].map((name) => springAnnotationSimpleName(name)));
+function springAnnotationSimpleName(name) {
+    const separator = name.lastIndexOf('.');
+    return separator === -1 ? name : name.slice(separator + 1);
+}
+function hasSpringDiRelevantAnnotation(annotations) {
+    return annotations.some((annotation) => CAPTURE_RELEVANT_ANNOTATIONS.has(springAnnotationSimpleName(annotation.name)));
+}
+function hasSpringStereotypeSyntax(annotations) {
+    return annotations.some((annotation) => STEREOTYPE_SIMPLE_NAMES.has(springAnnotationSimpleName(annotation.name)));
+}
+function staticStringArgument(annotationText) {
+    const argumentsList = (0, annotation_arguments_js_1.parseSpringAnnotationArguments)(annotationText);
+    if (argumentsList === null || argumentsList.length !== 1)
+        return undefined;
+    const argument = argumentsList[0];
+    if (argument.name !== undefined && argument.name !== 'value')
+        return undefined;
+    const values = (0, annotation_arguments_js_1.parseStaticStringValues)(argument.value);
+    return values !== null && values.length === 1 ? values[0] : undefined;
+}
+function defaultBeanName(className) {
+    if (className.length === 0)
+        return className;
+    if (className.length > 1 &&
+        className[0] !== className[0].toLowerCase() &&
+        className[1] !== className[1].toLowerCase()) {
+        return className;
+    }
+    return className[0].toLowerCase() + className.slice(1);
+}
+/**
+ * Build the post-resolution Spring DI metadata hook shared by language adapters.
+ * Language adapters retain syntax capture, type normalization, use-site rules,
+ * and side-channel ownership; this function owns framework semantics only.
+ */
+function createSpringDiMetadataAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        const resolveAnnotation = (0, bean_candidates_js_1.createSpringAnnotationNameResolver)(indexes);
+        for (const parsed of parsedFiles) {
+            const incomplete = adapter.isPackageVisibilityIncomplete(parsed.filePath);
+            for (const fact of adapter.getFacts(parsed.filePath)) {
+                const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+                if (classScope === undefined || classScope.kind !== 'Class')
+                    continue;
+                const classDef = classScope.ownedDefs.find((definition) => definition.type === 'Class');
+                if (classDef === undefined)
+                    continue;
+                const graphId = (0, ids_js_1.resolveDefGraphId)(parsed.filePath, classDef, nodeLookup);
+                if (graphId === undefined)
+                    continue;
+                const classNode = graph.getNode(graphId);
+                if (classNode === undefined || classNode.label !== 'Class')
+                    continue;
+                const resolvedAnnotations = new Map();
+                const resolveFact = (annotation, enclosingScope = classScope.parent) => {
+                    const cacheKey = `${enclosingScope ?? '<root>'}\0${annotation.name}`;
+                    if (resolvedAnnotations.has(cacheKey))
+                        return resolvedAnnotations.get(cacheKey);
+                    const resolved = resolveAnnotation(annotation.name, parsed, enclosingScope, RESOLVABLE_DI_ANNOTATIONS, incomplete);
+                    resolvedAnnotations.set(cacheKey, resolved);
+                    return resolved;
+                };
+                const frameworkAnnotations = Array.isArray(classNode.properties.frameworkAnnotations)
+                    ? classNode.properties.frameworkAnnotations.filter((annotation) => typeof annotation === 'string')
+                    : [];
+                if (frameworkAnnotations.length > 0) {
+                    const names = new Set();
+                    let explicitBeanName;
+                    let hasDynamicBeanName = false;
+                    let primary = false;
+                    for (const annotation of fact.classAnnotations) {
+                        const resolved = resolveFact(annotation);
+                        if (resolved === undefined)
+                            continue;
+                        if (bean_catalog_js_1.SPRING_BEAN_STEREOTYPES.has(resolved)) {
+                            const argumentText = annotation.text.match(/\((.*)\)$/s)?.[1]?.trim();
+                            if (argumentText !== undefined && argumentText.length > 0) {
+                                const staticName = staticStringArgument(annotation.text);
+                                if (staticName === undefined)
+                                    hasDynamicBeanName = true;
+                                else if (staticName.length > 0)
+                                    explicitBeanName = staticName;
+                            }
+                        }
+                        if (QUALIFIER_ANNOTATIONS.has(resolved)) {
+                            const qualifier = staticStringArgument(annotation.text);
+                            if (qualifier !== undefined)
+                                names.add(qualifier);
+                        }
+                        if (PRIMARY_ANNOTATIONS.has(resolved))
+                            primary = true;
+                    }
+                    if (explicitBeanName !== undefined)
+                        names.add(explicitBeanName);
+                    else if (!hasDynamicBeanName)
+                        names.add(defaultBeanName(classNode.properties.name));
+                    const provider = {
+                        names: [...names],
+                        ...(primary ? { preferenceReason: 'selected @Primary' } : {}),
+                    };
+                    classNode.properties[spring_js_1.SPRING_DI_PROVIDER_PROPERTY] = provider;
+                }
+                // Factory methods have no legacy member-collection fallback to suppress,
+                // so they do not participate in semanticallyOwnedMemberNames below.
+                for (const factory of fact.beanFactoryMethods ?? []) {
+                    const factoryScope = indexes.scopeTree.getScope(factory.callableScopeId);
+                    if (factoryScope === undefined)
+                        continue;
+                    const beanAnnotation = factory.annotations.find((annotation) => resolveFact(annotation, factoryScope.parent) === bean_factories_js_1.SPRING_BEAN_ANNOTATION);
+                    if (beanAnnotation === undefined)
+                        continue;
+                    const methodId = (0, ids_js_1.resolveCallerGraphId)(factory.callableScopeId, indexes, nodeLookup, {
+                        startLine: factoryScope.range.startLine,
+                        startCol: factoryScope.range.startCol,
+                    });
+                    if (methodId === undefined)
+                        continue;
+                    const methodNode = graph.getNode(methodId);
+                    if (methodNode === undefined || methodNode.label !== 'Method')
+                        continue;
+                    const names = (0, bean_factories_js_1.springBeanNames)(beanAnnotation.text, factory.methodName);
+                    const providedType = factory.returnType === undefined
+                        ? undefined
+                        : (0, annotation_arguments_js_1.normalizeSpringBeanType)(factory.returnType);
+                    const declaration = {
+                        names: names.names,
+                        namesKnown: names.namesKnown,
+                        ...(providedType === null || providedType === undefined ? {} : { providedType }),
+                    };
+                    const reason = (0, bean_factories_js_1.encodeSpringBeanFactoryReason)(declaration);
+                    const beanId = `${bean_factories_js_1.SPRING_BEAN_DECLARATION_ID_PREFIX}${methodNode.id}`;
+                    const beanNode = {
+                        id: beanId,
+                        label: 'CodeElement',
+                        properties: {
+                            name: names.names[0] ?? factory.methodName,
+                            filePath: methodNode.properties.filePath,
+                            startLine: methodNode.properties.startLine,
+                            endLine: methodNode.properties.endLine,
+                            language: methodNode.properties.language,
+                            description: `Spring @Bean factory declaration from ${factory.methodName}` +
+                                (providedType === null || providedType === undefined
+                                    ? ''
+                                    : ` providing ${providedType}`),
+                        },
+                    };
+                    beanNode.properties[spring_js_1.SPRING_DI_PROVIDER_PROPERTY] = {
+                        names: names.names,
+                        declaredByNodeId: methodNode.id,
+                        ...(providedType === null || providedType === undefined
+                            ? {}
+                            : { providedTypeName: providedType }),
+                    };
+                    graph.addNode(beanNode);
+                    const fileId = (0, utils_js_1.generateId)('File', parsed.filePath);
+                    if (graph.getNode(fileId) !== undefined) {
+                        graph.addRelationship({
+                            id: (0, utils_js_1.generateId)('DEFINES', `${fileId}->${beanId}`),
+                            sourceId: fileId,
+                            targetId: beanId,
+                            type: 'DEFINES',
+                            confidence: 1,
+                            reason: 'spring-bean:declaration',
+                        });
+                    }
+                    graph.addRelationship({
+                        id: (0, utils_js_1.generateId)('DECLARES', `${methodNode.id}->${beanId}`),
+                        sourceId: methodNode.id,
+                        targetId: beanId,
+                        type: 'DECLARES',
+                        confidence: names.namesKnown ? 1 : 0.8,
+                        reason,
+                    });
+                    const factoryMatches = [];
+                    for (const dependency of factory.dependencies) {
+                        const parsedType = adapter.parseInjectionType(dependency.rawType);
+                        if (parsedType === null)
+                            continue;
+                        let qualifierAnnotation;
+                        for (const annotation of dependency.annotations) {
+                            if (adapter.isFactoryQualifierAnnotationApplicable?.(annotation) === false)
+                                continue;
+                            const resolved = resolveFact(annotation, factoryScope.id);
+                            if (resolved !== undefined && QUALIFIER_ANNOTATIONS.has(resolved)) {
+                                qualifierAnnotation = annotation;
+                                break;
+                            }
+                        }
+                        const qualifier = qualifierAnnotation === undefined
+                            ? undefined
+                            : staticStringArgument(qualifierAnnotation.text);
+                        if (qualifierAnnotation !== undefined && qualifier === undefined)
+                            continue;
+                        factoryMatches.push({
+                            targetTypeName: parsedType.targetTypeName,
+                            cardinality: parsedType.cardinality,
+                            edgeSource: 'site',
+                            ...(qualifier === undefined
+                                ? {}
+                                : {
+                                    namedSelection: {
+                                        name: qualifier,
+                                        reason: `qualifier "${qualifier}"`,
+                                    },
+                                }),
+                            reason: `Spring DI: @Bean method ${factory.methodName} parameter ${dependency.name}: ` +
+                                parsedType.displayType,
+                        });
+                    }
+                    if (factoryMatches.length > 0) {
+                        const existing = methodNode.properties[spring_js_1.SPRING_DI_INJECTION_SITES_PROPERTY];
+                        methodNode.properties[spring_js_1.SPRING_DI_INJECTION_SITES_PROPERTY] = [
+                            ...(Array.isArray(existing) ? existing : []),
+                            ...factoryMatches,
+                        ];
+                    }
+                }
+                const matches = [];
+                const semanticallyOwnedMemberNames = new Set();
+                for (const site of fact.injectionSites) {
+                    let injectionAnnotation;
+                    let resourceAnnotation;
+                    for (const annotation of site.annotations) {
+                        if (adapter.isInjectionAnnotationApplicable?.(annotation, site) === false)
+                            continue;
+                        const resolved = resolveFact(annotation, classScope.id);
+                        if (resolved !== undefined && INJECTION_ANNOTATIONS.has(resolved)) {
+                            injectionAnnotation = annotation;
+                        }
+                        else if (resolved !== undefined && resource_injection_js_1.SPRING_RESOURCE_ANNOTATIONS.has(resolved)) {
+                            resourceAnnotation = annotation;
+                        }
+                    }
+                    if (injectionAnnotation !== undefined && resourceAnnotation !== undefined) {
+                        // The annotation pair is semantically ambiguous, so emit no edge.
+                        // It still owns a captured member: otherwise the legacy collection
+                        // matcher sees the same Property and fans out behind this fail-closed
+                        // decision.
+                        if (site.kind === adapter.capturedMemberKind) {
+                            semanticallyOwnedMemberNames.add(site.memberName);
+                        }
+                        continue;
+                    }
+                    if (resourceAnnotation !== undefined) {
+                        if (site.kind === adapter.capturedMemberKind) {
+                            semanticallyOwnedMemberNames.add(site.memberName);
+                        }
+                        if (site.dependencies.length !== 1 || site.kind === 'constructor')
+                            continue;
+                        const defaultName = (0, resource_injection_js_1.springResourceDefaultName)(site.kind, site.memberName, site.dependencies.length);
+                        if (defaultName === null)
+                            continue;
+                        const dependency = site.dependencies[0];
+                        const location = site.kind === adapter.capturedMemberKind
+                            ? site.memberName
+                            : `${site.memberName} parameter ${dependency.name}`;
+                        const resourceMatch = (0, resource_injection_js_1.springResourceInjectionMatch)(resourceAnnotation.text, defaultName, dependency.rawType, location);
+                        if (resourceMatch !== null)
+                            matches.push(resourceMatch);
+                        continue;
+                    }
+                    if (injectionAnnotation === undefined) {
+                        if (!site.implicitConstructor || frameworkAnnotations.length === 0)
+                            continue;
+                    }
+                    else if (site.kind === adapter.capturedMemberKind) {
+                        // Claim the member only after its injection annotation resolves to
+                        // a recognized FQN. Ambiguous wildcard imports stay unclaimed so
+                        // the legacy collection matcher can fall back. A dynamic qualifier
+                        // later fails closed, but this path still owns the member and must
+                        // suppress that legacy fallback.
+                        semanticallyOwnedMemberNames.add(site.memberName);
+                    }
+                    for (const dependency of site.dependencies) {
+                        const parsedType = adapter.parseInjectionType(dependency.rawType);
+                        if (parsedType === null)
+                            continue;
+                        let qualifierAnnotation;
+                        for (const annotation of dependency.annotations) {
+                            if (adapter.isQualifierAnnotationApplicable?.(annotation, site) === false)
+                                continue;
+                            const resolved = resolveFact(annotation, classScope.id);
+                            if (resolved !== undefined && QUALIFIER_ANNOTATIONS.has(resolved)) {
+                                qualifierAnnotation = annotation;
+                                break;
+                            }
+                        }
+                        const qualifier = qualifierAnnotation === undefined
+                            ? undefined
+                            : staticStringArgument(qualifierAnnotation.text);
+                        // A present-but-dynamic qualifier is not the same as no qualifier.
+                        // Without its value we cannot choose a provider honestly, so fail
+                        // closed instead of emitting the unqualified candidate set.
+                        if (qualifierAnnotation !== undefined && qualifier === undefined)
+                            continue;
+                        const trigger = injectionAnnotation === undefined
+                            ? 'constructor'
+                            : `@${springAnnotationSimpleName(injectionAnnotation.name)} ${site.kind}`;
+                        const location = site.kind === adapter.capturedMemberKind
+                            ? site.memberName
+                            : `${site.memberName} parameter ${dependency.name}`;
+                        matches.push({
+                            targetTypeName: parsedType.targetTypeName,
+                            cardinality: parsedType.cardinality,
+                            ...(qualifier === undefined
+                                ? {}
+                                : {
+                                    namedSelection: {
+                                        name: qualifier,
+                                        reason: `qualifier "${qualifier}"`,
+                                    },
+                                }),
+                            reason: `Spring DI: ${trigger} ${location}: ${parsedType.displayType}`,
+                        });
+                    }
+                }
+                if (matches.length > 0) {
+                    classNode.properties[spring_js_1.SPRING_DI_INJECTION_SITES_PROPERTY] = matches;
+                }
+                for (const memberName of semanticallyOwnedMemberNames) {
+                    for (const { def } of classScope.bindings.get(memberName) ?? []) {
+                        if (def.ownerId !== classDef.nodeId)
+                            continue;
+                        const propertyId = (0, ids_js_1.resolveDefGraphId)(parsed.filePath, def, nodeLookup);
+                        if (propertyId === undefined)
+                            continue;
+                        const property = graph.getNode(propertyId);
+                        if (property?.label === 'Property') {
+                            property.properties[spring_js_1.SPRING_DI_CAPTURED_FIELD_PROPERTY] = true;
+                        }
+                    }
+                }
+            }
+        }
+    };
+}

package/dist/core/code/engine/core/ingestion/frameworks/spring/resource-injection.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPRING_RESOURCE_ANNOTATIONS = void 0;
+exports.springResourceDefaultName = springResourceDefaultName;
+exports.springResourceInjectionMatch = springResourceInjectionMatch;
+const annotation_arguments_js_1 = require("./annotation-arguments.js");
+exports.SPRING_RESOURCE_ANNOTATIONS = new Set([
+    'jakarta.annotation.Resource',
+    'javax.annotation.Resource',
+]);
+function singleNamedArgument(annotationText, name) {
+    const argumentsList = (0, annotation_arguments_js_1.parseSpringAnnotationArguments)(annotationText);
+    if (argumentsList === null || argumentsList.some((argument) => argument.name === undefined)) {
+        return null;
+    }
+    const matches = argumentsList.filter((argument) => argument.name === name);
+    if (matches.length > 1)
+        return null;
+    return matches.length === 0 ? { present: false } : { present: true, value: matches[0].value };
+}
+function staticSingleString(value) {
+    if (value === undefined)
+        return null;
+    const values = (0, annotation_arguments_js_1.parseStaticStringValues)(value);
+    return values !== null && values.length === 1 ? values[0] : null;
+}
+function javaBeansDecapitalize(value) {
+    if (value.length === 0)
+        return value;
+    if (value.length > 1 &&
+        value[0] !== value[0].toLowerCase() &&
+        value[1] !== value[1].toLowerCase()) {
+        return value;
+    }
+    return value[0].toLowerCase() + value.slice(1);
+}
+function springResourceDefaultName(siteKind, memberName, dependencyCount) {
+    if (siteKind !== 'method')
+        return memberName;
+    if (dependencyCount !== 1 || !/^set[A-Z_$]/.test(memberName) || memberName.length <= 3) {
+        return null;
+    }
+    return javaBeansDecapitalize(memberName.slice(3));
+}
+/** Build the conservative name-first Resource match shared by Java and Kotlin. */
+function springResourceInjectionMatch(annotationText, defaultName, rawDeclaredType, location) {
+    const nameArgument = singleNamedArgument(annotationText, 'name');
+    const typeArgument = singleNamedArgument(annotationText, 'type');
+    const lookupArgument = singleNamedArgument(annotationText, 'lookup');
+    const mappedNameArgument = singleNamedArgument(annotationText, 'mappedName');
+    if (nameArgument === null ||
+        typeArgument === null ||
+        lookupArgument === null ||
+        mappedNameArgument === null) {
+        return null;
+    }
+    for (const runtimeArgument of [lookupArgument, mappedNameArgument]) {
+        if (!runtimeArgument.present)
+            continue;
+        const value = staticSingleString(runtimeArgument.value);
+        if (value === null || value.length > 0)
+            return null;
+    }
+    const declaredType = (0, annotation_arguments_js_1.normalizeSpringBeanType)(rawDeclaredType);
+    if (declaredType === null)
+        return null;
+    let targetTypeName = declaredType;
+    if (typeArgument.present) {
+        const override = (0, annotation_arguments_js_1.parseStaticClassLiteral)(typeArgument.value ?? '');
+        if (override === null)
+            return null;
+        if (override.length > 0)
+            targetTypeName = override;
+    }
+    let selectedName = defaultName;
+    let explicitName = false;
+    if (nameArgument.present) {
+        const parsedName = staticSingleString(nameArgument.value);
+        if (parsedName === null)
+            return null;
+        if (parsedName.length > 0) {
+            selectedName = parsedName;
+            explicitName = true;
+        }
+    }
+    return {
+        targetTypeName,
+        cardinality: 'single',
+        namedSelection: {
+            name: selectedName,
+            reason: `${explicitName ? 'resource name' : 'default resource name'} "${selectedName}"`,
+            ...(!explicitName && !rawDeclaredType.includes('<') ? { fallbackToType: true } : {}),
+        },
+        reason: `Spring DI: @Resource ${location}: ${targetTypeName}`,
+    };
+}

package/dist/core/code/engine/core/ingestion/import-resolvers/configs/c-cpp.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * C / C++ import resolution configs.
+ * Both use standard resolution for #include directives.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cppImportConfig = exports.cImportConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const standard_js_1 = require("../standard.js");
+exports.cImportConfig = {
+    language: index_js_1.SupportedLanguages.C,
+    strategies: [(0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.C)],
+};
+exports.cppImportConfig = {
+    language: index_js_1.SupportedLanguages.CPlusPlus,
+    strategies: [(0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.CPlusPlus)],
+};

package/dist/core/code/engine/core/ingestion/import-resolvers/configs/csharp.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * C# import resolution config.
+ * Namespace-based strategy via .csproj configs, then standard fallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpImportConfig = exports.csharpNamespaceStrategy = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const standard_js_1 = require("../standard.js");
+const csharp_js_1 = require("../csharp.js");
+const csharp_namespace_gate_js_1 = require("../../csharp-namespace-gate.js");
+/** C# namespace-based resolution strategy via .csproj configs. */
+const csharpNamespaceStrategy = (rawImportPath, _filePath, ctx) => {
+    const csharpConfigs = ctx.configs.csharpConfigs;
+    const evidence = ctx.configs.csharpNamespaces;
+    if (csharpConfigs.length === 0) {
+        // No csproj → there's no namespace→directory mapping to apply, so the
+        // generic strategy would normally take over. But that generic suffix match
+        // is UNGATED: it re-introduces the BCL→local spurious match the #1881 gate
+        // exists to stop. Mirror the registry leg's no-csproj path — defer to the
+        // generic strategy ONLY for imports that align with an in-repo declared
+        // namespace; for everything else (BCL usings) return an authoritative empty
+        // result that STOPS the chain (#2 parity). With no evidence threaded the
+        // gate fails open, so behavior is unchanged when the scan didn't run.
+        if (!(0, csharp_namespace_gate_js_1.csharpSuffixFallbackAllowed)(rawImportPath, evidence)) {
+            return { kind: 'files', files: [] };
+        }
+        return null;
+    }
+    const resolvedFiles = (0, csharp_js_1.resolveCSharpImportInternal)(rawImportPath, csharpConfigs, ctx.normalizedFileList, ctx.allFileList, ctx.index, evidence);
+    if (resolvedFiles.length > 1) {
+        const dirSuffix = (0, csharp_js_1.resolveCSharpNamespaceDir)(rawImportPath, csharpConfigs);
+        if (dirSuffix) {
+            return { kind: 'package', files: resolvedFiles, dirSuffix };
+        }
+    }
+    // Authoritative once csproj configs exist: return even an empty result to
+    // STOP the chain, so the generic suffix fallback can't re-introduce the
+    // gated BCL→local match this resolver just suppressed (#1881).
+    return { kind: 'files', files: resolvedFiles };
+};
+exports.csharpNamespaceStrategy = csharpNamespaceStrategy;
+exports.csharpImportConfig = {
+    language: index_js_1.SupportedLanguages.CSharp,
+    strategies: [exports.csharpNamespaceStrategy, (0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.CSharp)],
+};