codespine 0.5.2__tar.gz → 0.5.3__tar.gz

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

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

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

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

{codespine-0.5.2 → 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.2 → 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.2 → codespine-0.5.3}/codespine/analysis/crossmodule.py

@@ -47,11 +47,15 @@ def _param_count(sig: str) -> int:
     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:
+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]
@@ -72,6 +76,8 @@ def link_cross_module_calls(store, project_ids: list[str] | None = None) -> int:
         """
     )
 
+    _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:
@@ -99,6 +105,8 @@ def link_cross_module_calls(store, project_ids: list[str] | None = None) -> int:
         if not other_class_names:
             continue
 
+        _ping(f"scanning {src_pid} methods")
+
         # Fetch all methods in this project
         src_methods = store.query_records(
             """
@@ -181,5 +189,6 @@ def link_cross_module_calls(store, project_ids: list[str] | None = None) -> int:
                         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.2 → 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.2 → 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.2 → codespine-0.5.3}/codespine.egg-info/PKG-INFO

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

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

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