gitnexus 1.6.9-rc.42 → 1.6.9-rc.44

package/dist/_shared/graph/types.d.ts

@@ -32,6 +32,9 @@ export type NodeProperties = {
     level?: number;
     returnType?: string;
     declaredType?: string;
+    /** Verbatim declared-type source text with generics preserved
+     *  (e.g. `List<Shape>` where `declaredType` is the stripped `List`). */
+    rawDeclaredType?: string;
     visibility?: string;
     isStatic?: boolean;
     isReadonly?: boolean;
@@ -52,6 +55,19 @@ export type NodeProperties = {
     [key: string]: unknown;
 };
 export type RelationshipType = 'CONTAINS' | 'CALLS' | 'INHERITS' | 'METHOD_OVERRIDES' | 'METHOD_IMPLEMENTS' | 'IMPORTS' | 'USES' | 'DEFINES' | 'DECORATES' | 'IMPLEMENTS' | 'EXTENDS' | 'HAS_METHOD' | 'HAS_PROPERTY' | 'ACCESSES' | 'MEMBER_OF' | 'STEP_IN_PROCESS' | 'HANDLES_ROUTE' | 'FETCHES' | 'HANDLES_TOOL' | 'ENTRY_POINT_OF' | 'WRAPS' | 'QUERIES'
+/** Dependency-injection edge: a consumer class receives every implementer
+ *  of interface `T` via a container-injected collection-typed field
+ *  (`List<T>`, `Set<T>`, `Collection<T>`, or `Map<K,T>`). Precondition: the
+ *  field carries an injection annotation recognized by a per-language
+ *  matcher registered in `di-extractors/` (Java/Spring today: `@Autowired`
+ *  or `@Inject`; `@Resource` is excluded — by-name-first semantics).
+ *  Source = the consumer Class node (the one owning the field).
+ *  Target = an implementing Class node.
+ *  Framework specifics live in the `reason` payload (e.g.
+ *  `Spring DI: @Autowired List<T>`), not in this type contract.
+ *  Lets Cypher queries trace which beans the container injects into a given
+ *  consumer, complementing the structural `IMPLEMENTS` heritage edges. */
+ | 'INJECTS'
 /** Vue component event system: a handler function in a parent component is
  *  bound to an event emitted by a child component (`@event="handlerFn"`).
  *  Source = handler Function/Method node in the parent.

package/dist/_shared/graph/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/graph/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/graph/types.ts"],"names":[],"mappings":"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"}

package/dist/_shared/lbug/schema-constants.d.ts

@@ -10,7 +10,7 @@
 export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Section", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Variable", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module", "Route", "Tool", "BasicBlock"];
 export type NodeTableName = (typeof NODE_TABLES)[number];
 export declare const REL_TABLE_NAME = "CodeRelation";
-export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "HAS_METHOD", "HAS_PROPERTY", "ACCESSES", "METHOD_OVERRIDES", "OVERRIDES", "METHOD_IMPLEMENTS", "MEMBER_OF", "STEP_IN_PROCESS", "HANDLES_ROUTE", "FETCHES", "HANDLES_TOOL", "ENTRY_POINT_OF", "WRAPS", "QUERIES", "CFG", "REACHING_DEF", "TAINTED", "SANITIZES", "TAINT_PATH", "CDG", "POST_DOMINATE"];
+export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "HAS_METHOD", "HAS_PROPERTY", "ACCESSES", "METHOD_OVERRIDES", "OVERRIDES", "METHOD_IMPLEMENTS", "MEMBER_OF", "STEP_IN_PROCESS", "HANDLES_ROUTE", "FETCHES", "HANDLES_TOOL", "ENTRY_POINT_OF", "WRAPS", "QUERIES", "INJECTS", "CFG", "REACHING_DEF", "TAINTED", "SANITIZES", "TAINT_PATH", "CDG", "POST_DOMINATE"];
 export type RelType = (typeof REL_TYPES)[number];
 export declare const EMBEDDING_TABLE_NAME = "CodeEmbedding";
 //# sourceMappingURL=schema-constants.d.ts.map

package/dist/_shared/lbug/schema-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-constants.d.ts","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,wWAkCd,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,SAAS,sXAmCZ,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}
+{"version":3,"file":"schema-constants.d.ts","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,wWAkCd,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,SAAS,iYAoCZ,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}

package/dist/_shared/lbug/schema-constants.js

@@ -64,6 +64,7 @@ export const REL_TYPES = [
     'ENTRY_POINT_OF',
     'WRAPS',
     'QUERIES',
+    'INJECTS',
     // Taint/PDG substrate (issue #2080) — reserved edge types, emitted by no
     // phase yet (CFG → M1, REACHING_DEF → M2, TAINTED/SANITIZES/TAINT_PATH →
     // M3/M4). REACHING_DEF's variable name rides the relation's `reason` column.

package/dist/_shared/lbug/schema-constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema-constants.js","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,WAAW;IACX,QAAQ;IACR,aAAa;IACb,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,MAAM;IACN,OAAO;IACP,SAAS;IACT,OAAO;IACP,WAAW;IACX,OAAO;IACP,MAAM;IACN,WAAW;IACX,OAAO;IACP,QAAQ;IACR,UAAU;IACV,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,aAAa;IACb,UAAU;IACV,QAAQ;IACR,OAAO;IACP,MAAM;IACN,2EAA2E;IAC3E,YAAY;CACJ,CAAC;AAIX,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,SAAS;IACT,OAAO;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,UAAU;IACV,kBAAkB;IAClB,WAAW,EAAE,mEAAmE;IAChF,mBAAmB;IACnB,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,SAAS;IACT,cAAc;IACd,gBAAgB;IAChB,OAAO;IACP,SAAS;IACT,yEAAyE;IACzE,yEAAyE;IACzE,6EAA6E;IAC7E,KAAK;IACL,cAAc;IACd,SAAS;IACT,WAAW;IACX,YAAY;IACZ,4EAA4E;IAC5E,uEAAuE;IACvE,4EAA4E;IAC5E,8EAA8E;IAC9E,KAAK;IACL,eAAe;CACP,CAAC;AAIX,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}
+{"version":3,"file":"schema-constants.js","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,WAAW;IACX,QAAQ;IACR,aAAa;IACb,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,MAAM;IACN,OAAO;IACP,SAAS;IACT,OAAO;IACP,WAAW;IACX,OAAO;IACP,MAAM;IACN,WAAW;IACX,OAAO;IACP,QAAQ;IACR,UAAU;IACV,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,aAAa;IACb,UAAU;IACV,QAAQ;IACR,OAAO;IACP,MAAM;IACN,2EAA2E;IAC3E,YAAY;CACJ,CAAC;AAIX,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,SAAS;IACT,OAAO;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,UAAU;IACV,kBAAkB;IAClB,WAAW,EAAE,mEAAmE;IAChF,mBAAmB;IACnB,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,SAAS;IACT,cAAc;IACd,gBAAgB;IAChB,OAAO;IACP,SAAS;IACT,SAAS;IACT,yEAAyE;IACzE,yEAAyE;IACzE,6EAA6E;IAC7E,KAAK;IACL,cAAc;IACd,SAAS;IACT,WAAW;IACX,YAAY;IACZ,4EAA4E;IAC5E,uEAAuE;IACvE,4EAA4E;IAC5E,8EAA8E;IAC9E,KAAK;IACL,eAAe;CACP,CAAC;AAIX,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}

package/dist/core/incremental/subgraph-extract.js

@@ -63,7 +63,20 @@ const isGraphWide = (label) => label === 'Community' || label === 'Process';
 // re-included from the FULL fresh graph (which the emit phase recomputes every
 // run) or an unchanged function's summary would be lost. Cheap: one self-loop
 // edge per return-flowing function.
-const isGraphWideRelType = (type) => type === 'TAINT_PATH' || type === 'CALL_SUMMARY';
+//
+// `INJECTS` (DI collection injection, #2200) is the same class as TAINT_PATH
+// (the #2084 M4 U6 pattern above): its validity is a whole-program property —
+// a change to a THIRD file (the interface itself, or a new/removed
+// implementer) creates or invalidates edges between two files that were never
+// touched, so the endpoint-writability rule would strand a stale
+// consumer→implementer edge (or miss a new one). Always re-extracted from the
+// fresh graph; the orchestrator unconditionally delete-alls the old rows
+// first (`deleteAllInjects`). Crash-recovery: delete-then-COPY is not atomic
+// by design — a crash between them loses INJECTS edges until the next
+// analyze, and the `incrementalInProgress` dirty flag (saved before any
+// delete) forces a full rebuild on the next run. Temporary absence is
+// possible; duplicates are not.
+const isGraphWideRelType = (type) => type === 'TAINT_PATH' || type === 'CALL_SUMMARY' || type === 'INJECTS';
 /**
  * Build a Map<nodeId, filePath> for every File-bound node in the graph.
  * Graph-wide nodes (Community/Process) have no filePath and are filtered.

package/dist/core/ingestion/di-extractors/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Per-language DI field-matcher registry — the lookup the generic `di`
+ * pipeline phase uses to decide whether a `Property` node is a
+ * dependency-injection fan-out candidate.
+ *
+ * Mirrors `scope-resolution/pipeline/registry.ts` (`SCOPE_RESOLVERS`): a
+ * single-valued `ReadonlyMap<SupportedLanguages, DiFieldMatcher>` consumed by
+ * a framework-neutral phase, so no language or framework names leak into
+ * shared pipeline code. Adding a framework is two lines: implement a
+ * `DiFieldMatcher` in `di-extractors/<framework>.ts` and register it here.
+ *
+ * Scope honesty: matchers are per-language *field-injection* matchers.
+ * Constructor injection (the dominant modern Spring idiom) lives on
+ * Method/parameter nodes and would require widening the phase's routing —
+ * deliberately out of scope (see the plan's Deferred work). The registry is
+ * single-valued per language, matching the `SCOPE_RESOLVERS` shape; widen the
+ * value type to arrays only when a second same-language framework actually
+ * lands (a one-line type change then).
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import type { GraphNode } from '../../../_shared/index.js';
+/** A successful DI field match, produced by a per-language matcher. */
+export interface DiFieldMatch {
+    /** The element type name `T` — the injected bean interface. */
+    elementTypeName: string;
+    /** Human-readable edge reason. Framework specifics (names, idioms,
+     *  collection wrapper, gating annotation) live in this payload so the
+     *  shared `di` phase stays framework-neutral. */
+    reason: string;
+}
+/**
+ * A per-language field-injection matcher: given a `Property` node, return the
+ * parsed DI match or `null` when the field is not container-injected. The
+ * matcher receives the whole node (not pre-plucked fields) so the shared
+ * phase stays ignorant of which properties matter.
+ */
+export type DiFieldMatcher = (node: GraphNode) => DiFieldMatch | null;
+/**
+ * Type guard narrowing an arbitrary graph `language` string to
+ * `SupportedLanguages`, so `DI_MATCHERS.get()` needs no cast.
+ */
+export declare function isSupportedLanguage(value: string): value is SupportedLanguages;
+/** Map of `SupportedLanguages` → `DiFieldMatcher`. The `di` phase routes each
+ *  `Property` node here by `node.properties.language`; no entry ⇒ the node is
+ *  skipped. This is the single source of truth for which languages (and,
+ *  transitively, frameworks) produce INJECTS edges. */
+export declare const DI_MATCHERS: ReadonlyMap<SupportedLanguages, DiFieldMatcher>;

package/dist/core/ingestion/di-extractors/index.js

@@ -0,0 +1,35 @@
+/**
+ * Per-language DI field-matcher registry — the lookup the generic `di`
+ * pipeline phase uses to decide whether a `Property` node is a
+ * dependency-injection fan-out candidate.
+ *
+ * Mirrors `scope-resolution/pipeline/registry.ts` (`SCOPE_RESOLVERS`): a
+ * single-valued `ReadonlyMap<SupportedLanguages, DiFieldMatcher>` consumed by
+ * a framework-neutral phase, so no language or framework names leak into
+ * shared pipeline code. Adding a framework is two lines: implement a
+ * `DiFieldMatcher` in `di-extractors/<framework>.ts` and register it here.
+ *
+ * Scope honesty: matchers are per-language *field-injection* matchers.
+ * Constructor injection (the dominant modern Spring idiom) lives on
+ * Method/parameter nodes and would require widening the phase's routing —
+ * deliberately out of scope (see the plan's Deferred work). The registry is
+ * single-valued per language, matching the `SCOPE_RESOLVERS` shape; widen the
+ * value type to arrays only when a second same-language framework actually
+ * lands (a one-line type change then).
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { springDiFieldMatcher } from './spring.js';
+/** All `SupportedLanguages` string values, for narrowing raw graph strings. */
+const SUPPORTED_LANGUAGE_VALUES = new Set(Object.values(SupportedLanguages));
+/**
+ * Type guard narrowing an arbitrary graph `language` string to
+ * `SupportedLanguages`, so `DI_MATCHERS.get()` needs no cast.
+ */
+export function isSupportedLanguage(value) {
+    return SUPPORTED_LANGUAGE_VALUES.has(value);
+}
+/** Map of `SupportedLanguages` → `DiFieldMatcher`. The `di` phase routes each
+ *  `Property` node here by `node.properties.language`; no entry ⇒ the node is
+ *  skipped. This is the single source of truth for which languages (and,
+ *  transitively, frameworks) produce INJECTS edges. */
+export const DI_MATCHERS = new Map([[SupportedLanguages.Java, springDiFieldMatcher]]);

package/dist/core/ingestion/di-extractors/spring.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Spring dependency-injection field matcher for the generic `di` phase.
+ *
+ * Recognizes the fields Spring's container fills via collect-all-implementers
+ * collection injection: when a Java class declares a field carrying an
+ * injection annotation (`@Autowired` or `@Inject`) typed as `List<T>`,
+ * `Set<T>`, `Collection<T>`, or `Map<K,T>`, the container injects EVERY bean
+ * implementing interface `T`. The matcher reports the element type name `T`
+ * plus a human-readable reason naming the collection wrapper and the
+ * annotation that gated the match; the shared `di` phase turns that into
+ * `INJECTS` edges.
+ *
+ * The injection annotation is a hard precondition: a plain (non-annotated)
+ * collection field is never injected by the container and produces no match.
+ * `@Resource` (JSR-250) is DELIBERATELY excluded: it resolves by bean NAME
+ * first (defaulting to the field name), which injects a single named
+ * collection bean — the opposite of the collect-all-implementers fan-out
+ * INJECTS models. Including it would emit false edges.
+ *
+ * Matching happens on `rawDeclaredType` (the verbatim type text, generics
+ * preserved) — NOT `declaredType`, which is generics-stripped by design
+ * (`List<Shape>` → `List`) and can never match the collection patterns.
+ *
+ * Accepted type shapes (after whitespace normalization — internal runs of
+ * whitespace, including newlines from multi-line declarations, collapse to a
+ * single space):
+ * - `List<T>` / `Set<T>` / `Collection<T>` — element `T`.
+ * - `Map<K, T>` — element is the VALUE type `T`; the key `K` is irrelevant
+ *   for DI resolution and may itself be generic (`Map<Pair<A,B>, T>` — the
+ *   top-level-comma split is bracket-depth-aware, so nested commas in the
+ *   key never bleed into the element).
+ * - Bounded wildcards `List<? extends T>` / `List<? super T>` — element `T`
+ *   (both are idiomatic Spring collection injection; the container still
+ *   collects every implementer of `T`).
+ * - Package-qualified wrappers `java.util.List<T>` — the wrapper is
+ *   recognized by its LAST dotted segment. The ELEMENT keeps its dots
+ *   (`List<com.a.Shape>` → `com.a.Shape`): dotted element names resolve via
+ *   `qualifiedName` downstream in the `di` phase.
+ *
+ * Documented REJECTIONS (parse returns `null` — no INJECTS edges):
+ * - `Map<String, List<IFoo>>` — the element itself is generic; a nested
+ *   generic is not resolvable as a single interface.
+ * - `List<?>` — unbounded wildcard; there is no element type to fan out to.
+ * - Arrays: `IFoo[]`, `List<IFoo>[]`, `List<IFoo[]>` — array injection is
+ *   not the collect-all-implementers shape INJECTS models.
+ * - Non-collection types (`IFoo`, `Optional<IFoo>`, …) and wrong generic
+ *   arity (`Map<String>`, `List<A, B>`).
+ * - Anything whose element is not a plain (possibly dotted) Java type name —
+ *   this makes the parser fail closed on unanticipated syntax. In particular
+ *   Java block comments inside the generic arguments (a `/* ... ` comment
+ *   between `<` and the element) are NOT stripped and fail closed —
+ *   acceptable.
+ *
+ * Registered under `SupportedLanguages.Java` in `./index.ts` (`DI_MATCHERS`);
+ * language routing is the registry's job, so the matcher itself never reads
+ * `node.properties.language`.
+ */
+import type { DiFieldMatcher } from './index.js';
+/**
+ * Parse a Spring DI collection field's raw declared type (verbatim source
+ * text, generics preserved) and return the injected bean type name.
+ *
+ * Whitespace-normalizes first (raw tree-sitter `.text` can span lines), then
+ * recognizes the wrapper by the LAST dotted segment before the first `<`
+ * (so `java.util.List<IFoo>` works), depth-aware-splits the generic argument
+ * list, and validates the element position. See the module docstring for the
+ * full accepted/rejected shape inventory.
+ *
+ * @returns the collection wrapper name + element type name, or `null` when
+ *          the raw declared type is not a recognized Spring collection shape.
+ */
+export declare function parseSpringCollectionType(rawDeclaredType: string): {
+    collectionType: string;
+    elementTypeName: string;
+} | null;
+/**
+ * Match a `Property` node against Spring's collection-injection shape.
+ *
+ * Returns the parsed match (with a Spring-specific human-readable `reason`
+ * payload) or `null` when the field is not container-injected.
+ */
+export declare const springDiFieldMatcher: DiFieldMatcher;

package/dist/core/ingestion/di-extractors/spring.js

@@ -0,0 +1,220 @@
+/**
+ * Spring dependency-injection field matcher for the generic `di` phase.
+ *
+ * Recognizes the fields Spring's container fills via collect-all-implementers
+ * collection injection: when a Java class declares a field carrying an
+ * injection annotation (`@Autowired` or `@Inject`) typed as `List<T>`,
+ * `Set<T>`, `Collection<T>`, or `Map<K,T>`, the container injects EVERY bean
+ * implementing interface `T`. The matcher reports the element type name `T`
+ * plus a human-readable reason naming the collection wrapper and the
+ * annotation that gated the match; the shared `di` phase turns that into
+ * `INJECTS` edges.
+ *
+ * The injection annotation is a hard precondition: a plain (non-annotated)
+ * collection field is never injected by the container and produces no match.
+ * `@Resource` (JSR-250) is DELIBERATELY excluded: it resolves by bean NAME
+ * first (defaulting to the field name), which injects a single named
+ * collection bean — the opposite of the collect-all-implementers fan-out
+ * INJECTS models. Including it would emit false edges.
+ *
+ * Matching happens on `rawDeclaredType` (the verbatim type text, generics
+ * preserved) — NOT `declaredType`, which is generics-stripped by design
+ * (`List<Shape>` → `List`) and can never match the collection patterns.
+ *
+ * Accepted type shapes (after whitespace normalization — internal runs of
+ * whitespace, including newlines from multi-line declarations, collapse to a
+ * single space):
+ * - `List<T>` / `Set<T>` / `Collection<T>` — element `T`.
+ * - `Map<K, T>` — element is the VALUE type `T`; the key `K` is irrelevant
+ *   for DI resolution and may itself be generic (`Map<Pair<A,B>, T>` — the
+ *   top-level-comma split is bracket-depth-aware, so nested commas in the
+ *   key never bleed into the element).
+ * - Bounded wildcards `List<? extends T>` / `List<? super T>` — element `T`
+ *   (both are idiomatic Spring collection injection; the container still
+ *   collects every implementer of `T`).
+ * - Package-qualified wrappers `java.util.List<T>` — the wrapper is
+ *   recognized by its LAST dotted segment. The ELEMENT keeps its dots
+ *   (`List<com.a.Shape>` → `com.a.Shape`): dotted element names resolve via
+ *   `qualifiedName` downstream in the `di` phase.
+ *
+ * Documented REJECTIONS (parse returns `null` — no INJECTS edges):
+ * - `Map<String, List<IFoo>>` — the element itself is generic; a nested
+ *   generic is not resolvable as a single interface.
+ * - `List<?>` — unbounded wildcard; there is no element type to fan out to.
+ * - Arrays: `IFoo[]`, `List<IFoo>[]`, `List<IFoo[]>` — array injection is
+ *   not the collect-all-implementers shape INJECTS models.
+ * - Non-collection types (`IFoo`, `Optional<IFoo>`, …) and wrong generic
+ *   arity (`Map<String>`, `List<A, B>`).
+ * - Anything whose element is not a plain (possibly dotted) Java type name —
+ *   this makes the parser fail closed on unanticipated syntax. In particular
+ *   Java block comments inside the generic arguments (a `/* ... ` comment
+ *   between `<` and the element) are NOT stripped and fail closed —
+ *   acceptable.
+ *
+ * Registered under `SupportedLanguages.Java` in `./index.ts` (`DI_MATCHERS`);
+ * language routing is the registry's job, so the matcher itself never reads
+ * `node.properties.language`.
+ */
+import { isDev } from '../utils/env.js';
+import { logger } from '../../logger.js';
+/**
+ * Annotations that trigger Spring's collect-all-implementers collection
+ * injection. `@Resource` is deliberately absent — JSR-250 resolves by bean
+ * NAME first (defaulting to the field name), injecting a single named
+ * collection bean rather than fanning out to every implementer, so an
+ * INJECTS fan-out for it would be a false edge.
+ */
+const INJECTION_ANNOTATIONS = new Set(['@Autowired', '@Inject']);
+/** Collection wrappers whose generic element Spring fans out to every
+ *  implementer. `Map` is special-cased for arity (2 args, element = value). */
+const COLLECTION_WRAPPERS = new Set(['List', 'Set', 'Collection', 'Map']);
+/** Bounded-wildcard prefixes stripped from the element position (single-spaced
+ *  — the input is whitespace-normalized before these are checked). */
+const WILDCARD_EXTENDS_PREFIX = '? extends ';
+const WILDCARD_SUPER_PREFIX = '? super ';
+/** A plain (possibly dotted) Java type name — the only element shape the
+ *  parser accepts. Everything else (wildcards, arrays, comments, stray
+ *  punctuation) fails closed. */
+const JAVA_TYPE_NAME_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/;
+/**
+ * Split a generic-argument list on TOP-LEVEL commas only, tracking `<`/`>`
+ * bracket depth so nested generics (e.g. the `Pair<A,B>` key in
+ * `Map<Pair<A,B>, IFoo>`) never split mid-argument.
+ *
+ * @returns the top-level argument segments (untrimmed), or `null` when the
+ *          brackets are unbalanced (fail closed on malformed input).
+ */
+function splitTopLevelGenericArgs(inner) {
+    const args = [];
+    let depth = 0;
+    let segmentStart = 0;
+    for (let i = 0; i < inner.length; i++) {
+        const ch = inner[i];
+        if (ch === '<') {
+            depth++;
+        }
+        else if (ch === '>') {
+            depth--;
+            if (depth < 0)
+                return null;
+        }
+        else if (ch === ',' && depth === 0) {
+            args.push(inner.slice(segmentStart, i));
+            segmentStart = i + 1;
+        }
+    }
+    if (depth !== 0)
+        return null;
+    args.push(inner.slice(segmentStart));
+    return args;
+}
+/**
+ * Extract the injected bean type name from one (whitespace-normalized)
+ * generic-argument segment: strip a bounded-wildcard prefix, then require a
+ * plain dotted Java type name.
+ *
+ * @returns the element type name, or `null` for unbounded wildcards, nested
+ *          generics, arrays, and any other non-type-name shape (fail closed).
+ */
+function parseElementTypeName(segment) {
+    let element = segment.trim();
+    // Bounded wildcards are idiomatic collection injection: the container
+    // still collects every implementer of the bound.
+    if (element.startsWith(WILDCARD_EXTENDS_PREFIX)) {
+        element = element.slice(WILDCARD_EXTENDS_PREFIX.length);
+    }
+    else if (element.startsWith(WILDCARD_SUPER_PREFIX)) {
+        element = element.slice(WILDCARD_SUPER_PREFIX.length);
+    }
+    // Final gate: a plain (possibly dotted) type name. Rejects nested generics
+    // (`Map<String, List<IFoo>>` — not resolvable as a single interface),
+    // arrays (`List<IFoo[]>` — not the fan-out shape INJECTS models), the
+    // unbounded wildcard `?`, un-stripped comments, and any other residue —
+    // all documented rejections; fail closed.
+    if (!JAVA_TYPE_NAME_PATTERN.test(element))
+        return null;
+    return element;
+}
+/**
+ * Parse a Spring DI collection field's raw declared type (verbatim source
+ * text, generics preserved) and return the injected bean type name.
+ *
+ * Whitespace-normalizes first (raw tree-sitter `.text` can span lines), then
+ * recognizes the wrapper by the LAST dotted segment before the first `<`
+ * (so `java.util.List<IFoo>` works), depth-aware-splits the generic argument
+ * list, and validates the element position. See the module docstring for the
+ * full accepted/rejected shape inventory.
+ *
+ * @returns the collection wrapper name + element type name, or `null` when
+ *          the raw declared type is not a recognized Spring collection shape.
+ */
+export function parseSpringCollectionType(rawDeclaredType) {
+    // Collapse ALL internal whitespace runs (spaces, tabs, newlines from
+    // multi-line declarations) to single spaces, then trim the ends.
+    const normalized = rawDeclaredType.replace(/\s+/g, ' ').trim();
+    const openIndex = normalized.indexOf('<');
+    // No generic argument list, or trailing residue after the closing `>`
+    // (e.g. the array suffix in `List<IFoo>[]`) — not a collection injection.
+    if (openIndex === -1 || !normalized.endsWith('>'))
+        return null;
+    // Wrapper = last dotted segment of the pre-`<` text: strips a package
+    // qualifier from the WRAPPER only (`java.util.List` → `List`).
+    const wrapperPath = normalized.slice(0, openIndex).trim();
+    const wrapperSegments = wrapperPath.split('.');
+    const wrapper = wrapperSegments[wrapperSegments.length - 1];
+    if (!COLLECTION_WRAPPERS.has(wrapper))
+        return null;
+    const inner = normalized.slice(openIndex + 1, normalized.length - 1);
+    const args = splitTopLevelGenericArgs(inner);
+    if (args === null)
+        return null;
+    // List/Set/Collection take exactly one type argument; Map exactly two,
+    // and the injected bean type is the VALUE (2nd argument) — the key is
+    // irrelevant for DI resolution.
+    const expectedArity = wrapper === 'Map' ? 2 : 1;
+    if (args.length !== expectedArity)
+        return null;
+    const elementTypeName = parseElementTypeName(args[expectedArity - 1]);
+    if (elementTypeName === null)
+        return null;
+    return { collectionType: wrapper, elementTypeName };
+}
+/**
+ * Match a `Property` node against Spring's collection-injection shape.
+ *
+ * Returns the parsed match (with a Spring-specific human-readable `reason`
+ * payload) or `null` when the field is not container-injected.
+ */
+export const springDiFieldMatcher = (node) => {
+    // Injection-annotation gate: only fields the container actually
+    // injects (@Autowired / @Inject) are candidates. Plain collection
+    // fields are never injected; @Resource is deliberately excluded
+    // (by-name-first semantics — see INJECTION_ANNOTATIONS).
+    const matchedAnnotation = node.properties.annotations?.find((a) => INJECTION_ANNOTATIONS.has(a));
+    if (matchedAnnotation === undefined)
+        return null;
+    // Match on rawDeclaredType ONLY — no `?? declaredType` fallback:
+    // production `declaredType` is generics-stripped by design, so a
+    // fallback can never match real data and would only mask plumbing
+    // regressions as quiet no-ops.
+    const rawDeclaredType = node.properties.rawDeclaredType;
+    if (!rawDeclaredType) {
+        // An injection-annotated field with NO rawDeclaredType means the
+        // extraction plumbing broke its contract (U1 threads the raw type
+        // wherever annotations are threaded) — surface it, don't silently drop.
+        if (isDev) {
+            logger.warn(`Spring DI: annotated field '${node.properties.name}' (${node.properties.filePath}) has no rawDeclaredType — extraction plumbing contract breach; skipping`);
+        }
+        return null;
+    }
+    const parsed = parseSpringCollectionType(rawDeclaredType);
+    if (!parsed)
+        return null;
+    return {
+        elementTypeName: parsed.elementTypeName,
+        // Honest reason: states the annotation actually found on the field and
+        // the collection wrapper it gated. Framework specifics live HERE, in the
+        // payload — never in the phase.
+        reason: `Spring DI: ${matchedAnnotation} ${parsed.collectionType}<${parsed.elementTypeName}>`,
+    };
+};

package/dist/core/ingestion/field-extractors/configs/helpers.d.ts

@@ -18,6 +18,18 @@ export declare function hasKeyword(node: SyntaxNode, keyword: string): boolean;
  * (e.g. Java 'modifiers', Kotlin 'modifiers').
  */
 export declare function hasModifier(node: SyntaxNode, modifierType: string, keyword: string): boolean;
+/**
+ * Collect `'@Name'`-prefixed annotation names from a declaration node's
+ * modifier-wrapper children (e.g. Java `modifiers`). Handles both
+ * `marker_annotation` (`@Autowired`) and `annotation`
+ * (`@Autowired(required=false)`) node types. Node-type-agnostic: works for
+ * any declaration (method, field, ...) that groups annotations under a
+ * wrapper child of type `modifierType`.
+ *
+ * Shared by the JVM method- and field-extractor configs (moved verbatim from
+ * `method-extractors/configs/jvm.ts` in PR #2200 U2).
+ */
+export declare function extractAnnotations(node: SyntaxNode, modifierType: string): string[];
 /**
  * Return the first matching visibility keyword found either as a direct keyword
  * child or inside a modifier wrapper node.

package/dist/core/ingestion/field-extractors/configs/helpers.js

@@ -39,6 +39,34 @@ export function hasModifier(node, modifierType, keyword) {
     }
     return false;
 }
+/**
+ * Collect `'@Name'`-prefixed annotation names from a declaration node's
+ * modifier-wrapper children (e.g. Java `modifiers`). Handles both
+ * `marker_annotation` (`@Autowired`) and `annotation`
+ * (`@Autowired(required=false)`) node types. Node-type-agnostic: works for
+ * any declaration (method, field, ...) that groups annotations under a
+ * wrapper child of type `modifierType`.
+ *
+ * Shared by the JVM method- and field-extractor configs (moved verbatim from
+ * `method-extractors/configs/jvm.ts` in PR #2200 U2).
+ */
+export function extractAnnotations(node, modifierType) {
+    const annotations = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === modifierType) {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const mod = child.namedChild(j);
+                if (mod && (mod.type === 'marker_annotation' || mod.type === 'annotation')) {
+                    const nameNode = mod.childForFieldName('name') ?? mod.firstNamedChild;
+                    if (nameNode)
+                        annotations.push('@' + nameNode.text);
+                }
+            }
+        }
+    }
+    return annotations;
+}
 /**
  * Return the first matching visibility keyword found either as a direct keyword
  * child or inside a modifier wrapper node.

package/dist/core/ingestion/field-extractors/configs/jvm.js

@@ -1,6 +1,6 @@
 // gitnexus/src/core/ingestion/field-extractors/configs/jvm.ts
 import { SupportedLanguages } from '../../../../_shared/index.js';
-import { findVisibility, hasKeyword, hasModifier, typeFromField } from './helpers.js';
+import { extractAnnotations, findVisibility, hasKeyword, hasModifier, typeFromField, } from './helpers.js';
 import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 // ---------------------------------------------------------------------------
 // Java
@@ -46,6 +46,18 @@ export const javaConfig = {
         }
         return undefined;
     },
+    extractRawType(node) {
+        // Verbatim type-node text — preserves generic arguments (`List<Shape>`)
+        // and qualifiers (`java.util.List<Shape>`) that extractType strips.
+        // Precedent: the JVM method extractor keeps raw `.text` for the same
+        // reason (method-extractors/configs/jvm.ts).
+        return node.childForFieldName('type')?.text?.trim();
+    },
+    extractAnnotations(node) {
+        // Same walk the JVM method extractor uses — field annotations live under
+        // the `modifiers` child of a `field_declaration` (e.g. `@Autowired`).
+        return extractAnnotations(node, 'modifiers');
+    },
     extractVisibility(node) {
         return findVisibility(node, JAVA_VIS, 'package', 'modifiers');
     },

package/dist/core/ingestion/field-extractors/generic.d.ts

@@ -37,6 +37,19 @@ export interface FieldExtractionConfig {
     extractNames?: (node: SyntaxNode) => string[];
     /** Extract type annotation from a field declaration node */
     extractType: (node: SyntaxNode) => string | undefined;
