codespine 0.7.3__tar.gz → 0.9.0__tar.gz

{codespine-0.7.3 → codespine-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 0.7.3
+Version: 0.9.0
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License
@@ -267,7 +267,7 @@ codespine guide --json   # structured JSON for tooling
 | `detect_dead_code(limit, project, strict)` | Methods with no callers (Java-aware exemptions). |
 | `trace_execution_flows(entry_symbol, max_depth, project)` | Execution paths from entry points. |
 | `get_symbol_community(symbol)` | Architectural community cluster for a symbol. |
-| `get_change_coupling(months, min_strength, min_cochanges)` | Files that historically change together. |
+| `get_change_coupling(days, min_strength, min_cochanges)` | Files that changed together in the last N days (default 5). |
 
 **Git**
 

{codespine-0.7.3 → codespine-0.9.0}/README.md

@@ -203,7 +203,7 @@ codespine guide --json   # structured JSON for tooling
 | `detect_dead_code(limit, project, strict)` | Methods with no callers (Java-aware exemptions). |
 | `trace_execution_flows(entry_symbol, max_depth, project)` | Execution paths from entry points. |
 | `get_symbol_community(symbol)` | Architectural community cluster for a symbol. |
-| `get_change_coupling(months, min_strength, min_cochanges)` | Files that historically change together. |
+| `get_change_coupling(days, min_strength, min_cochanges)` | Files that changed together in the last N days (default 5). |
 
 **Git**
 

{codespine-0.7.3 → codespine-0.9.0}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "0.7.3"
+__version__ = "0.9.0"

{codespine-0.7.3 → codespine-0.9.0}/codespine/analysis/crossmodule.py

@@ -17,11 +17,10 @@ Two linking strategies are applied:
       parameter count as a method M_dst in the referenced class.  This catches
       delegation, interface-implementation forwarding, and adapter patterns.
 
-  Strategy B — Type-reference fallback  (confidence 0.4)
-      For every *public, non-constructor* method in the referenced class that
-      received NO name-match edge, create ONE low-confidence edge from the
-      referencing method.  This prevents methods that are genuinely used
-      cross-module from appearing as dead code.
+  Strategy B — Direct parameter/return type reference  (confidence 0.6)
+      When the referenced class name appears directly as a parameter type or
+      return type of the source method, create an edge to the class's
+      constructor (if any).  This catches model/DTO/context instantiation.
 """
 from __future__ import annotations
 
@@ -165,29 +164,28 @@ def link_cross_module_calls(store, project_ids: list[str] | None = None, progres
                                         LOGGER.debug("Name-match edge failed: %s", exc)
                                 matched_dst_mids.add(dm["mid"])
 
-                    # Strategy B: fallback for unmatched public dst methods
-                    for dm in dst_methods:
-                        if dm["mid"] in matched_dst_mids:
-                            continue
-                        if dm.get("is_ctor"):
-                            continue
-                        mods = dm.get("modifiers") or []
-                        mod_strs = {str(m).strip() for m in mods} if mods else set()
-                        if "private" in mod_strs:
-                            continue
-
-                        pair = (sm["mid"], dm["mid"])
-                        if pair in seen:
-                            continue
-                        seen.add(pair)
-                        try:
-                            store.add_call(
-                                sm["mid"], dm["mid"],
-                                0.4, "cross_module_type_ref",
-                            )
-                            new_edges += 1
-                        except Exception as exc:
-                            LOGGER.debug("Fallback edge failed: %s", exc)
+                    # Strategy B: if the referenced class name appears directly
+                    # in the source method's parameter types or return type,
+                    # link to the class's constructor (model/DTO instantiation).
+                    if not matched_dst_mids:
+                        rtype_tokens = set(_TOKEN_RE.findall(rtype))
+                        sig_tokens = set(_TOKEN_RE.findall(sig))
+                        if class_name in rtype_tokens or class_name in sig_tokens:
+                            for dm in dst_methods:
+                                if not dm.get("is_ctor"):
+                                    continue
+                                pair = (sm["mid"], dm["mid"])
+                                if pair in seen:
+                                    continue
+                                seen.add(pair)
+                                try:
+                                    store.add_call(
+                                        sm["mid"], dm["mid"],
+                                        0.6, "cross_module_ctor_ref",
+                                    )
+                                    new_edges += 1
+                                except Exception as exc:
+                                    LOGGER.debug("Ctor-ref edge failed: %s", exc)
 
     _ping(f"{new_edges} edges created")
     LOGGER.info("Cross-module linking: created %d new call edges.", new_edges)

{codespine-0.7.3 → codespine-0.9.0}/codespine/analysis/impact.py

@@ -115,6 +115,41 @@ def analyze_impact(store, symbol_query: str, max_depth: int = 4, project: str |
             """
         )
 
