codespine 0.5.1__tar.gz → 0.5.3__tar.gz

{codespine-0.5.1 → codespine-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 0.5.1
+Version: 0.5.3
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License

{codespine-0.5.1 → codespine-0.5.3}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "0.5.1"
+__version__ = "0.5.3"

{codespine-0.5.1 → codespine-0.5.3}/codespine/analysis/community.py

@@ -3,8 +3,14 @@ from __future__ import annotations
 from collections import defaultdict
 
 
-def detect_communities(store) -> list[dict]:
+def detect_communities(store, progress=None) -> list[dict]:
+    def _ping(msg: str) -> None:
+        if progress:
+            progress(msg)
+
+    _ping("loading symbols")
     symbols = store.query_records("MATCH (s:Symbol) RETURN s.id as id, s.fqname as fqname")
+    _ping(f"{len(symbols)} symbols, loading edges")
     edges = store.query_records(
         """
         MATCH (a:Method)-[:CALLS]->(b:Method)
@@ -17,6 +23,7 @@ def detect_communities(store) -> list[dict]:
     ids = [s["id"] for s in symbols]
     index_of = {sid: i for i, sid in enumerate(ids)}
 
+    _ping(f"{len(edges)} edges, clustering")
     membership: dict[str, int] = {}
     try:
         import igraph as ig
@@ -44,11 +51,17 @@ def detect_communities(store) -> list[dict]:
     for sid, cid in membership.items():
         grouped[cid].append(sid)
 
+    _ping(f"{len(grouped)} clusters, persisting")
     communities: list[dict] = []
+    done_clusters = 0
+    total_clusters = len(grouped)
     for cid, symbol_ids in grouped.items():
         cohesion = 1.0 / max(len(symbol_ids), 1)
         label = f"community_{cid}"
         store.set_community(str(cid), label, cohesion, symbol_ids)
+        done_clusters += 1
+        if done_clusters % 200 == 0 or done_clusters == total_clusters:
+            _ping(f"persisting {done_clusters}/{total_clusters} clusters")
         communities.append(
             {
                 "community_id": str(cid),

{codespine-0.5.1 → codespine-0.5.3}/codespine/analysis/coupling.py

@@ -46,11 +46,18 @@ def compute_coupling(
     months: int = SETTINGS.default_coupling_months,
     min_strength: float = SETTINGS.default_min_coupling_strength,
     min_cochanges: int = SETTINGS.default_min_cochanges,
+    progress=None,
 ) -> list[dict]:
+    def _ping(msg: str) -> None:
+        if progress:
+            progress(msg)
+
+    _ping("reading git history")
     changesets = _git_changed_file_sets(repo_path, months)
     if not changesets:
         return []
 
+    _ping(f"{len(changesets)} commits, computing co-changes")
     file_changes = Counter()
     co_changes: Counter[tuple[str, str]] = Counter()
 
@@ -60,6 +67,7 @@ def compute_coupling(
         for a, b in itertools.combinations(sorted(cs), 2):
             co_changes[(a, b)] += 1
 
+    _ping(f"{len(co_changes)} pairs, filtering and persisting")
     results = []
     for (a, b), pair_count in co_changes.items():
         denom = max(file_changes[a], file_changes[b])

codespine-0.5.3/codespine/analysis/crossmodule.py

@@ -0,0 +1,194 @@
+"""Cross-module call edge linker.
+
+After all modules in a workspace have been individually indexed, each module's
+call resolver only sees methods *within that module* (the class/method catalogs
+are project-scoped).  This module fills the gap by:
+
+  1. Building a **global** class-name index across ALL projects.
+  2. Scanning every method's signature and return type for class names that
+     belong to a DIFFERENT project.
+  3. Creating CALLS edges between the referencing method and the methods of
+     the referenced class.
+
+Two linking strategies are applied:
+
+  Strategy A — Name + arity match  (confidence 0.7)
+      The referencing method M_src calls a method with the same name AND
+      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.
+"""
+from __future__ import annotations
+
+import logging
+import re
+from collections import defaultdict
+
+LOGGER = logging.getLogger(__name__)
+
+# Very short class names produce too many false-positive matches when scanned
+# as substrings of method signatures.  Skip names ≤ this length.
+_MIN_CLASS_NAME_LEN = 4
+
+# Regex to split a Java signature into word tokens (class names, keywords, etc.)
+_TOKEN_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
+
+
+def _param_count(sig: str) -> int:
+    """Count parameters from a method signature string."""
+    if not sig or "(" not in sig or ")" not in sig:
+        return 0
+    arg_str = sig[sig.find("(") + 1: sig.rfind(")")]
+    return 0 if not arg_str.strip() else arg_str.count(",") + 1
+
+
+def link_cross_module_calls(store, project_ids: list[str] | None = None, progress=None) -> int:
+    """Create CALLS edges between methods in different projects.
+
+    Returns the number of new cross-module call edges created.
+    *progress* is an optional ``(status_str) -> None`` callback for live updates.
+    """
+    def _ping(msg: str) -> None:
+        if progress:
+            progress(msg)
+    if project_ids is None:
+        proj_recs = store.query_records("MATCH (p:Project) RETURN p.id as id")
+        project_ids = [r["id"] for r in proj_recs]
+
+    if len(project_ids) < 2:
+        LOGGER.info(
+            "Only %d project(s) indexed — skipping cross-module linking.",
+            len(project_ids),
+        )
+        return 0
+
+    # ── 1. Global class index ─────────────────────────────────────────
+    all_classes = store.query_records(
+        """
+        MATCH (c:Class), (f:File)
+        WHERE c.file_id = f.id
+        RETURN c.id as cid, c.name as name, c.fqcn as fqcn, f.project_id as pid
+        """
+    )
+
+    _ping(f"building class index ({len(all_classes)} classes)")
+
+    # class_name → [(class_id, project_id)]
+    name_to_classes: dict[str, list[tuple[str, str]]] = defaultdict(list)
+    for c in all_classes:
+        name_to_classes[c["name"]].append((c["cid"], c["pid"]))
+
+    # ── 2. Per-project class name sets (for O(1) lookups) ─────────────
+    # For each project pair (src, dst), we need the set of class names
+    # that belong to the OTHER project(s).  Pre-compute per-project sets.
+    classes_per_project: dict[str, set[str]] = defaultdict(set)
+    for c in all_classes:
+        if len(c["name"]) > _MIN_CLASS_NAME_LEN:
+            classes_per_project[c["pid"]].add(c["name"])
+
+    # ── 3. Scan methods for cross-project type references ─────────────
+    new_edges = 0
+    seen: set[tuple[str, str]] = set()
+
+    for src_pid in project_ids:
+        # Build the set of "interesting" class names from OTHER projects
+        other_class_names: set[str] = set()
+        for other_pid in project_ids:
+            if other_pid != src_pid:
+                other_class_names |= classes_per_project.get(other_pid, set())
+
+        if not other_class_names:
+            continue
+
+        _ping(f"scanning {src_pid} methods")
+
+        # Fetch all methods in this project
+        src_methods = store.query_records(
+            """
+            MATCH (m:Method), (c:Class), (f:File)
+            WHERE m.class_id = c.id AND c.file_id = f.id AND f.project_id = $pid
+            RETURN m.id as mid, m.name as name, m.signature as sig,
+                   m.return_type as rtype, c.id as cid
+            """,
+            {"pid": src_pid},
+        )
+
+        for sm in src_methods:
+            sig = sm.get("sig") or ""
+            rtype = sm.get("rtype") or ""
+            # Tokenize signature + return type into words
+            tokens = set(_TOKEN_RE.findall(sig + " " + rtype))
+            # Find which class names from other projects appear in the tokens
+            matched_class_names = tokens & other_class_names
+            if not matched_class_names:
+                continue
+
+            # For each matched class, create CALLS edges
+            for class_name in matched_class_names:
+                for dst_cid, dst_pid in name_to_classes.get(class_name, []):
+                    if dst_pid == src_pid:
+                        continue  # same project — not cross-module
+
+                    # Get methods of the destination class
+                    dst_methods = store.query_records(
+                        """MATCH (m:Method) WHERE m.class_id = $cid
+                           RETURN m.id as mid, m.name as name, m.signature as sig,
+                                  m.modifiers as modifiers, m.is_constructor as is_ctor""",
+                        {"cid": dst_cid},
+                    )
+                    if not dst_methods:
+                        continue
+
+                    # Strategy A: name + arity match
+                    matched_dst_mids: set[str] = set()
+                    sm_name = sm["name"]
+                    sm_pc = _param_count(sm.get("sig") or "")
+                    for dm in dst_methods:
+                        if dm["name"] == sm_name:
+                            dm_pc = _param_count(dm.get("sig") or "")
+                            if dm_pc == sm_pc:
+                                pair = (sm["mid"], dm["mid"])
+                                if pair not in seen:
+                                    seen.add(pair)
+                                    try:
+                                        store.add_call(
+                                            sm["mid"], dm["mid"],
+                                            0.7, "cross_module_name_match",
+                                        )
+                                        new_edges += 1
+                                    except Exception as exc:
+                                        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)
+
+    _ping(f"{new_edges} edges created")
+    LOGGER.info("Cross-module linking: created %d new call edges.", new_edges)
+    return new_edges

{codespine-0.5.1 → codespine-0.5.3}/codespine/analysis/flow.py

@@ -48,7 +48,12 @@ def _entry_methods(store, project: str | None = None) -> list[str]:
     return [r["id"] for r in fallback]
 
 
-def trace_execution_flows(store, entry_symbol: str | None = None, max_depth: int = 6, project: str | None = None) -> list[dict]:
+def trace_execution_flows(store, entry_symbol: str | None = None, max_depth: int = 6, project: str | None = None, progress=None) -> list[dict]:
+    def _ping(msg: str) -> None:
+        if progress:
+            progress(msg)
+
+    _ping("loading call graph")
     edges = store.query_records(
         """
         MATCH (a:Method)-[:CALLS]->(b:Method)
@@ -85,8 +90,11 @@ def trace_execution_flows(store, entry_symbol: str | None = None, max_depth: int
     else:
         entries = _entry_methods(store, project=project)
 
+    _ping(f"{len(entries)} entry points, tracing")
     flows = []
-    for e in entries:
+    for idx, e in enumerate(entries):
+        if idx % 50 == 0 and idx > 0:
+            _ping(f"traced {idx}/{len(entries)} entry points")
         visited = {e}
         q = deque([(e, 0)])
         nodes_with_depth = [(e, 0)]
@@ -115,6 +123,7 @@ def trace_execution_flows(store, entry_symbol: str | None = None, max_depth: int
     # need a second round-trip to resolve raw method ID hashes.
     # Collect all unique IDs across all flows, resolve in one bulk query.
     # ------------------------------------------------------------------ #
+    _ping(f"{len(flows)} flows, enriching metadata")
     all_ids = list({node["symbol"] for flow in flows for node in flow["nodes"]})
     meta = _resolve_method_metadata(store, all_ids)
 

{codespine-0.5.1 → codespine-0.5.3}/codespine/cli.py

@@ -217,13 +217,25 @@ def analyse(path: str, full: bool, deep: bool, embed: bool, allow_running: bool)
         elif parse_state["indexed"] < parse_state["total"]:
             _phase("Parsing code...", f"{parse_state['indexed']}/{parse_state['total']}")
 
+    # ── Helper for in-place progress updates ────────────────────────────
+    def _live_phase(label: str, status: str) -> None:
+        """Overwrite the current line with a status update."""
+        click.echo(f"\r{label:<30} {status:<50}", nl=False)
+
+    def _finish_phase(label: str, result: str) -> None:
+        """Finalise an in-place phase line and move to the next line."""
+        click.echo(f"\r{label:<30} {result:<50}")
+
     # ── Cross-module call linking ──────────────────────────────────────
-    # When multiple modules/projects are indexed, attempt to resolve call
-    # edges that span module boundaries using import + REFERENCES_TYPE info.
     if is_multi and len(modules_with_ids) > 1:
+        xmod_label = "Cross-module linking..."
+        _live_phase(xmod_label, "running")
         xmod_pids = [pid for _, pid in modules_with_ids]
-        xmod_edges = link_cross_module_calls(store, project_ids=xmod_pids)
-        _phase("Cross-module linking...", f"{xmod_edges} cross-module call edges")
+        xmod_edges = link_cross_module_calls(
+            store, project_ids=xmod_pids,
+            progress=lambda s: _live_phase(xmod_label, s),
+        )
+        _finish_phase(xmod_label, f"{xmod_edges} cross-module call edges")
     else:
         _phase("Cross-module linking...", "skipped (single module)")
 
@@ -234,16 +246,29 @@ def analyse(path: str, full: bool, deep: bool, embed: bool, allow_running: bool)
 
     should_run_deep = deep or total_files_found <= 1200
     if should_run_deep:
-        communities = detect_communities(store)
-        _phase("Detecting communities...", f"{len(communities)} clusters found")
+        comm_label = "Detecting communities..."
+        _live_phase(comm_label, "running")
+        communities = detect_communities(
+            store,
+            progress=lambda s: _live_phase(comm_label, s),
+        )
+        _finish_phase(comm_label, f"{len(communities)} clusters found")
 
-        flows = trace_execution_flows(store)
-        _phase("Detecting execution flows...", f"{len(flows)} processes found")
+        flow_label = "Detecting execution flows..."
+        _live_phase(flow_label, "running")
+        flows = trace_execution_flows(
+            store,
+            progress=lambda s: _live_phase(flow_label, s),
+        )
+        _finish_phase(flow_label, f"{len(flows)} processes found")
 
+        dead_label = "Finding dead code..."
+        _live_phase(dead_label, "running")
         dead = detect_dead_code(store, limit=500)
-        _phase("Finding dead code...", f"{len(dead)} unreachable symbols")
+        _finish_phase(dead_label, f"{len(dead)} unreachable symbols")
 
-        # Use the root path for git coupling; fallback to the single module path
+        coup_label = "Analyzing git history..."
+        _live_phase(coup_label, "running")
         coupling_root = abs_path
         coupling_project = root_basename if is_multi else (last_result.project_id if last_result else root_basename)
         coupling_pairs = compute_coupling(
@@ -253,8 +278,9 @@ def analyse(path: str, full: bool, deep: bool, embed: bool, allow_running: bool)
             months=SETTINGS.default_coupling_months,
             min_strength=SETTINGS.default_min_coupling_strength,
             min_cochanges=SETTINGS.default_min_cochanges,
+            progress=lambda s: _live_phase(coup_label, s),
         )
-        _phase("Analyzing git history...", f"{len(coupling_pairs)} coupled file pairs")
+        _finish_phase(coup_label, f"{len(coupling_pairs)} coupled file pairs")
     else:
         _phase("Detecting communities...", "skipped (large repo; rerun with --deep)")
         _phase("Detecting execution flows...", "skipped (large repo; rerun with --deep)")

{codespine-0.5.1 → codespine-0.5.3}/codespine/db/store.py

@@ -17,7 +17,7 @@ from codespine.db.schema import ensure_schema
 
 LOGGER = logging.getLogger(__name__)
 
-_BUFFER_POOL_SIZE = 256 * 1024 * 1024  # 256 MB – small enough for page eviction to work
+_BUFFER_POOL_SIZE = 512 * 1024 * 1024  # 512 MB – room for large community detection
 
 
 @dataclass
@@ -298,15 +298,23 @@ class GraphStore:
         )
         self.execute(query, {"src_id": src_id, "dst_id": dst_id, "confidence": confidence})
 
+    def _recycle_conn(self) -> None:
+        """Drop and recreate the per-thread connection to release buffer pages."""
+        try:
+            if hasattr(self._tls, "conn") and self._tls.conn is not None:
+                self._tls.conn = None
+        except Exception:
+            pass
+
     def set_community(self, community_id: str, label: str, cohesion: float, symbol_ids: list[str]) -> None:
         self.execute(
             "MERGE (c:Community {id: $id}) SET c.label = $label, c.cohesion = $cohesion",
             {"id": community_id, "label": label, "cohesion": cohesion},
         )
-        # Commit in batches of 50 to keep Kuzu's buffer pool from OOMing on large
-        # communities. A single transaction over thousands of MERGE statements exhausts
-        # the 256 MB buffer pool before it can page out.
-        _BATCH = 50
+        # Commit in batches of 500 to keep Kuzu's buffer pool from OOMing on
+        # large communities.  After each batch, recycle the connection so Kuzu
+        # can release buffer pages accumulated during the transaction.
+        _BATCH = 500
         for i in range(0, len(symbol_ids), _BATCH):
             batch = symbol_ids[i : i + _BATCH]
             with self.transaction():
@@ -315,17 +323,24 @@ class GraphStore:
                         "MATCH (s:Symbol {id: $sid}), (c:Community {id: $cid}) MERGE (s)-[:IN_COMMUNITY]->(c)",
                         {"sid": sid, "cid": community_id},
                     )
+            # Recycle connection after each batch to let Kuzu free buffer pages
+            self._recycle_conn()
 
     def set_flow(self, flow_id: str, entry_symbol_id: str, kind: str, symbols_at_depth: list[tuple[str, int]]) -> None:
         self.execute(
             "MERGE (f:Flow {id: $id}) SET f.entry_symbol_id = $entry, f.kind = $kind",
             {"id": flow_id, "entry": entry_symbol_id, "kind": kind},
         )
-        for sid, depth in symbols_at_depth:
-            self.execute(
-                "MATCH (s:Symbol {id: $sid}), (f:Flow {id: $fid}) MERGE (s)-[:IN_FLOW {depth: $depth}]->(f)",
-                {"sid": sid, "fid": flow_id, "depth": int(depth)},
-            )
+        _BATCH = 500
+        for i in range(0, len(symbols_at_depth), _BATCH):
+            batch = symbols_at_depth[i : i + _BATCH]
+            with self.transaction():
+                for sid, depth in batch:
+                    self.execute(
+                        "MATCH (s:Symbol {id: $sid}), (f:Flow {id: $fid}) MERGE (s)-[:IN_FLOW {depth: $depth}]->(f)",
+                        {"sid": sid, "fid": flow_id, "depth": int(depth)},
+                    )
+            self._recycle_conn()
 
     def upsert_coupling(self, file_a: str, file_b: str, strength: float, cochanges: int, months: int) -> None:
         self.execute(

{codespine-0.5.1 → codespine-0.5.3}/codespine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespine
-Version: 0.5.1
+Version: 0.5.3
 Summary: Local Java code intelligence indexer backed by a graph database
 Author: CodeSpine contributors
 License: MIT License

{codespine-0.5.1 → codespine-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codespine"
-version = "0.5.1"
+version = "0.5.3"
 description = "Local Java code intelligence indexer backed by a graph database"
 readme = "README.md"
 requires-python = ">=3.10"

codespine-0.5.1/codespine/analysis/crossmodule.py

@@ -1,173 +0,0 @@
-"""Cross-module call edge linker.
-
-After all modules in a workspace have been individually indexed, each module's
-call resolver only sees methods within that module.  This module fills the gap
-by scanning the graph for cross-project class references (REFERENCES_TYPE and
-IMPLEMENTS edges) and creating CALLS edges between methods where the call is
-plausible.
-
-Strategy A — Name + arity match  (confidence 0.7)
-    If src_class references dst_class (cross-project) and both have a method
-    with the same name and same parameter count, create a CALLS edge.  This
-    catches delegation, interface-implementation forwarding, and adapter
-    patterns.
-
-Strategy B — Type-reference fallback  (confidence 0.4)
-    For each *public* method in dst_class that received NO name-match edge,
-    create ONE low-confidence edge from a representative src method (preferring
-    one with zero outgoing calls).  This prevents methods that are genuinely
-    used cross-module from appearing as dead code.
-"""
-from __future__ import annotations
-
-import logging
-from collections import defaultdict
-
-LOGGER = logging.getLogger(__name__)
-
-
-def _param_count(sig: str) -> int:
-    """Count parameters from a method signature string."""
-    if not sig or "(" not in sig or ")" not in sig:
-        return 0
-    arg_str = sig[sig.find("(") + 1: sig.rfind(")")]
-    return 0 if not arg_str.strip() else arg_str.count(",") + 1
-
-
-def link_cross_module_calls(store, project_ids: list[str] | None = None) -> int:
-    """Create CALLS edges between methods in different projects.
-
-    Returns the number of new cross-module call edges created.
-    """
-    if project_ids is None:
-        proj_recs = store.query_records("MATCH (p:Project) RETURN p.id as id")
-        project_ids = [r["id"] for r in proj_recs]
-
-    if len(project_ids) < 2:
-        LOGGER.info(
-            "Only %d project(s) indexed — skipping cross-module linking.",
-            len(project_ids),
-        )
-        return 0
-
-    # ── 1. Collect cross-project class pairs ──────────────────────────
-    ref_pairs = store.query_records(
-        """
-        MATCH (src:Class)-[:REFERENCES_TYPE]->(dst:Class), (sf:File), (df:File)
-        WHERE src.file_id = sf.id AND dst.file_id = df.id
-          AND sf.project_id <> df.project_id
-        RETURN DISTINCT src.id as src_cid, dst.id as dst_cid
-        """
-    )
-    impl_pairs = store.query_records(
-        """
-        MATCH (src:Class)-[:IMPLEMENTS]->(dst:Class), (sf:File), (df:File)
-        WHERE src.file_id = sf.id AND dst.file_id = df.id
-          AND sf.project_id <> df.project_id
-        RETURN DISTINCT src.id as src_cid, dst.id as dst_cid
-        """
-    )
-
-    all_pairs: set[tuple[str, str]] = set()
-    for p in ref_pairs:
-        all_pairs.add((p["src_cid"], p["dst_cid"]))
-    for p in impl_pairs:
-        all_pairs.add((p["src_cid"], p["dst_cid"]))
-
-    if not all_pairs:
-        LOGGER.info("No cross-project class references found.")
-        return 0
-
-    LOGGER.info(
-        "Cross-module: %d cross-project class pair(s) to process.",
-        len(all_pairs),
-    )
-
-    # ── 2. Process each class pair ────────────────────────────────────
-    new_edges = 0
-    seen: set[tuple[str, str]] = set()
-
-    for src_cid, dst_cid in all_pairs:
-        src_methods = store.query_records(
-            """MATCH (m:Method) WHERE m.class_id = $cid
-               RETURN m.id as mid, m.name as name, m.signature as sig""",
-            {"cid": src_cid},
-        )
-        dst_methods = store.query_records(
-            """MATCH (m:Method) WHERE m.class_id = $cid
-               RETURN m.id as mid, m.name as name, m.signature as sig,
-                      m.modifiers as modifiers, m.is_constructor as is_ctor""",
-            {"cid": dst_cid},
-        )
-        if not src_methods or not dst_methods:
-            continue
-
-        # Build name → methods index for src class
-        src_by_name: dict[str, list[dict]] = defaultdict(list)
-        for sm in src_methods:
-            src_by_name[sm["name"]].append(sm)
-
-        # ── Strategy A: name + arity matching ─────────────────────────
-        matched_dst_mids: set[str] = set()
-
-        for dm in dst_methods:
-            dm_name = dm["name"]
-            dm_pc = _param_count(dm.get("sig") or "")
-            candidates = src_by_name.get(dm_name, [])
-            for sm in candidates:
-                sm_pc = _param_count(sm.get("sig") or "")
-                if sm_pc == dm_pc:
-                    pair = (sm["mid"], dm["mid"])
-                    if pair in seen:
-                        matched_dst_mids.add(dm["mid"])
-                        continue
-                    seen.add(pair)
-                    try:
-                        store.add_call(
-                            sm["mid"], dm["mid"], 0.7, "cross_module_name_match",
-                        )
-                        new_edges += 1
-                        matched_dst_mids.add(dm["mid"])
-                    except Exception as exc:
-                        LOGGER.debug("Name-match edge failed: %s", exc)
-
-        # ── Strategy B: fallback for unmatched public dst methods ─────
-        # Find a representative caller: prefer src methods with 0 outgoing calls
-        fallback_src = None
-        for sm in src_methods:
-            out = store.query_records(
-                "MATCH (m:Method {id: $mid})-[:CALLS]->(:Method) RETURN count(*) as n",
-                {"mid": sm["mid"]},
-            )
-            if out and out[0]["n"] == 0:
-                fallback_src = sm
-                break
-        if fallback_src is None and src_methods:
-            fallback_src = src_methods[0]
-
-        if fallback_src:
-            for dm in dst_methods:
-                if dm["mid"] in matched_dst_mids:
-                    continue
-                # Skip constructors and private methods
-                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 = (fallback_src["mid"], dm["mid"])
-                if pair in seen:
-                    continue
-                seen.add(pair)
-                try:
-                    store.add_call(
-                        fallback_src["mid"], dm["mid"], 0.4, "cross_module_type_ref",
-                    )
-                    new_edges += 1
-                except Exception as exc:
-                    LOGGER.debug("Fallback edge failed: %s", exc)
-
-    LOGGER.info("Cross-module linking: created %d new call edges.", new_edges)
-    return new_edges