+    /**
+     * Extract the verbatim declared-type source text (trimmed) from a field
+     * declaration node, preserving generic arguments (`List<Shape>` stays
+     * `List<Shape>`). Unlike `extractType`, the result bypasses
+     * `normalizeType`/`resolveType` entirely — it is the untouched source text.
+     */
+    extractRawType?: (node: SyntaxNode) => string | undefined;
+    /**
+     * Extract `'@Name'`-prefixed annotation names from a field declaration
+     * node (e.g. `['@Autowired']`). Optional — only languages with
+     * field-level annotations implement it.
+     */
+    extractAnnotations?: (node: SyntaxNode) => string[];
     /** Extract visibility from a field declaration node */
     extractVisibility: (node: SyntaxNode) => FieldVisibility;
     /** Extract visibility for one field name from a multi-name declaration. */

package/dist/core/ingestion/field-extractors/generic.js

@@ -103,9 +103,35 @@ export function createFieldExtractor(config) {
                 if (resolved)
                     type = resolved;
             }
+            // Raw declared type deliberately bypasses normalizeType/resolveType —
+            // it is the verbatim source text (generics preserved).
+            let rawDeclaredType;
+            try {
+                rawDeclaredType = config.extractRawType?.(node);
+            }
+            catch {
+                // A throw here (an unexpected tree-sitter node shape, a config bug)
+                // must NOT propagate — it would escape processFileGroup to the
+                // language-group catch, which treats any throw as "parser unavailable"
+                // and silently drops every remaining file in the group. Degrade to a
+                // field without the raw type instead. Mirrors the descriptionExtractor
+                // / extractTemplateConstraints guards in parse-worker.ts (#2286 review).
+                rawDeclaredType = undefined;
+            }
+            let annotations;
+            try {
+                annotations = config.extractAnnotations?.(node);
+            }
+            catch {
+                // Same group-drop rationale as the extractRawType guard above —
+                // degrade to a field without annotations (#2286 review).
+                annotations = undefined;
+            }
             return {
                 name,
                 type,
+                ...(rawDeclaredType !== undefined ? { rawDeclaredType } : {}),
+                ...(annotations !== undefined && annotations.length > 0 ? { annotations } : {}),
                 visibility: config.extractVisibilityForName?.(node, name) ?? config.extractVisibility(node),
                 isStatic: config.isStatic(node),
                 isReadonly: config.isReadonly(node),