+    # Augment with DI injection edges: for each target method's class, find all
+    # classes that @Inject it (or bind it via @Component/@Service) and add their
+    # methods as implicit callers at depth+1 with edge_type "DI_INJECT".
+    try:
+        di_edges = store.query_records(
+            """
+            MATCH (a:Method), (ca:Class), (b:Method), (cb:Class),
+                  (ca)-[r:INJECTS]->(cb)
+            WHERE a.class_id = ca.id AND b.class_id = cb.id
+            RETURN a.id as src, b.id as dst, 'DI_INJECT' as edge_type,
+                   coalesce(r.confidence, 0.8) as confidence,
+                   coalesce(r.binding_type, 'field_inject') as reason
+            """
+        )
+        edges = list(edges) + di_edges
+    except Exception:
+        pass  # INJECTS table may not exist on old DBs
+
+    # Also follow BINDS_INTERFACE — any class implementing the target's interface
+    # counts as an indirect caller.
+    try:
+        bi_edges = store.query_records(
+            """
+            MATCH (a:Method), (ca:Class), (b:Method), (cb:Class),
+                  (ca)-[r:BINDS_INTERFACE]->(cb)
+            WHERE a.class_id = ca.id AND b.class_id = cb.id
+            RETURN a.id as src, b.id as dst, 'INTERFACE_BINDING' as edge_type,
+                   coalesce(r.confidence, 0.9) as confidence,
+                   coalesce(r.reason, 'implements') as reason
+            """
+        )
+        edges = list(edges) + bi_edges
+    except Exception:
+        pass
+
     reverse_adj: dict[str, list[dict]] = defaultdict(list)
     for edge in edges:
         reverse_adj[edge["dst"]].append(edge)
@@ -184,13 +219,31 @@ def analyze_impact(store, symbol_query: str, max_depth: int = 4, project: str |
         for mid in target_method_ids
     ]
 
+    # FR-06: Separate "self_callers" (same class as target, depth=1) from
+    # impacted_callers so the output is unambiguous.
+    target_class_fqcns = {
+        target_meta.get(mid, {}).get("class_fqcn")
+        for mid in target_method_ids
+        if target_meta.get(mid, {}).get("class_fqcn")
+    }
+    self_callers: list[dict] = []
+    impacted_depth1: list[dict] = []
+    for item in depth_groups["1"]:
+        if item.get("class_fqcn") and item["class_fqcn"] in target_class_fqcns:
+            self_callers.append(item)
+        else:
+            impacted_depth1.append(item)
+    depth_groups["1"] = impacted_depth1
+
     return {
         "target": symbol_query,
-        "targets_resolved": resolved_targets,
-        "depth_groups": depth_groups,
+        "resolved_to": resolved_targets,
+        "self_callers": self_callers,
+        "impacted_callers": depth_groups,
         "summary": {
             "direct": len(depth_groups["1"]),
             "indirect": len(depth_groups["2"]),
             "transitive": len(depth_groups["3+"]),
+            "self_callers": len(self_callers),
         },
     }

{codespine-0.7.3 → codespine-0.9.0}/codespine/db/schema.py

@@ -51,6 +51,16 @@ REL_TABLES: Iterable[tuple[str, str]] = [
         "CO_CHANGED_WITH",
         "CREATE REL TABLE CO_CHANGED_WITH(FROM File TO File, strength DOUBLE, cochanges INT64, days INT64)",
     ),
+    # v5: Dependency-injection edges — tracks @Inject/@Autowired/@Provides/@Bean bindings
+    (
+        "INJECTS",
+        "CREATE REL TABLE INJECTS(FROM Class TO Class, framework STRING, binding_type STRING, confidence DOUBLE)",
+    ),
+    # v5: Interface-to-implementation bindings discovered via @Component/@Service annotations
+    (
+        "BINDS_INTERFACE",
+        "CREATE REL TABLE BINDS_INTERFACE(FROM Class TO Class, confidence DOUBLE, reason STRING)",
+    ),
 ]
 
 
