codespine 0.5.1__tar.gz → 0.5.2__tar.gz

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

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

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

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

codespine-0.5.2/codespine/analysis/crossmodule.py

@@ -0,0 +1,185 @@
+"""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) -> 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. 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
+        """
+    )
+
+    # 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
+
+        # 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)
+
+    LOGGER.info("Cross-module linking: created %d new call edges.", new_edges)
+    return new_edges

{codespine-0.5.1 → codespine-0.5.2}/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.2}/codespine.egg-info/PKG-INFO

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codespine"
-version = "0.5.1"
+version = "0.5.2"
 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