codespine 1.0.4__tar.gz → 1.0.7__tar.gz

{codespine-1.0.4 → codespine-1.0.7}/PKG-INFO

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

{codespine-1.0.4 → codespine-1.0.7}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "1.0.4"
+__version__ = "1.0.7"

{codespine-1.0.4 → codespine-1.0.7}/codespine/cli.py

@@ -137,8 +137,12 @@ def _index_shard_group(
 
     for mod_path, project_id in modules:
         # Per-module progress state (local — no shared mutation).
-        parse_state: dict = {"shown": False, "indexed": 0, "total": 0,
-                              "last_ts": 0.0, "printed_zero": False}
+        parse_state: dict = {
+            "shown": False, "indexed": 0, "total": 0,
+            "last_ts": 0.0, "printed_zero": False,
+            "current_file": "", "elapsed": 0.0,
+            "last_done": -1, "frozen_since": 0.0, "stall_warned": False,
+        }
         call_state: dict = {"shown": False, "count": 0, "last_ts": 0.0,
                              "started_at": 0.0}
 
@@ -160,11 +164,61 @@ def _index_shard_group(
                         _phase(f"{prefix}Parsing code...", "0/0")
                     parse_state["printed_zero"] = True
                 return
+            if event == "parse_heartbeat":
+                # Fires every 2s from a daemon thread — keeps spinner alive
+                # even when all worker threads are busy or one is hanging.
+                done    = int(payload.get("done", 0))
+                total   = int(payload.get("total", 0))
+                current = str(payload.get("current_file", ""))
+                elapsed_s = float(payload.get("elapsed", 0.0))
+                parse_state["indexed"] = done
+                parse_state["total"] = total
+                parse_state["current_file"] = current
+                parse_state["elapsed"] = elapsed_s
+                if total > 0 and not parallel:
+                    basename = os.path.basename(current) if current else ""
+                    click.echo(
+                        f"\r{_spinner_char()} {prefix}Parsing code...   "
+                        f"{_bar(done, total)} {done}/{total}  "
+                        f"{basename[:38]:<38}  {elapsed_s:.0f}s  ",
+                        nl=False,
+                    )
+                    parse_state["shown"] = True
+                    parse_state["last_ts"] = now
+
+                # ── Stall detection ──────────────────────────────────────
+                if done == parse_state["last_done"]:
+                    if parse_state["frozen_since"] == 0.0:
+                        parse_state["frozen_since"] = now
+                    stalled_for = now - parse_state["frozen_since"]
+                    if stalled_for >= 15.0 and not parse_state["stall_warned"]:
+                        parse_state["stall_warned"] = True
+                        basename = os.path.basename(current) if current else "unknown"
+                        with output_lock:
+                            click.echo()  # break out of \r line
+                            click.secho(
+                                f"  ⚠  Parsing stalled on {basename} for "
+                                f"{stalled_for:.0f}s — file may be pathological.\n"
+                                f"     Timeout at {os.environ.get('CODESPINE_PARSE_TIMEOUT_SECS', '60')}s. "
+                                f"To skip large files: "
+                                f"export CODESPINE_MAX_FILE_BYTES=2097152",
+                                fg="yellow",
+                            )
+                else:
+                    parse_state["last_done"] = done
+                    parse_state["frozen_since"] = 0.0
+                    parse_state["stall_warned"] = False
+                return
             if event == "parse_progress":
                 indexed = int(payload.get("indexed", 0))
                 total = int(payload.get("total", 0))
                 parse_state["indexed"] = indexed
                 parse_state["total"] = total
+                # Reset stall tracker on actual progress
+                if indexed != parse_state["last_done"]:
+                    parse_state["last_done"] = indexed
+                    parse_state["frozen_since"] = 0.0
+                    parse_state["stall_warned"] = False
                 if total == 0:
                     return
                 if indexed == total or (now - parse_state["last_ts"]) >= 0.2:
@@ -192,6 +246,21 @@ def _index_shard_group(
                 with output_lock:
                     _phase(f"{prefix}Tracing calls...", "starting...")
                 return
+            if event == "resolve_calls_heartbeat":
+                # Fires every 2 s from a daemon thread so the spinner stays
+                # alive even when the resolver produces no new edges.
+                scanned = int(payload.get("scanned", 0))
+                edges   = int(payload.get("edges", 0))
+                elapsed_s = float(payload.get("elapsed", 0.0))
+                if not parallel:
+                    click.echo(
+                        f"\r{_spinner_char()} {prefix}Tracing calls...   "
+                        f"{edges:>6} resolved / {scanned} scanned  {elapsed_s:.1f}s  ",
+                        nl=False,
+                    )
+                    call_state["shown"] = True
+                call_state["last_ts"] = now
+                return
             if event == "resolve_calls_progress":
                 call_state["count"] = int(payload.get("calls_resolved", 0))
                 if (now - call_state["last_ts"]) >= 0.25:
@@ -345,6 +414,37 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
     # For single-project analysis this is transparent — shard() always
     # returns a GraphStore pointing to the correct shard path.
     sg = ShardedGraphStore(read_only=False)
+
+    # ── SIGINT handler: flush partial index on Ctrl+C ────────────────────
+    # The handler captures `sg` by closure.  On interrupt it snapshots all
+    # open shards so `codespine stats` and MCP see the partial result, then
+    # calls os._exit(130) to bypass Python cleanup (safe for CLI process).
+    # A second Ctrl+C hard-exits immediately.
+    _sigint_pressed: list[bool] = [False]
+    _old_sigint_handler = signal.getsignal(signal.SIGINT)
+
+    def _sigint_flush(signum: int, frame: object) -> None:  # noqa: ARG001
+        if _sigint_pressed[0]:
+            os._exit(130)
+        _sigint_pressed[0] = True
+        # Restore default handler so a second Ctrl+C exits immediately.
+        signal.signal(signal.SIGINT, signal.default_int_handler)
+        click.secho(
+            "\n\n⚠  Interrupted — flushing partial index to read replica…",
+            fg="yellow",
+        )
+        try:
+            sg.snapshot_all(background=False)
+            click.secho(
+                "✓ Partial index saved. Run 'codespine stats' to see what was indexed.",
+                fg="yellow",
+            )
+        except Exception:  # noqa: BLE001
+            pass
+        os._exit(130)
+
+    signal.signal(signal.SIGINT, _sigint_flush)
+
     # The indexer is initialised per-module below with the right shard store.
     # We keep a single ShardedGraphStore to fan-out cross-module linking later.
 
@@ -537,21 +637,28 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
 
         _phase("Analyzing git history...", "skipped (large repo; rerun with --deep)")
 
-    vector_count = root_shard_store.query_records(
+    # Summary queries are best-effort: a translator miss or a transient
+    # DB error must never throw away a successful index.
+    def _safe_count(query: str) -> int:
+        try:
+            rows = root_shard_store.query_records(query)
+            return int(rows[0]["count"]) if rows else 0
+        except Exception as exc:  # noqa: BLE001 - summary stats are non-critical
+            click.secho(f"   (summary stat unavailable: {exc})", fg="yellow")
+            return 0
+
+    embeddings_generated = last_result.embeddings_generated if last_result else 0
+    vectors_stored = _safe_count(
         """
         MATCH (s:Symbol)
         WHERE s.embedding IS NOT NULL
         RETURN count(s) as count
         """
-    )
-    embeddings_generated = last_result.embeddings_generated if last_result else 0
-    vectors_stored = int(vector_count[0]["count"]) if vector_count else embeddings_generated
+    ) or embeddings_generated
     _phase("Generating embeddings...", f"{vectors_stored} vectors stored")
 
-    symbol_count = root_shard_store.query_records("MATCH (s:Symbol) RETURN count(s) as count")
-    edge_count = root_shard_store.query_records("MATCH ()-[r]->() RETURN count(r) as count")
-    symbols = int(symbol_count[0]["count"]) if symbol_count else 0
-    edges = int(edge_count[0]["count"]) if edge_count else 0
+    symbols = _safe_count("MATCH (s:Symbol) RETURN count(s) as count")
+    edges = _safe_count("MATCH ()-[r]->() RETURN count(r) as count")
     elapsed = time.perf_counter() - started
 
     if not embed:
@@ -587,6 +694,9 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
     sg.snapshot_all(background=False)
     _finish_phase(snap_label, "MCP will reload automatically")
 
+    # Restore original SIGINT handler now that we've finished cleanly.
+    signal.signal(signal.SIGINT, _old_sigint_handler)
+
 
 @main.command()
 @click.argument("query")
@@ -734,15 +844,27 @@ def stats(as_json: bool, show_shards: bool) -> None:
         click.secho("No projects indexed yet. Run 'codespine analyse <path>'.", fg="yellow")
         return
 
+    def _stat_count(store, query: str, params: dict) -> int:
+        """Run a stats count query — returns 0 on any failure."""
+        try:
+            rows = store.query_records(query, params)
+            return int(rows[0]["n"]) if rows else 0
+        except Exception as exc:  # noqa: BLE001
+            click.secho(f"   (stat unavailable: {exc})", fg="yellow")
+            return 0
+
     rows = []
     for p in all_projects_meta:
         pid = p["id"]
         # Route each query to the project's owning shard.
         ps = _project_store(pid)
-        files = ps.query_records(
-            "MATCH (f:File) WHERE f.project_id = $pid RETURN count(f) as n", {"pid": pid}
+        n_files = _stat_count(
+            ps,
+            "MATCH (f:File) WHERE f.project_id = $pid RETURN count(f) as n",
+            {"pid": pid},
         )
-        classes = ps.query_records(
+        n_classes = _stat_count(
+            ps,
             """
             MATCH (f:File) WHERE f.project_id = $pid
             WITH f
@@ -751,7 +873,8 @@ def stats(as_json: bool, show_shards: bool) -> None:
             """,
             {"pid": pid},
         )
-        methods = ps.query_records(
+        n_methods = _stat_count(
+            ps,
             """
             MATCH (f:File) WHERE f.project_id = $pid
             WITH f
@@ -762,7 +885,8 @@ def stats(as_json: bool, show_shards: bool) -> None:
             """,
             {"pid": pid},
         )
-        calls = ps.query_records(
+        n_calls = _stat_count(
+            ps,
             """
             MATCH (f:File) WHERE f.project_id = $pid
             WITH f
@@ -773,7 +897,8 @@ def stats(as_json: bool, show_shards: bool) -> None:
             """,
             {"pid": pid},
         )
-        emb = ps.query_records(
+        n_emb = _stat_count(
+            ps,
             """
             MATCH (f:File) WHERE f.project_id = $pid
             WITH f
@@ -786,11 +911,11 @@ def stats(as_json: bool, show_shards: bool) -> None:
             "project": pid,
             "path": p["path"],
             "shard": sg.router.shard_for(pid),
-            "files": files[0]["n"] if files else 0,
-            "classes": classes[0]["n"] if classes else 0,
-            "methods": methods[0]["n"] if methods else 0,
-            "calls_out": calls[0]["n"] if calls else 0,
-            "embeddings": emb[0]["n"] if emb else 0,
+            "files": n_files,
+            "classes": n_classes,
+            "methods": n_methods,
+            "calls_out": n_calls,
+            "embeddings": n_emb,
         })
 
     if as_json: