codespine 1.0.1__tar.gz → 1.0.3__tar.gz

{codespine-1.0.1 → codespine-1.0.3}/PKG-INFO

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

{codespine-1.0.1 → codespine-1.0.3}/codespine/__init__.py

@@ -1,4 +1,4 @@
 """CodeSpine package."""
 
 __all__ = ["__version__"]
-__version__ = "1.0.1"
+__version__ = "1.0.3"

{codespine-1.0.1 → codespine-1.0.3}/codespine/db/duckdb_store.py

@@ -41,6 +41,60 @@ LOGGER = logging.getLogger(__name__)
 _VECTOR_DIM = SETTINGS.vector_dim  # 384
 
 
+def _remove_path(path: str) -> None:
+    """Remove *path* whether it is a file, symlink, or directory tree."""
+    try:
+        if os.path.isdir(path) and not os.path.islink(path):
+            shutil.rmtree(path)
+        elif os.path.exists(path) or os.path.islink(path):
+            os.remove(path)
+    except OSError as exc:
+        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
 # ---------------------------------------------------------------------------
@@ -201,41 +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
-
         # ----------------------------------------------------------------
-        # Legacy KùzuDB migration guard
-        # KùzuDB stores its database as a *directory*; DuckDB uses a single
-        # file.  When CODESPINE_BACKEND is changed to "duckdb" an existing
-        # KùzuDB shard directory sits at the same path and DuckDB refuses to
-        # open it.  Detect this case, wipe the directory, and start fresh.
+        # 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.
         # ----------------------------------------------------------------
-        for legacy_path in (self._db_path, self._snapshot_path):
-            if os.path.isdir(legacy_path):
-                LOGGER.info(
-                    "Removing legacy KùzuDB directory at %s — "
-                    "re-index with 'codespine analyse' to rebuild.",
-                    legacy_path,
-                )
-                shutil.rmtree(legacy_path)
+        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)
 
-        # Re-evaluate db_file after possible cleanup.
+        # 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
 
-        # When opening read-only and no snapshot exists yet, open the write
-        # DB in read-only mode so callers get an empty-but-valid store rather
-        # than an error.
-        if read_only and not snap_exists and not os.path.exists(self._db_path):
-            # No data at all — open an in-memory DB so queries return [] cleanly.
+        # 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
 
-        os.makedirs(os.path.dirname(db_file) or ".", exist_ok=True)
-        self._conn: duckdb.DuckDBPyConnection = duckdb.connect(db_file, read_only=read_only)
+        self._conn: duckdb.DuckDBPyConnection = duckdb.connect(
+            db_file, read_only=read_only
+        )
         if not read_only:
             self._ensure_schema()
 

{codespine-1.0.1 → codespine-1.0.3}/codespine.egg-info/PKG-INFO

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

{codespine-1.0.1 → codespine-1.0.3}/pyproject.toml

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

{codespine-1.0.1 → codespine-1.0.3}/tests/test_duckdb_store.py

@@ -399,3 +399,50 @@ def test_sharded_duckdb_multi_project_isolation(tmp_path: Path):
     all_ids = {p["id"] for p in sg.list_project_metadata()}
     assert pid_a in all_ids
     assert pid_b in all_ids
+
+
+# ---------------------------------------------------------------------------
+# Legacy KùzuDB artifact recovery
+# ---------------------------------------------------------------------------
+
+
+def test_legacy_kuzu_directory_at_db_path_is_removed(tmp_path: Path):
+    """DuckDBStore auto-removes a KùzuDB directory left at the DB path."""
+    db_path = str(tmp_path / "db")
+    snap_path = str(tmp_path / "db_read")
+
+    # Simulate a KùzuDB directory at the write path
+    os.makedirs(db_path)
+    (Path(db_path) / "nodes.index").write_bytes(b"\x00" * 16)
+
+    store = DuckDBStore(db_path_override=db_path, snapshot_path_override=snap_path)
+    rows = store.query_records("SELECT * FROM projects")
+    assert rows == []  # fresh empty DB, no crash
+
+
+def test_legacy_kuzu_file_at_snapshot_path_is_removed(tmp_path: Path):
+    """DuckDBStore auto-removes a non-DuckDB file left at the snapshot path."""
+    db_path = str(tmp_path / "db")
+    snap_path = str(tmp_path / "db_read")
+
+    # Write a KùzuDB-style snapshot *directory* at the snap path
+    os.makedirs(snap_path)
+    (Path(snap_path) / "catalog.json").write_bytes(b"{}")
+
+    # Open read-only — should clear the bad snapshot and open fresh
+    store = DuckDBStore(read_only=True, db_path_override=db_path, snapshot_path_override=snap_path)
+    rows = store.query_records("SELECT * FROM projects")
+    assert rows == []
+
+
+def test_corrupt_file_at_db_path_is_replaced(tmp_path: Path):
+    """DuckDBStore replaces a corrupt (non-DuckDB) regular file at the DB path."""
+    db_path = str(tmp_path / "db")
+    snap_path = str(tmp_path / "db_read")
+
+    # Write garbage that DuckDB cannot open
+    Path(db_path).write_bytes(b"NOT A DUCKDB FILE\x00\x01\x02")
+
+    store = DuckDBStore(db_path_override=db_path, snapshot_path_override=snap_path)
+    rows = store.query_records("SELECT * FROM projects")
+    assert rows == []