@@ -81,7 +91,7 @@ def ensure_schema(conn) -> None:
 
     _safe_execute(
         conn,
-        "MERGE (s:SchemaMeta {key: 'schema_version'}) SET s.value = '4'",
+        "MERGE (s:SchemaMeta {key: 'schema_version'}) SET s.value = '5'",
     )
 
     _safe_execute(conn, "ALTER TABLE Project ADD indexed_commit STRING DEFAULT ''")

{codespine-0.7.3 → codespine-0.9.0}/codespine/db/store.py

@@ -476,6 +476,163 @@ class GraphStore:
                 confidence=float(record["confidence"]),
             )
 
+    def add_injection(
+        self,
+        src_class_id: str,
+        dst_class_id: str,
+        framework: str,
+        binding_type: str,
+        confidence: float,
+    ) -> None:
+        """Write an INJECTS edge between two Class nodes."""
+        try:
+            self.execute(
+                """
+                MATCH (a:Class {id: $src}), (b:Class {id: $dst})
+                MERGE (a)-[:INJECTS {framework: $fw, binding_type: $bt, confidence: $conf}]->(b)
+                """,
+                {
+                    "src": src_class_id,
+                    "dst": dst_class_id,
+                    "fw": framework,
+                    "bt": binding_type,
+                    "conf": float(confidence),
+                },
+            )
+        except Exception as exc:
+            LOGGER.debug("add_injection: skipping edge %s→%s: %s", src_class_id, dst_class_id, exc)
+
+    def add_injections_batch(self, records: list[dict[str, Any]]) -> None:
+        for rec in records:
+            self.add_injection(
+                src_class_id=rec["src"],
+                dst_class_id=rec["dst"],
+                framework=rec.get("framework", "unknown"),
+                binding_type=rec.get("binding_type", "unknown"),
+                confidence=float(rec.get("confidence", 0.8)),
+            )
+
+    def add_interface_binding(
+        self,
+        src_class_id: str,
+        dst_class_id: str,
+        confidence: float,
+        reason: str,
+    ) -> None:
+        """Write a BINDS_INTERFACE edge between two Class nodes."""
+        try:
+            self.execute(
+                """
+                MATCH (a:Class {id: $src}), (b:Class {id: $dst})
+                MERGE (a)-[:BINDS_INTERFACE {confidence: $conf, reason: $reason}]->(b)
+                """,
+                {
+                    "src": src_class_id,
+                    "dst": dst_class_id,
+                    "conf": float(confidence),
+                    "reason": reason,
+                },
+            )
+        except Exception as exc:
+            LOGGER.debug("add_interface_binding: skipping edge %s→%s: %s", src_class_id, dst_class_id, exc)
+
+    def add_interface_bindings_batch(self, records: list[dict[str, Any]]) -> None:
+        for rec in records:
+            self.add_interface_binding(
+                src_class_id=rec["src"],
+                dst_class_id=rec["dst"],
+                confidence=float(rec.get("confidence", 0.9)),
+                reason=rec.get("reason", "implements"),
+            )
+
+    # Sub-batch sizes for direct-to-graph file writes (same policy as engine.py)
+    _FILE_METHOD_SUB_BATCH = 200
+    _FILE_SYMBOL_SUB_BATCH = 200
+    _FILE_CALL_SUB_BATCH = 500
+    _FILE_REL_SUB_BATCH = 500
+
+    def upsert_file_from_entry(self, entry: dict, project_path: str) -> None:
+        """Atomically replace one file's graph data from a build_overlay_file_entry() dict.
+
+        Clears all existing nodes/edges for the file first, then writes the
+        full parsed content (file, classes, methods, symbols, calls, type rels)
+        in sub-batched transactions to prevent Kuzu buffer pool OOM.
+
+        This is the primary path for watch-mode incremental writes — it
+        bypasses the overlay JSON store and writes directly to the write DB
+        so changes are immediately visible after snapshot_to_read_replica().
+        """
+        f_id = entry["file_id"]
+        path = entry["file_path"]
+        project_id = entry["project_id"]
+        is_test = bool(entry.get("is_test", False))
+        digest = entry.get("file_hash", "")
+        classes = entry.get("classes") or []
+        methods = entry.get("methods") or []
+        symbols = entry.get("symbols") or []
+        calls = entry.get("calls") or []
+        type_rels = entry.get("types") or []
+
+        # 1. Clear stale data for this file
+        with self.transaction():
+            self.clear_file(f_id)
+        self._recycle_conn()
+
+        # 2. Upsert file record
+        with self.transaction():
+            self.upsert_file(f_id, path, project_id, is_test, digest)
+        self._recycle_conn()
+
+        # 3. Upsert classes (typically very few per file)
+        if classes:
+            with self.transaction():
+                self.upsert_classes_batch(classes)
+            self._recycle_conn()
+
+        # 4. Upsert methods in sub-batches of 200
+        for i in range(0, len(methods), self._FILE_METHOD_SUB_BATCH):
+            batch = methods[i: i + self._FILE_METHOD_SUB_BATCH]
+            with self.transaction():
+                self.upsert_methods_batch(batch)
+            self._recycle_conn()
+
+        # 5. Upsert symbols in sub-batches of 200
+        for i in range(0, len(symbols), self._FILE_SYMBOL_SUB_BATCH):
+            batch = symbols[i: i + self._FILE_SYMBOL_SUB_BATCH]
+            with self.transaction():
+                self.upsert_symbols_batch(batch)
+            self._recycle_conn()
+
+        # 6. Write call edges in sub-batches of 500
+        for i in range(0, len(calls), self._FILE_CALL_SUB_BATCH):
+            batch = calls[i: i + self._FILE_CALL_SUB_BATCH]
+            with self.transaction():
+                for rec in batch:
+                    self.add_call(
+                        source_id=rec["src"],
+                        target_id=rec["dst"],
+                        confidence=float(rec.get("confidence", 0.5)),
+                        reason=rec.get("reason", "unknown"),
+                    )
+            self._recycle_conn()
+
+        # 7. Write type relations (IMPLEMENTS, OVERRIDES, REFERENCES_TYPE)
+        for i in range(0, len(type_rels), self._FILE_REL_SUB_BATCH):
+            batch = type_rels[i: i + self._FILE_REL_SUB_BATCH]
+            with self.transaction():
+                self.add_references_batch(batch)
+            self._recycle_conn()
+
+    def clear_file_by_path(self, project_id: str, project_path: str, file_path: str) -> None:
+        """Delete all graph data for a file identified by its filesystem path."""
+        from codespine.indexer.symbol_builder import file_id as _fid
+        import os as _os
+        rel_path = _os.path.relpath(os.path.abspath(file_path), os.path.abspath(project_path))
+        f_id = _fid(project_id, rel_path)
+        with self.transaction():
+            self.clear_file(f_id)
+        self._recycle_conn()
+
     def _recycle_conn(self) -> None:
         """Drop and recreate the per-thread connection to release buffer pages."""
         try:

{codespine-0.7.3 → codespine-0.9.0}/codespine/indexer/call_resolver.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections import defaultdict
 from typing import Iterator
 
-from codespine.noise.blocklist import NOISE_METHOD_NAMES
+from codespine.noise.blocklist import MIN_FUZZY_NAME_LEN, NOISE_METHOD_NAMES
 
 MAX_FUZZY_TARGETS = 12
 
@@ -84,8 +84,6 @@ def resolve_calls(
 
         for call in call_sites:
             call_name = call.name
-            if call_name in NOISE_METHOD_NAMES:
-                continue
 
             key = (call_name, int(call.arg_count))
             targets: list[str] = []
@@ -123,6 +121,12 @@ def resolve_calls(
                     reason = "intra_class_exact"
 
             if not targets:
+                # Skip noise method names and short names in the fuzzy global
+                # fallback — they are too ambiguous without receiver context.
+                if call_name in NOISE_METHOD_NAMES:
+                    continue
+                if len(call_name) < MIN_FUZZY_NAME_LEN:
+                    continue
                 # Prefer same-package candidates before global fallback.
                 src_pkg = src_ctx.get("package", "")
                 same_pkg = []

codespine-0.9.0/codespine/indexer/di_resolver.py

@@ -0,0 +1,210 @@
+"""Dependency-injection binding resolver for CodeSpine.
+
+Produces INJECTS and BINDS_INTERFACE edges by inspecting:
+
+1. @Inject / @Autowired fields  →  INJECTS(consumer_class → provider_class)
+2. @Provides / @Bean methods    →  INJECTS(config_class → consumer_classes)
+3. @Component/@Service classes  →  BINDS_INTERFACE(impl → interface) when
+                                   the class implements an indexed interface.
+
+All edges are written in sub-batched transactions by the engine after
+call resolution completes.
+
+Edge schemas
+------------
+INJECTS(FROM Class TO Class,
+        framework STRING,   # "spring" | "guice" | "jakarta" | "javax" | "unknown"
+        binding_type STRING, # "field_inject" | "constructor_inject" |
+                              #  "provides_binding" | "bean_method" | "component_scan"
+        confidence DOUBLE)
+
+BINDS_INTERFACE(FROM Class TO Class,
+                confidence DOUBLE,
+                reason STRING)   # "implements" | "extends"
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Iterator
+
+LOGGER = logging.getLogger(__name__)
+
+# Annotations that mark a field/constructor parameter as injection point.
+_INJECT_ANNOTATIONS = frozenset({
+    "Inject", "Autowired", "Resource",
+    "javax.inject.Inject", "jakarta.inject.Inject",
+    "org.springframework.beans.factory.annotation.Autowired",
+})
+
+# Annotations that mark a method as a DI provider.
+_PROVIDES_ANNOTATIONS = frozenset({
+    "Provides", "Bean",
+    "com.google.inject.Provides",
+    "org.springframework.context.annotation.Bean",
+})
+
+# Component-scan annotations: classes with these are treated as injectable.
+_COMPONENT_ANNOTATIONS = frozenset({
+    "Component", "Service", "Repository", "Controller", "RestController",
+    "Configuration", "ManagedBean", "Named",
+    "org.springframework.stereotype.Component",
+    "org.springframework.stereotype.Service",
+    "javax.inject.Named", "jakarta.inject.Named",
+})
+
+# DI frameworks by annotation prefix
+_FRAMEWORK_MAP: dict[str, str] = {
+    "Autowired": "spring",
+    "Component": "spring", "Service": "spring", "Repository": "spring",
+    "Controller": "spring", "RestController": "spring", "Bean": "spring",
+    "Configuration": "spring",
+    "Inject": "guice",
+    "Provides": "guice",
+    "Named": "guice",
+    "Resource": "jakarta",
+    "ManagedBean": "jakarta",
+}
+
+
+def _framework(annotation: str) -> str:
+    simple = annotation.split(".")[-1]
+    if "springframework" in annotation:
+        return "spring"
+    if "google.inject" in annotation:
+        return "guice"
+    if "jakarta.inject" in annotation:
+        return "jakarta"
+    if "javax.inject" in annotation:
+        return "javax"
+    return _FRAMEWORK_MAP.get(simple, "unknown")
+
+
+def _simple(annotation: str) -> str:
+    return annotation.split(".")[-1]
+
+
+def resolve_di_bindings(
+    class_catalog: dict[str, list[str]],
+    class_meta: dict[str, dict[str, Any]],
+    parsed_classes: list[dict[str, Any]],
+    fqcn_to_class_ids: dict[str, list[str]],
+) -> Iterator[tuple[str, str, str, str, float, str]]:
+    """Yield (src_class_id, dst_class_id, framework, binding_type, confidence, edge_type) tuples.
+
+    edge_type is "INJECTS" or "BINDS_INTERFACE".
+
+    Parameters
+    ----------
+    class_catalog      : name → [fqcn, ...]  (full project catalog)
+    class_meta         : class_id → {fqcn, annotations, interfaces, extends, imports, package}
+    parsed_classes     : list of dicts from build_overlay_file_entry / engine — each has:
+                           id, fqcn, name, package, file_id, and extra DI metadata fields
+                           injected_fields, methods_with_provides
+    fqcn_to_class_ids  : fqcn → [class_id, ...]
+    """
+    # Build a reverse FQCN lookup: fqcn → class_id (first match)
+    fqcn_to_id: dict[str, str] = {}
+    for fqcn, ids in fqcn_to_class_ids.items():
+        if ids:
+            fqcn_to_id[fqcn] = ids[0]
+
+    # Build simple-name → [fqcn] lookup for type resolution.
+    name_to_fqcns: dict[str, list[str]] = {}
+    for fqcn in fqcn_to_id:
+        simple = fqcn.split(".")[-1]
+        name_to_fqcns.setdefault(simple, []).append(fqcn)
+    # Also add class_catalog entries.
+    for name, fqcns in class_catalog.items():
+        for fqcn in fqcns:
+            if fqcn not in name_to_fqcns.get(name, []):
+                name_to_fqcns.setdefault(name, []).append(fqcn)
+
+    # Build a set of class_ids for component-scan eligible classes.
+    component_class_ids: set[str] = set()
+    for meta in class_meta.values():
+        anns = [_simple(a) for a in (meta.get("annotations") or [])]
+        if any(a in _COMPONENT_ANNOTATIONS for a in anns):
+            cid = meta.get("id") or ""
+            if cid:
+                component_class_ids.add(cid)
+
+    def _resolve_type(type_name: str, package: str, imports: list[str]) -> list[str]:
+        """Best-effort resolution of a simple type name to known class IDs."""
+        if not type_name:
+            return []
+        # Strip generics: List<Foo> → Foo
+        if "<" in type_name:
+            type_name = type_name[type_name.index("<") + 1:].rstrip(">").strip()
+        simple = type_name.split(".")[-1]
+        candidates: list[str] = []
+        # 1. Exact FQ match.
+        if "." in type_name and type_name in fqcn_to_id:
+            candidates.append(fqcn_to_id[type_name])
+        # 2. Same package.
+        same_pkg = f"{package}.{simple}" if package else simple
+        if same_pkg in fqcn_to_id:
+            candidates.append(fqcn_to_id[same_pkg])
+        # 3. From imports.
+        for imp in imports:
+            if imp.endswith(f".{simple}") and imp in fqcn_to_id:
+                candidates.append(fqcn_to_id[imp])
+        # 4. Name catalog.
+        for fqcn in name_to_fqcns.get(simple, []):
+            cid = fqcn_to_id.get(fqcn)
+            if cid:
+                candidates.append(cid)
+        return list(dict.fromkeys(candidates))  # deduplicate preserving order
+
+    # ---------------------------------------------------------------
+    # Process each parsed class.
+    # ---------------------------------------------------------------
+    for cls in parsed_classes:
+        src_id = cls.get("id") or cls.get("class_id") or ""
+        if not src_id:
+            continue
+        meta = class_meta.get(src_id, {})
+        package = str(meta.get("package") or cls.get("package") or "")
+        imports: list[str] = meta.get("imports") or []
+        cls_annotations: list[str] = [_simple(a) for a in (meta.get("annotations") or cls.get("annotations") or [])]
+
+        # --- 1. @Inject / @Autowired fields → INJECTS edges ---------
+        for fld in cls.get("injected_fields") or []:
+            inj_ann = fld.get("injection_annotation") or ""
+            if not inj_ann or _simple(inj_ann) not in frozenset({
+                "Inject", "Autowired", "Resource"
+            }):
+                continue
+            type_name = fld.get("type_name") or ""
+            dst_ids = _resolve_type(type_name, package, imports)
+            fw = _framework(inj_ann)
+            for dst_id in dst_ids:
+                if dst_id != src_id:
+                    yield (src_id, dst_id, fw, "field_inject", 0.85, "INJECTS")
+
+        # --- 2. @Provides / @Bean methods → INJECTS (config → type) -
+        for method in cls.get("methods_with_provides") or []:
+            provides_type = method.get("provides_type") or ""
+            if not provides_type:
+                continue
+            ann = method.get("provides_annotation") or "Provides"
+            fw = _framework(ann)
+            dst_ids = _resolve_type(provides_type, package, imports)
+            for dst_id in dst_ids:
+                if dst_id != src_id:
+                    binding_type = "bean_method" if _simple(ann) == "Bean" else "provides_binding"
+                    yield (src_id, dst_id, fw, binding_type, 0.9, "INJECTS")
+
+        # --- 3. Component-scan: class implementing interfaces → BINDS_INTERFACE
+        if any(a in _COMPONENT_ANNOTATIONS for a in cls_annotations):
+            for iface_name in meta.get("interfaces") or []:
+                dst_ids = _resolve_type(iface_name, package, imports)
+                for dst_id in dst_ids:
+                    if dst_id != src_id:
+                        yield (src_id, dst_id, 1.0, "implements", 0.95, "BINDS_INTERFACE")
+            extends_name = meta.get("extends") or ""
+            if extends_name:
+                dst_ids = _resolve_type(extends_name, package, imports)
+                for dst_id in dst_ids:
+                    if dst_id != src_id:
+                        yield (src_id, dst_id, 0.7, "extends", 0.7, "BINDS_INTERFACE")