codespine 1.0.2__tar.gz → 1.0.4__tar.gz

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

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

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

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

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

@@ -22,7 +22,6 @@ from codespine.analysis.deadcode import detect_dead_code
 from codespine.analysis.flow import trace_execution_flows
 from codespine.analysis.impact import analyze_impact
 from codespine.config import SETTINGS
-from codespine.db.store import GraphStore
 from codespine.sharding import ShardedGraphStore, ShardRouter
 from codespine.diff.branch_diff import compare_branches
 from codespine.indexer.engine import JavaIndexer
@@ -56,6 +55,17 @@ def _current_repo_path() -> str:
     return os.getcwd()
 
 
+def _open_store(read_only: bool = True) -> ShardedGraphStore:
+    """Open the sharded store with the backend configured in SETTINGS.
+
+    Every CLI command must go through this helper so the correct backend
+    (DuckDB or KùzuDB) is selected transparently.  Direct ``GraphStore(...)``
+    calls were tied to the legacy single-DB KùzuDB layout and will fail on
+    any machine running the default DuckDB backend with sharded storage.
+    """
+    return ShardedGraphStore(read_only=read_only)
+
+
 def _db_size_bytes(path: str) -> int:
     if os.path.isfile(path):
         return os.path.getsize(path)
@@ -584,7 +594,7 @@ def analyse(path: str, full: bool, deep: bool, incremental_deep: bool, embed: bo
 @click.option("--json", "as_json", is_flag=True)
 def search(query: str, k: int, as_json: bool) -> None:
     """Hybrid search (BM25 + vector + fuzzy + RRF)."""
-    store = GraphStore(read_only=True)
+    store = _open_store(read_only=True)
     results = hybrid_search(store, query, k=k)
     _echo_json(results, as_json)
 
@@ -595,7 +605,7 @@ def search(query: str, k: int, as_json: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def context(query: str, max_depth: int, as_json: bool) -> None:
     """Get one-shot symbol context: search + impact + community + flows."""
-    store = GraphStore(read_only=True)
+    store = _open_store(read_only=True)
     result = build_symbol_context(store, query, max_depth=max_depth)
     _echo_json(result, as_json)
 
@@ -606,7 +616,7 @@ def context(query: str, max_depth: int, as_json: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def impact(symbol: str, max_depth: int, as_json: bool) -> None:
     """Impact analysis grouped by depth with confidence scores."""
-    store = GraphStore(read_only=True)
+    store = _open_store(read_only=True)
     result = analyze_impact(store, symbol, max_depth=max_depth)
     _echo_json(result, as_json)
 
@@ -616,7 +626,7 @@ def impact(symbol: str, max_depth: int, as_json: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def deadcode(limit: int, as_json: bool) -> None:
     """Detect dead code candidates with Java-aware exemptions."""
-    store = GraphStore(read_only=True)
+    store = _open_store(read_only=True)
     result = detect_dead_code(store, limit=limit)
     _echo_json(result, as_json)
 
@@ -627,7 +637,7 @@ def deadcode(limit: int, as_json: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def flow(entry_symbol: str | None, max_depth: int, as_json: bool) -> None:
     """Trace execution flows from detected entry points."""
-    store = GraphStore(read_only=True)
+    store = _open_store(read_only=True)
     result = trace_execution_flows(store, entry_symbol=entry_symbol, max_depth=max_depth)
     _echo_json(result, as_json)
 
@@ -637,7 +647,7 @@ def flow(entry_symbol: str | None, max_depth: int, as_json: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def community(symbol: str | None, as_json: bool) -> None:
     """Detect communities or lookup community for a symbol."""
-    store = GraphStore(read_only=False)
+    store = _open_store(read_only=False)
     detect_communities(store)
     if symbol:
         _echo_json(symbol_community(store, symbol), as_json)
@@ -655,7 +665,7 @@ def community(symbol: str | None, as_json: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def coupling(days: int, min_strength: float, min_cochanges: int, as_json: bool) -> None:
     """Compute and query git change coupling."""
-    store = GraphStore(read_only=False)
+    store = _open_store(read_only=False)
     project = store.query_records("MATCH (p:Project) RETURN p.id as id LIMIT 1")
     project_id = project[0]["id"] if project else os.path.basename(os.getcwd())
     compute_coupling(store, os.getcwd(), project_id, days=days, min_strength=min_strength, min_cochanges=min_cochanges)
@@ -681,7 +691,7 @@ def coupling(days: int, min_strength: float, min_cochanges: int, as_json: bool)
 @click.option("--promote-on-commit/--no-promote-on-commit", default=True, show_default=True)
 def watch(path: str, global_interval: int, overlay_debounce_ms: int, promote_on_commit: bool) -> None:
     """Live re-indexing and periodic global analysis refresh."""
-    store = GraphStore(read_only=False)
+    store = _open_store(read_only=False)
     run_watch_mode(
         store,
         os.path.abspath(path),
@@ -720,12 +730,12 @@ def stats(as_json: bool, show_shards: bool) -> None:
     def _project_store(pid: str):
         return sg.shard(pid)
 
-    if not projects:
+    if not all_projects_meta:
         click.secho("No projects indexed yet. Run 'codespine analyse <path>'.", fg="yellow")
         return
 
     rows = []
-    for p in projects:
+    for p in all_projects_meta:
         pid = p["id"]
         # Route each query to the project's owning shard.
         ps = _project_store(pid)
@@ -813,7 +823,7 @@ def stats(as_json: bool, show_shards: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def list_projects(as_json: bool) -> None:
     """List indexed projects."""
-    store = GraphStore(read_only=True)
+    store = _open_store(read_only=True)
     projects = store.query_records("MATCH (p:Project) RETURN p.id as id, p.path as path, p.language as language ORDER BY p.id")
     _echo_json(projects, as_json)
 
@@ -837,7 +847,7 @@ def status(as_json: bool) -> None:
                 pid = int(f.read().strip())
         except Exception:
             pid = None
-    store = GraphStore(read_only=True)
+    store = _open_store(read_only=True)
     overlay = get_overlay_status(store)
 
     # Check for stale PID file
@@ -875,7 +885,7 @@ def status(as_json: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def overlay_status_cmd(project: str | None, as_json: bool) -> None:
     """Show dirty overlay status by project/module."""
-    store = GraphStore(read_only=True)
+    store = _open_store(read_only=True)
     _echo_json(get_overlay_status(store, project=project), as_json)
 
 
@@ -884,7 +894,7 @@ def overlay_status_cmd(project: str | None, as_json: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def overlay_clear_cmd(project: str | None, as_json: bool) -> None:
     """Clear dirty overlay data without touching the committed base index."""
-    store = GraphStore(read_only=False)
+    store = _open_store(read_only=False)
     result = {"cleared": clear_overlay(store, project=project)}
     _echo_json(result, as_json)
 
@@ -894,7 +904,7 @@ def overlay_clear_cmd(project: str | None, as_json: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def overlay_promote_cmd(project: str | None, as_json: bool) -> None:
     """Promote dirty overlay changes into the committed base index now."""
-    store = GraphStore(read_only=False)
+    store = _open_store(read_only=False)
     result = {"promoted": promote_overlay(store, project=project, require_head_change=False)}
     _echo_json(result, as_json)
 
@@ -904,7 +914,7 @@ def overlay_promote_cmd(project: str | None, as_json: bool) -> None:
 @click.option("--json", "as_json", is_flag=True)
 def cypher(query: str, as_json: bool) -> None:
     """Run a raw Cypher query against the graph DB."""
-    store = GraphStore(read_only=True)
+    store = _open_store(read_only=True)
     try:
         result = store.query_records(query)
     except Exception as exc:
@@ -948,7 +958,7 @@ def clear_project_cmd(project_id: str, allow_running: bool) -> None:
         click.secho("Stop MCP first ('codespine stop') to modify index.", fg="yellow")
         return
     try:
-        store = GraphStore(read_only=False)
+        store = _open_store(read_only=False)
         recs = store.query_records(
             "MATCH (p:Project) WHERE p.id = $pid RETURN p.id as id, p.path as path",
             {"pid": project_id},
@@ -974,7 +984,7 @@ def clear_project_cmd(project_id: str, allow_running: bool) -> None:
         except OSError:
             pass
     # Update the read replica so read-only callers (stats, MCP) see the change.
-    GraphStore.snapshot_to_read_replica()
+    store.snapshot_to_read_replica()
     click.secho(f"Cleared project '{project_id}' (was at {project_path}).", fg="green")
 
 
@@ -991,12 +1001,12 @@ def clear_index_cmd(allow_running: bool) -> None:
         click.secho("Stop MCP first ('codespine stop') to modify index.", fg="yellow")
         return
     try:
-        store = GraphStore(read_only=False)
+        store = _open_store(read_only=False)
         projects = store.query_records("MATCH (p:Project) RETURN p.id as id")
     except Exception:
         # DB is corrupted — can't even open it.  Force-delete everything.
         click.secho("DB is corrupted. Running force-reset instead...", fg="yellow")
-        removed = GraphStore.force_delete_all_data()
+        removed = ShardedGraphStore(read_only=False).force_delete_all_data()
         click.secho(f"Force-reset complete. {len(removed)} path(s) removed. Index is now empty.", fg="green")
         return
     try:
@@ -1004,7 +1014,7 @@ def clear_index_cmd(allow_running: bool) -> None:
     except Exception as exc:
         # rebuild_empty_db failed even with fallbacks — force-delete.
         click.secho(f"rebuild failed ({exc}). Running force-reset...", fg="yellow")
-        GraphStore.force_delete_all_data()
+        store.force_delete_all_data()
         click.secho("Force-reset complete. Index is now empty.", fg="green")
         return
     store.overlay_store.clear_all()
@@ -1017,7 +1027,7 @@ def clear_index_cmd(allow_running: bool) -> None:
                 pass
     # Publish an empty read replica so that read-only callers (stats, MCP)
     # immediately see the cleared state and the MCP daemon hot-reloads.
-    GraphStore.snapshot_to_read_replica()
+    store.snapshot_to_read_replica()
     click.secho(f"Cleared {len(projects)} project(s). Index is now empty.", fg="green")
 
 
@@ -1038,7 +1048,7 @@ def force_reset_cmd(force: bool) -> None:
     ):
         click.echo("Aborted.")
         return
-    removed = GraphStore.force_delete_all_data()
+    removed = ShardedGraphStore(read_only=False).force_delete_all_data()
     if removed:
         for p in removed:
             click.echo(f"  removed: {p}")
@@ -1177,7 +1187,7 @@ def install_model() -> None:
 @main.command("run-mcp", hidden=True)
 def run_mcp() -> None:
     """Run MCP server in stdio mode."""
-    store = GraphStore(read_only=True)
+    store = _open_store(read_only=True)
     mcp = build_mcp_server(store, repo_path_provider=_current_repo_path)
     mcp.run()
 

{codespine-1.0.2 → codespine-1.0.4}/codespine/db/duckdb_store.py

@@ -52,6 +52,49 @@ def _remove_path(path: str) -> None:
         LOGGER.warning("Could not remove %s: %s", path, exc)
 
 
+def _sanitize_db_path(path: str) -> None:
+    """Ensure *path* is either absent or a valid DuckDB database file.
+
+    KùzuDB leaves directory-trees at the same paths DuckDB expects as files,
+    and half-written snapshots can leave zero-byte or corrupt files.  We
+    cheaply probe each path with a read-only DuckDB connect; if that raises
+    any ``IOException``, whatever is there isn't a valid DuckDB database and
+    we delete it so the subsequent real open starts from a clean slate.
+    """
+    if not os.path.exists(path) and not os.path.islink(path):
+        return  # nothing there — nothing to do
+
+    # Any directory is by definition not a DuckDB database file.
+    if os.path.isdir(path) and not os.path.islink(path):
+        LOGGER.info(
+            "Removing non-DuckDB directory at %s (likely legacy KùzuDB layout) — "
+            "re-index with 'codespine analyse' to rebuild.",
+            path,
+        )
+        _remove_path(path)
+        return
+
+    # Regular file — try a throw-away read-only open to verify it's a DB.
+    # IOException  → file exists but is not a valid DuckDB database → remove.
+    # Connection/Catalog/Other exceptions → file is valid DuckDB (possibly
+    # already open by another connection in this process); leave it alone.
+    try:
+        probe = duckdb.connect(path, read_only=True)
+        probe.close()
+    except duckdb.IOException as exc:
+        LOGGER.info(
+            "Removing invalid DB file at %s (%s) — re-index with "
+            "'codespine analyse' to rebuild.",
+            path,
+            exc,
+        )
+        _remove_path(path)
+    except Exception:
+        # File is a valid DuckDB but we can't open it right now (in-use, perms,
+        # etc.) — not our problem to fix here; let the real open surface it.
+        pass
+
+
 # ---------------------------------------------------------------------------
 # Schema DDL
 # ---------------------------------------------------------------------------
@@ -212,46 +255,31 @@ class DuckDBStore:
         from codespine.overlay.store import OverlayStore
         self.overlay_store = OverlayStore()
 
-        # Prefer snapshot for read-only access; fall back to write path.
-        snap_exists = os.path.exists(self._snapshot_path)
-        db_file = self._snapshot_path if read_only and snap_exists else self._db_path
-
         # ----------------------------------------------------------------
-        # Robust open: handle legacy KùzuDB artifacts at the target path.
-        # KùzuDB may leave a directory, a partial file, or a 0-byte sentinel
-        # at the same path DuckDB expects.  Rather than guessing the type,
-        # we attempt to connect and on any IOException we wipe whatever is
-        # there and retry once with a clean slate.
+        # Pre-flight sanitize: KùzuDB may have left directories or partial
+        # files at the paths DuckDB is about to use.  Probe each path with a
+        # throw-away read-only connect — if it fails, whatever is there is
+        # not a valid DuckDB database, so remove it.  This runs BEFORE the
+        # real open so we never hit a mid-fallback failure mode.
         # ----------------------------------------------------------------
-        os.makedirs(os.path.dirname(db_file) or ".", exist_ok=True)
-        for attempt in range(2):
-            # If read-only and the target file doesn't exist, we have nothing
-            # to read — use an in-memory DB so callers get [] instead of crash.
-            if read_only and not os.path.exists(db_file):
-                self._conn = duckdb.connect(":memory:")
-                self._ensure_schema()
-                return
+        os.makedirs(os.path.dirname(self._db_path) or ".", exist_ok=True)
+        for p in (self._db_path, self._snapshot_path):
+            _sanitize_db_path(p)
 
-            try:
-                self._conn: duckdb.DuckDBPyConnection = duckdb.connect(
-                    db_file, read_only=read_only
-                )
-                break
-            except duckdb.IOException as exc:
-                if attempt > 0:
-                    raise  # second attempt also failed — give up
-                LOGGER.info(
-                    "Cannot open DB at %s (%s) — removing stale artifact "
-                    "and starting fresh. Re-index with 'codespine analyse'.",
-                    db_file,
-                    exc,
-                )
-                _remove_path(db_file)
-                # If the bad path was the snapshot, fall back to the write DB.
-                if db_file == self._snapshot_path:
-                    db_file = self._db_path
-                    os.makedirs(os.path.dirname(db_file) or ".", exist_ok=True)
+        # After sanitize, pick the file we actually open.
+        snap_exists = os.path.exists(self._snapshot_path)
+        db_file = self._snapshot_path if read_only and snap_exists else self._db_path
 
+        # Read-only open with nothing on disk → in-memory empty DB so queries
+        # return [] cleanly instead of "database does not exist".
+        if read_only and not os.path.exists(db_file):
+            self._conn = duckdb.connect(":memory:")
+            self._ensure_schema()
+            return
+
+        self._conn: duckdb.DuckDBPyConnection = duckdb.connect(
+            db_file, read_only=read_only
+        )
         if not read_only:
             self._ensure_schema()
 

{codespine-1.0.2 → codespine-1.0.4}/codespine/sharding/store.py

@@ -299,6 +299,27 @@ class ShardedGraphStore:
             removed.extend(store.force_delete_all_data())
         return removed
 
+    def clear_analysis_artifacts(self) -> None:
+        """Fan-out: clear analysis artifacts (communities, flows, dead code) on every shard."""
+        for store in self.all_shards():
+            try:
+                store.clear_analysis_artifacts()
+            except Exception as exc:
+                LOGGER.warning("clear_analysis_artifacts failed on shard: %s", exc)
+
+    def rebuild_empty_db(self) -> None:
+        """Fan-out: rebuild each shard as an empty database."""
+        for store in self.all_shards():
+            try:
+                store.rebuild_empty_db()
+            except Exception as exc:
+                LOGGER.warning("rebuild_empty_db failed on shard: %s", exc)
+
+    def snapshot_to_read_replica(self, background: bool = False) -> bool:
+        """Alias for ``snapshot_all`` — matches GraphStore's API."""
+        self.snapshot_all(background=background)
+        return True
+
     def describe(self) -> dict:
         """Return a human-readable description of the shard topology."""
         shard_info = []

{codespine-1.0.2 → codespine-1.0.4}/codespine.egg-info/PKG-INFO

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

{codespine-1.0.2 → codespine-1.0.4}/pyproject.toml

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

{codespine-1.0.2 → codespine-1.0.4}/tests/test_duckdb_store.py

@@ -446,3 +446,42 @@ def test_corrupt_file_at_db_path_is_replaced(tmp_path: Path):
     store = DuckDBStore(db_path_override=db_path, snapshot_path_override=snap_path)
     rows = store.query_records("SELECT * FROM projects")
     assert rows == []
+
+
+def test_legacy_kuzu_dirs_at_both_paths_are_removed(tmp_path: Path):
+    """Regression: both db and db_read as KùzuDB directories (the exact
+    scenario from the field bug in v1.0.2)."""
+    db_path = str(tmp_path / "db")
+    snap_path = str(tmp_path / "db_read")
+
+    # Simulate KùzuDB directories at BOTH paths
+    for p in (db_path, snap_path):
+        os.makedirs(p)
+        (Path(p) / "catalog.kz").write_bytes(b"\x00" * 64)
+        (Path(p) / "data.kz").write_bytes(b"\x00" * 1024)
+
+    # Read-only open: legacy code would pick snap, fail, fall back to db, fail, raise.
+    # New code pre-sanitizes both paths, then returns an in-memory empty DB.
+    store = DuckDBStore(read_only=True, db_path_override=db_path, snapshot_path_override=snap_path)
+    rows = store.query_records("SELECT * FROM projects")
+    assert rows == []
+    # Both paths should be gone
+    assert not os.path.exists(db_path)
+    assert not os.path.exists(snap_path)
+
+
+def test_sharded_store_stats_flow_with_stale_kuzu_dirs(tmp_path: Path):
+    """Regression: ShardedGraphStore.list_project_metadata() must not crash
+    when every shard path is a stale KùzuDB directory (the failing
+    'codespine stats' scenario)."""
+    shards_dir = tmp_path / "shards"
+    # Pre-create 4 shards with legacy KùzuDB-style directories at both paths
+    for i in range(4):
+        (shards_dir / str(i)).mkdir(parents=True)
+        (shards_dir / str(i) / "db").mkdir()
+        (shards_dir / str(i) / "db" / "catalog.kz").write_bytes(b"\x00" * 32)
+        (shards_dir / str(i) / "db_read").mkdir()
+
+    sg = ShardedGraphStore(read_only=True, shards_dir=str(shards_dir), backend="duckdb")
+    # This is what `codespine stats` does — it must not raise.
+    assert sg.list_project_metadata() == []