codespine 1.0.6__tar.gz → 1.0.8__tar.gz

{codespine-1.0.6 → codespine-1.0.8}/PKG-INFO

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

{codespine-1.0.6 → codespine-1.0.8}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "1.0.6"
+__version__ = "1.0.8"

{codespine-1.0.6 → codespine-1.0.8}/codespine/cli.py

@@ -137,10 +137,18 @@ 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}
+        db_state: dict = {
+            "shown": False, "done": 0, "total": 0, "last_ts": 0.0,
+            "started_at": 0.0,
+        }
 
         def _progress(event: str, payload: dict) -> None:
             now = time.perf_counter()
@@ -160,11 +168,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:
@@ -183,11 +241,101 @@ def _index_shard_group(
                     parse_state["shown"] = True
                     parse_state["last_ts"] = now
                 return
-            if event in ("resolve_calls_start",):
+            if event == "db_write_start":
                 if parse_state["shown"]:
                     with output_lock:
                         click.echo()
                     parse_state["shown"] = False
+                total = int(payload.get("total", 0))
+                deleted = int(payload.get("deleted_files", 0))
+                db_state["done"] = 0
+                db_state["total"] = total
+                db_state["started_at"] = now
+                status = f"starting ({total} files"
+                if deleted:
+                    status += f", {deleted} deleted"
+                status += ")"
+                with output_lock:
+                    _phase(f"{prefix}Writing index...", status)
+                return
+            if event == "db_write_heartbeat":
+                done = int(payload.get("done", 0))
+                total = int(payload.get("total", 0))
+                classes = int(payload.get("classes", 0))
+                methods = int(payload.get("methods", 0))
+                phase = str(payload.get("phase", "writing"))
+                elapsed_s = float(payload.get("elapsed", 0.0))
+                db_state["done"] = done
+                db_state["total"] = total
+                if not parallel:
+                    click.echo(
+                        f"\r{_spinner_char()} {prefix}Writing index...   "
+                        f"{_bar(done, total)} {done}/{total}  "
+                        f"{classes} classes / {methods} methods  "
+                        f"{phase[:18]:<18} {elapsed_s:.0f}s  ",
+                        nl=False,
+                    )
+                else:
+                    with output_lock:
+                        click.echo(
+                            f"\r{prefix}Writing {done}/{total} "
+                            f"({classes} classes, {methods} methods, {elapsed_s:.0f}s)  ",
+                            nl=False,
+                        )
+                db_state["shown"] = True
+                db_state["last_ts"] = now
+                return
+            if event == "db_write_progress":
+                done = int(payload.get("done", 0))
+                total = int(payload.get("total", 0))
+                classes = int(payload.get("classes", 0))
+                methods = int(payload.get("methods", 0))
+                phase = str(payload.get("phase", "writing"))
+                db_state["done"] = done
+                db_state["total"] = total
+                if total == 0 and done == 0:
+                    return
+                if done == total or (now - db_state["last_ts"]) >= 0.25:
+                    elapsed_s = now - db_state["started_at"]
+                    if not parallel:
+                        click.echo(
+                            f"\r{_spinner_char()} {prefix}Writing index...   "
+                            f"{_bar(done, total)} {done}/{total}  "
+                            f"{classes} classes / {methods} methods  "
+                            f"{phase[:18]:<18} {elapsed_s:.0f}s  ",
+                            nl=False,
+                        )
+                    else:
+                        with output_lock:
+                            click.echo(
+                                f"\r{prefix}Writing {done}/{total} "
+                                f"({classes} classes, {methods} methods, {elapsed_s:.0f}s)  ",
+                                nl=False,
+                            )
+                    db_state["shown"] = True
+                    db_state["last_ts"] = now
+                return
+            if event == "db_write_done":
+                if db_state["shown"]:
+                    with output_lock:
+                        click.echo()
+                db_state["shown"] = False
+                files = int(payload.get("files_indexed", db_state["done"]))
+                classes = int(payload.get("classes", 0))
+                methods = int(payload.get("methods", 0))
+                elapsed_s = float(payload.get("elapsed", 0.0))
+                with output_lock:
+                    _phase(
+                        f"{prefix}Writing index...",
+                        f"{files} files, {classes} classes, {methods} methods  ({elapsed_s:.1f}s)",
+                    )
+                return
+            if event in ("resolve_calls_start",):
+                if parse_state["shown"] or db_state["shown"]:
+                    with output_lock:
+                        click.echo()
+                    parse_state["shown"] = False
+                    db_state["shown"] = False
                 call_state["started_at"] = now
                 with output_lock:
                     _phase(f"{prefix}Tracing calls...", "starting...")
@@ -255,7 +403,7 @@ def _index_shard_group(
         total_files += result.files_found
 
         # Flush any dangling progress line.
-        if parse_state["shown"]:
+        if parse_state["shown"] or db_state["shown"]:
             with output_lock:
                 click.echo()