codespine 1.0.7__tar.gz → 1.0.8__tar.gz

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

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

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

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

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

@@ -145,6 +145,10 @@ def _index_shard_group(
         }
         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()
@@ -237,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...")
@@ -309,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()
 

{codespine-1.0.7 → codespine-1.0.8}/codespine/indexer/engine.py

@@ -392,227 +392,299 @@ class JavaIndexer:
                 _parse_hb_stop.set()
                 _parse_hb_thread.join(timeout=3.0)
 
-        # ── Chunked DB writes ─────────────────────────────────────────────────
-        if full:
-            self.store.clear_project(project_id)
-        elif deleted_file_ids:
-            for delete_chunk in self._chunked(deleted_file_ids, file_batch_size):
-                with self.store.transaction():
-                    for fid in delete_chunk:
-                        self.store.clear_file(fid)
-                self.store._recycle_conn()
-
-        # Clean up stale project entries that point to the same path under a
-        # different ID (e.g. re-indexing "vision-server" directly after it was
-        # previously indexed as "vision::vision-server" from a workspace root).
-        try:
-            stale = self.store.query_records(
-                "MATCH (p:Project) WHERE p.path = $path AND p.id <> $pid RETURN p.id as id",
-                {"path": root_path, "pid": project_id},
-            )
-            for old in stale:
-                self.store.clear_project(old["id"])
-        except Exception:
-            pass  # best-effort cleanup
+        # ── DB-write heartbeat thread ─────────────────────────────────────────
+        # The DB write phase can be silent for many seconds on large repos:
+        # clearing stale rows, committing files/classes/methods/symbols, and
+        # recycling DuckDB connections all happen before call tracing starts.
+        # Keep emitting progress so the CLI never appears frozen after parsing.
+        _db_done_holder: list[int] = [0]
+        _db_classes_holder: list[int] = [0]
+        _db_methods_holder: list[int] = [0]
+        _db_phase_holder: list[str] = ["preparing"]
+        _db_hb_stop = threading.Event()
+        _db_start = time.perf_counter()
+        _db_total = len(parse_results)
+
+        def _db_heartbeat_worker() -> None:
+            while not _db_hb_stop.wait(_PARSE_HEARTBEAT_PERIOD):
+                self._emit(
+                    progress,
+                    "db_write_heartbeat",
+                    done=_db_done_holder[0],
+                    total=_db_total,
+                    classes=_db_classes_holder[0],
+                    methods=_db_methods_holder[0],
+                    phase=_db_phase_holder[0],
+                    elapsed=time.perf_counter() - _db_start,
+                )
 
-        self.store.upsert_project(project_id, root_path)
+        _db_hb_thread = threading.Thread(
+            target=_db_heartbeat_worker, daemon=True, name="codespine-db-heartbeat"
+        )
+        _db_hb_thread.start()
+        self._emit(
+            progress,
+            "db_write_start",
+            total=_db_total,
+            deleted_files=len(deleted_file_ids),
+        )
 
-        for parse_chunk in self._chunked(parse_results, file_batch_size):
-            file_rows: list[dict] = []
-            class_rows: list[dict] = []
-            method_rows: list[dict] = []
-            symbol_rows: list[dict] = []
+        try:
+            # ── Chunked DB writes ─────────────────────────────────────────────
+            _db_phase_holder[0] = "clearing"
+            if full:
+                self.store.clear_project(project_id)
+            elif deleted_file_ids:
+                for delete_chunk in self._chunked(deleted_file_ids, file_batch_size):
+                    with self.store.transaction():
+                        for fid in delete_chunk:
+                            self.store.clear_file(fid)
+                    self.store._recycle_conn()
 
-            for pr in parse_chunk:
-                # Skipped files (oversized, timeout) carry parsed=None.
-                # Still count as indexed for accurate reporting, but skip
-                # class/method/symbol extraction.
-                if pr.get("parsed") is None:
-                    files_indexed += 1
-                    continue
-                file_path = pr["file_path"]
-                parsed = pr["parsed"]
-                f_id = pr["f_id"]
-                file_digest = pr["digest"]
-                is_test = pr["is_test"]
-                scope = pr["scope"]
-                source = pr["source"]
-
-                file_rows.append(
-                    {
-                        "id": f_id,
-                        "path": file_path,
-                        "project_id": project_id,
-                        "is_test": is_test,
-                        "hash": file_digest,
-                    }
+            # Clean up stale project entries that point to the same path under a
+            # different ID (e.g. re-indexing "vision-server" directly after it was
+            # previously indexed as "vision::vision-server" from a workspace root).
+            _db_phase_holder[0] = "preparing"
+            try:
+                stale = self.store.query_records(
+                    "MATCH (p:Project) WHERE p.path = $path AND p.id <> $pid RETURN p.id as id",
+                    {"path": root_path, "pid": project_id},
                 )
-                self._update_meta_cache_entry(meta_cache, f_id, file_path, file_digest, len(source), imports=parsed.imports)
-
-                for cls in parsed.classes:
-                    c_id = class_id(cls.fqcn, scope)
-                    class_rows.append(
-                        {
-                            "id": c_id,
-                            "fqcn": cls.fqcn,
-                            "name": cls.name,
-                            "package": cls.package,
-                            "file_id": f_id,
-                        }
-                    )
-                    class_catalog.setdefault(cls.name, [])
-                    if cls.fqcn not in class_catalog[cls.name]:
-                        class_catalog[cls.name].append(cls.fqcn)
-                    fqcn_to_class_ids.setdefault(cls.fqcn, [])
-                    if c_id not in fqcn_to_class_ids[cls.fqcn]:
-                        fqcn_to_class_ids[cls.fqcn].append(c_id)
-                    class_meta[c_id] = {
-                        "id": c_id,
-                        "fqcn": cls.fqcn,
-                        "package": parsed.package,
-                        "imports": parsed.imports,
-                        "extends": cls.extends,
-                        "interfaces": cls.interfaces,
-                        "annotations": cls.annotations,
-                        "scope": scope,
-                    }
-                    class_methods.setdefault(c_id, {})
-
-                    cls_symbol_id = symbol_id("class", cls.fqcn, scope)
-                    symbol_rows.append(
+                for old in stale:
+                    self.store.clear_project(old["id"])
+            except Exception:
+                pass  # best-effort cleanup
+
+            self.store.upsert_project(project_id, root_path)
+
+            _db_phase_holder[0] = "building rows"
+            for parse_chunk in self._chunked(parse_results, file_batch_size):
+                file_rows: list[dict] = []
+                class_rows: list[dict] = []
+                method_rows: list[dict] = []
+                symbol_rows: list[dict] = []
+
+                for pr in parse_chunk:
+                    # Skipped files (oversized, timeout) carry parsed=None.
+                    # Still count as indexed for accurate reporting, but skip
+                    # class/method/symbol extraction.
+                    if pr.get("parsed") is None:
+                        files_indexed += 1
+                        _db_done_holder[0] = files_indexed
+                        continue
+                    file_path = pr["file_path"]
+                    parsed = pr["parsed"]
+                    f_id = pr["f_id"]
+                    file_digest = pr["digest"]
+                    is_test = pr["is_test"]
+                    scope = pr["scope"]
+                    source = pr["source"]
+
+                    file_rows.append(
                         {
-                            "id": cls_symbol_id,
-                            "kind": "class",
-                            "name": cls.name,
-                            "fqname": cls.fqcn,
-                            "file_id": f_id,
-                            "line": cls.line,
-                            "col": cls.col,
-                            "embedding": embed_text(f"class {cls.fqcn}") if embed else None,
+                            "id": f_id,
+                            "path": file_path,
+                            "project_id": project_id,
+                            "is_test": is_test,
+                            "hash": file_digest,
                         }
                     )
-                    classes_indexed += 1
-
-                    # Collect DI metadata for the resolver pass.
-                    di_cls_entry: dict = {
-                        "id": c_id,
-                        "fqcn": cls.fqcn,
-                        "name": cls.name,
-                        "package": cls.package,
-                        "annotations": cls.annotations,
-                        "injected_fields": [
-                            {
-                                "name": f.name,
-                                "type_name": f.type_name,
-                                "injection_annotation": f.injection_annotation,
-                                "qualifier": f.qualifier,
-                            }
-                            for f in cls.fields
-                            if f.injection_annotation
-                        ],
-                        "methods_with_provides": [
-                            {
-                                "name": m.name,
-                                "provides_type": m.provides_type,
-                                "provides_annotation": next(
-                                    (a for a in m.annotations if a.split(".")[-1] in {"Provides", "Bean"}),
-                                    "Provides",
-                                ),
-                            }
-                            for m in cls.methods
-                            if m.provides_type
-                        ],
-                    }
-                    di_classes.append(di_cls_entry)
-
-                    for fld in cls.fields:
-                        fqfield = f"{cls.fqcn}#{fld.name}"
-                        symbol_rows.append(
-                            {
-                                "id": symbol_id("field", fqfield, scope),
-                                "kind": "field",
-                                "name": fld.name,
-                                "fqname": fqfield,
-                                "file_id": f_id,
-                                "line": fld.line,
-                                "col": fld.col,
-                                "embedding": embed_text(f"field {fqfield} {fld.type_name}") if embed else None,
-                            }
-                        )
+                    self._update_meta_cache_entry(meta_cache, f_id, file_path, file_digest, len(source), imports=parsed.imports)
 
-                    for method in cls.methods:
-                        m_id = method_id(cls.fqcn, method.signature, scope)
-                        method_rows.append(
+                    for cls in parsed.classes:
+                        c_id = class_id(cls.fqcn, scope)
+                        class_rows.append(
                             {
-                                "id": m_id,
-                                "class_id": c_id,
-                                "name": method.name,
-                                "signature": method.signature,
-                                "return_type": method.return_type,
-                                "modifiers": method.modifiers + [f"@{a}" for a in method.annotations],
-                                "is_constructor": method.name == cls.name,
-                                "is_test": is_test,
+                                "id": c_id,
+                                "fqcn": cls.fqcn,
+                                "name": cls.name,
+                                "package": cls.package,
+                                "file_id": f_id,
                             }
                         )
+                        class_catalog.setdefault(cls.name, [])
+                        if cls.fqcn not in class_catalog[cls.name]:
+                            class_catalog[cls.name].append(cls.fqcn)
+                        fqcn_to_class_ids.setdefault(cls.fqcn, [])
+                        if c_id not in fqcn_to_class_ids[cls.fqcn]:
+                            fqcn_to_class_ids[cls.fqcn].append(c_id)
+                        class_meta[c_id] = {
+                            "id": c_id,
+                            "fqcn": cls.fqcn,
+                            "package": parsed.package,
+                            "imports": parsed.imports,
+                            "extends": cls.extends,
+                            "interfaces": cls.interfaces,
+                            "annotations": cls.annotations,
+                            "scope": scope,
+                        }
+                        class_methods.setdefault(c_id, {})
 
-                        fqname = f"{cls.fqcn}#{method.signature}"
+                        cls_symbol_id = symbol_id("class", cls.fqcn, scope)
                         symbol_rows.append(
                             {
-                                "id": symbol_id("method", fqname, scope),
-                                "kind": "method",
-                                "name": method.name,
-                                "fqname": fqname,
+                                "id": cls_symbol_id,
+                                "kind": "class",
+                                "name": cls.name,
+                                "fqname": cls.fqcn,
                                 "file_id": f_id,
-                                "line": method.line,
-                                "col": method.col,
-                                "embedding": embed_text(f"method {fqname} returns {method.return_type}") if embed else None,
+                                "line": cls.line,
+                                "col": cls.col,
+                                "embedding": embed_text(f"class {cls.fqcn}") if embed else None,
                             }
                         )
-                        methods_indexed += 1
-
-                        method_catalog[m_id] = {
-                            "signature": method.signature,
-                            "name": method.name,
-                            "param_count": len(method.parameter_types),
-                            "class_fqcn": cls.fqcn,
-                            "class_id": c_id,
-                        }
-                        method_calls[m_id] = method.calls
-                        method_context[m_id] = {
-                            "class_id": c_id,
-                            "class_fqcn": cls.fqcn,
-                            "local_types": method.local_types,
-                            "field_types": cls.field_types,
-                            "imports": parsed.imports,
-                            "package": parsed.package,
+                        classes_indexed += 1
+                        _db_classes_holder[0] = classes_indexed
+
+                        # Collect DI metadata for the resolver pass.
+                        di_cls_entry: dict = {
+                            "id": c_id,
+                            "fqcn": cls.fqcn,
+                            "name": cls.name,
+                            "package": cls.package,
+                            "annotations": cls.annotations,
+                            "injected_fields": [
+                                {
+                                    "name": f.name,
+                                    "type_name": f.type_name,
+                                    "injection_annotation": f.injection_annotation,
+                                    "qualifier": f.qualifier,
+                                }
+                                for f in cls.fields
+                                if f.injection_annotation
+                            ],
+                            "methods_with_provides": [
+                                {
+                                    "name": m.name,
+                                    "provides_type": m.provides_type,
+                                    "provides_annotation": next(
+                                        (a for a in m.annotations if a.split(".")[-1] in {"Provides", "Bean"}),
+                                        "Provides",
+                                    ),
+                                }
+                                for m in cls.methods
+                                if m.provides_type
+                            ],
                         }
-                        class_methods[c_id][method.signature] = m_id
-                files_indexed += 1
-
-            # For incremental re-indexes clear files in bulk first, then use
-            # CREATE (not MERGE) for all writes — after clear the nodes are
-            # guaranteed absent so we skip the costly existence-check MERGE pays.
-            if not full:
-                for clear_sub in self._chunked([r["id"] for r in file_rows], 100):
-                    with self.store.transaction():
-                        self.store.clear_files_batch(clear_sub)
-                    self.store._recycle_conn()
-            with self.store.transaction():
-                self.store.upsert_files_batch(file_rows)
-            self.store._recycle_conn()
-            with self.store.transaction():
-                self.store.upsert_classes_batch(class_rows)
-            self.store._recycle_conn()
-            _METHOD_SUB_BATCH = 200
-            for method_sub in self._chunked(method_rows, _METHOD_SUB_BATCH):
+                        di_classes.append(di_cls_entry)
+
+                        for fld in cls.fields:
+                            fqfield = f"{cls.fqcn}#{fld.name}"
+                            symbol_rows.append(
+                                {
+                                    "id": symbol_id("field", fqfield, scope),
+                                    "kind": "field",
+                                    "name": fld.name,
+                                    "fqname": fqfield,
+                                    "file_id": f_id,
+                                    "line": fld.line,
+                                    "col": fld.col,
+                                    "embedding": embed_text(f"field {fqfield} {fld.type_name}") if embed else None,
+                                }
+                            )
+
+                        for method in cls.methods:
+                            m_id = method_id(cls.fqcn, method.signature, scope)
+                            method_rows.append(
+                                {
+                                    "id": m_id,
+                                    "class_id": c_id,
+                                    "name": method.name,
+                                    "signature": method.signature,
+                                    "return_type": method.return_type,
+                                    "modifiers": method.modifiers + [f"@{a}" for a in method.annotations],
+                                    "is_constructor": method.name == cls.name,
+                                    "is_test": is_test,
+                                }
+                            )
+
+                            fqname = f"{cls.fqcn}#{method.signature}"
+                            symbol_rows.append(
+                                {
+                                    "id": symbol_id("method", fqname, scope),
+                                    "kind": "method",
+                                    "name": method.name,
+                                    "fqname": fqname,
+                                    "file_id": f_id,
+                                    "line": method.line,
+                                    "col": method.col,
+                                    "embedding": embed_text(f"method {fqname} returns {method.return_type}") if embed else None,
+                                }
+                            )
+                            methods_indexed += 1
+                            _db_methods_holder[0] = methods_indexed
+
+                            method_catalog[m_id] = {
+                                "signature": method.signature,
+                                "name": method.name,
+                                "param_count": len(method.parameter_types),
+                                "class_fqcn": cls.fqcn,
+                                "class_id": c_id,
+                            }
+                            method_calls[m_id] = method.calls
+                            method_context[m_id] = {
+                                "class_id": c_id,
+                                "class_fqcn": cls.fqcn,
+                                "local_types": method.local_types,
+                                "field_types": cls.field_types,
+                                "imports": parsed.imports,
+                                "package": parsed.package,
+                            }
+                            class_methods[c_id][method.signature] = m_id
+                    files_indexed += 1
+                    _db_done_holder[0] = files_indexed
+
+                # For incremental re-indexes clear files in bulk first, then use
+                # CREATE (not MERGE) for all writes — after clear the nodes are
+                # guaranteed absent so we skip the costly existence-check MERGE pays.
+                _db_phase_holder[0] = "clearing files"
+                if not full:
+                    for clear_sub in self._chunked([r["id"] for r in file_rows], 100):
+                        with self.store.transaction():
+                            self.store.clear_files_batch(clear_sub)
+                        self.store._recycle_conn()
+                _db_phase_holder[0] = "writing files"
                 with self.store.transaction():
-                    self.store.upsert_methods_batch(method_sub)
+                    self.store.upsert_files_batch(file_rows)
                 self.store._recycle_conn()
-            _SYMBOL_SUB_BATCH = 200
-            for symbol_sub in self._chunked(symbol_rows, _SYMBOL_SUB_BATCH):
+                _db_phase_holder[0] = "writing classes"
                 with self.store.transaction():
-                    self.store.upsert_symbols_batch(symbol_sub)
+                    self.store.upsert_classes_batch(class_rows)
                 self.store._recycle_conn()
+                _METHOD_SUB_BATCH = 200
+                _db_phase_holder[0] = "writing methods"
+                for method_sub in self._chunked(method_rows, _METHOD_SUB_BATCH):
+                    with self.store.transaction():
+                        self.store.upsert_methods_batch(method_sub)
+                    self.store._recycle_conn()
+                _SYMBOL_SUB_BATCH = 200
+                _db_phase_holder[0] = "writing symbols"
+                for symbol_sub in self._chunked(symbol_rows, _SYMBOL_SUB_BATCH):
+                    with self.store.transaction():
+                        self.store.upsert_symbols_batch(symbol_sub)
+                    self.store._recycle_conn()
+                self._emit(
+                    progress,
+                    "db_write_progress",
+                    done=files_indexed,
+                    total=_db_total,
+                    classes=classes_indexed,
+                    methods=methods_indexed,
+                    phase=_db_phase_holder[0],
+                )
+                _db_phase_holder[0] = "building rows"
+        finally:
+            _db_hb_stop.set()
+            _db_hb_thread.join(timeout=3.0)
+
+        self._emit(
+            progress,
+            "db_write_done",
+            files_indexed=files_indexed,
+            classes=classes_indexed,
+            methods=methods_indexed,
+            elapsed=time.perf_counter() - _db_start,
+        )
 
         self._emit(progress, "resolve_calls_start")
 

{codespine-1.0.7 → codespine-1.0.8}/codespine.egg-info/PKG-INFO

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

{codespine-1.0.7 → codespine-1.0.8}/pyproject.toml

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

{codespine-1.0.7 → codespine-1.0.8}/tests/test_parse_resilience.py

@@ -192,3 +192,99 @@ def test_parse_loop_skips_none_parsed_in_db_write(tmp_path):
         _ = pr["parsed"].classes
 
     assert files_indexed == 1, "Skipped sentinel should increment files_indexed"
+
+
+# ---------------------------------------------------------------------------
+# Test D: DB-write progress covers the silent post-parse phase
+# ---------------------------------------------------------------------------
+
+
+def test_db_write_heartbeat_emits_until_write_done(tmp_path, monkeypatch):
+    """The post-parse DB write phase must emit start/heartbeat/progress/done
+    events so the CLI does not look frozen before call tracing begins."""
+    import codespine.indexer.engine as eng
+
+    class _Txn:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+    class _SlowStore:
+        def query_records(self, *_args, **_kwargs):
+            return []
+
+        def clear_project(self, *_args, **_kwargs):
+            pass
+
+        def clear_file(self, *_args, **_kwargs):
+            pass
+
+        def upsert_project(self, *_args, **_kwargs):
+            pass
+
+        def transaction(self):
+            return _Txn()
+
+        def clear_files_batch(self, *_args, **_kwargs):
+            pass
+
+        def upsert_files_batch(self, *_args, **_kwargs):
+            pass
+
+        def upsert_classes_batch(self, *_args, **_kwargs):
+            pass
+
+        def upsert_methods_batch(self, *_args, **_kwargs):
+            time.sleep(0.03)
+
+        def upsert_symbols_batch(self, *_args, **_kwargs):
+            time.sleep(0.03)
+
+        def add_calls_batch(self, *_args, **_kwargs):
+            pass
+
+        def add_references_batch(self, *_args, **_kwargs):
+            pass
+
+        def add_injections_batch(self, *_args, **_kwargs):
+            pass
+
+        def add_interface_bindings_batch(self, *_args, **_kwargs):
+            pass
+
+        def _recycle_conn(self):
+            pass
+
+    monkeypatch.setattr(eng, "_PARSE_HEARTBEAT_PERIOD", 0.005)
+    monkeypatch.setattr(eng, "resolve_calls", lambda *_args, **_kwargs: iter(()))
+
+    java_file = tmp_path / "src/main/java/com/example/Foo.java"
+    java_file.parent.mkdir(parents=True)
+    java_file.write_text(
+        "package com.example; public class Foo { void run() {} }\n",
+        encoding="utf-8",
+    )
+
+    events: list[tuple[str, dict]] = []
+    indexer = eng.JavaIndexer(_SlowStore())
+    indexer.index_project(
+        str(tmp_path),
+        full=True,
+        progress=lambda event, payload: events.append((event, dict(payload))),
+        project_id="proj",
+        embed=False,
+    )
+
+    names = [event for event, _payload in events]
+    assert "db_write_start" in names
+    assert "db_write_heartbeat" in names
+    assert "db_write_progress" in names
+    assert "db_write_done" in names
+    assert names.index("db_write_done") < names.index("resolve_calls_start")
+
+    done_payload = next(payload for event, payload in events if event == "db_write_done")
+    assert done_payload["files_indexed"] == 1
+    assert done_payload["classes"] == 1
+    assert done_payload["methods"] == 1