codespine 1.0.3__tar.gz → 1.0.5__tar.gz

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

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

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

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

{codespine-1.0.3 → codespine-1.0.5}/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)
@@ -527,21 +537,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:
@@ -584,7 +601,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 +612,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 +623,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 +633,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 +644,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 +654,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 +672,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 +698,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 +737,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 +830,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 +854,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 +892,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 +901,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 +911,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 +921,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 +965,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 +991,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 +1008,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 +1021,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 +1034,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 +1055,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 +1194,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.3 → codespine-1.0.5}/codespine/db/_cypher_compat.py

@@ -77,7 +77,47 @@ def translate(cypher: str, params: dict[str, Any] | None = None) -> tuple[str, d
 # Internal translation pipeline
 # ---------------------------------------------------------------------------
 
+_ALL_EDGE_TABLES = (
+    "calls",
+    "references_type",
+    "injects",
+    "binds_interface",
+    "community_members",
+    "flow_members",
+    "co_changed_with",
+)
+
+
+def _translate_anonymous_edge_count(cypher: str) -> str | None:
+    """Handle `MATCH ()-[r]->() RETURN count(r) [as X]`.
+
+    Anonymous edge patterns carry no labels, so the generic translator
+    cannot derive a FROM table.  We special-case the count-all-edges
+    pattern by unioning row-counts across every edge table in the
+    schema, which is what CodeSpine actually asks for.
+    """
+    q = re.sub(r"\s+", " ", cypher.strip())
+    # Accept MATCH ()-[r]->() RETURN count(r) [as alias]
+    m = re.match(
+        r"(?i)MATCH\s*\(\s*\)\s*-\s*\[\s*(\w+)?\s*\]\s*->\s*\(\s*\)\s*"
+        r"RETURN\s+count\s*\(\s*\*?\w*\s*\)\s*(?:as\s+(\w+))?\s*$",
+        q,
+    )
+    if not m:
+        return None
+    alias = m.group(2) or "count"
+    unions = " UNION ALL ".join(
+        f"SELECT COUNT(*) AS c FROM {tbl}" for tbl in _ALL_EDGE_TABLES
+    )
+    return f"SELECT COALESCE(SUM(c), 0) AS {alias} FROM ({unions}) t"
+
+
 def _translate(cypher: str) -> str:
+    # Fast-path: anonymous edge-count query used by `analyse` summary.
+    special = _translate_anonymous_edge_count(cypher)
+    if special is not None:
+        return special
+
     q = re.sub(r"\s+", " ", cypher.strip())
 
     # Collect node aliases before we start mangling the string
@@ -248,7 +288,9 @@ def _translate(cypher: str) -> str:
                   if tbl not in {et.split()[0] for et in edge_from}
                   or any(alias in ef for ef in edge_from)]
     # Deduplicate: edge_from entries are already included via aliases
-    from_str = ", ".join(from_parts) if from_parts else "dual"
+    # Fallback: empty DuckDB-valid relation so an un-matched pattern
+    # degrades to zero rows instead of crashing with "table dual missing".
+    from_str = ", ".join(from_parts) if from_parts else "(SELECT 1 WHERE 1=0) _empty(x)"
 
     # ----------------------------------------------------------------
     # 7.  Transform WHERE conditions

{codespine-1.0.3 → codespine-1.0.5}/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.3 → codespine-1.0.5}/codespine.egg-info/PKG-INFO

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

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

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

{codespine-1.0.3 → codespine-1.0.5}/tests/test_cypher_compat.py

@@ -301,3 +301,48 @@ def test_no_return_gives_star():
     sql = _translate("MATCH (n:File)")
     assert "SELECT" in sql
     assert "files" in sql
+
+
+# ---------------------------------------------------------------------------
+# Anonymous edge-count pattern (v1.0.5 regression)
+# ---------------------------------------------------------------------------
+
+
+def test_anonymous_edge_count():
+    """`MATCH ()-[r]->() RETURN count(r) as count` — the query used by
+    `codespine analyse` to report total edges — must translate to a
+    DuckDB-valid query instead of falling through to `FROM dual`.
+    """
+    sql = _translate("MATCH ()-[r]->() RETURN count(r) as count")
+    # Must reference real edge tables, not the Oracle-style `dual`.
+    assert "dual" not in sql.lower()
+    assert "calls" in sql
+    assert "references_type" in sql
+    assert "injects" in sql
+    assert "binds_interface" in sql
+    assert "community_members" in sql
+    assert "flow_members" in sql
+    assert "co_changed_with" in sql
+    # Alias should survive so callers can read row["count"].
+    assert "AS count" in sql or "as count" in sql
+
+
+def test_anonymous_edge_count_no_alias():
+    sql = _translate("MATCH ()-[r]->() RETURN count(r)")
+    assert "dual" not in sql.lower()
+    assert "calls" in sql
+
+
+def test_anonymous_edge_count_unnamed_rel():
+    # `MATCH ()-[]->()` (no rel variable) should also be handled
+    sql = _translate("MATCH ()-[]->() RETURN count(*) as count")
+    assert "dual" not in sql.lower()
+    assert "calls" in sql
+
+
+def test_unmatched_pattern_uses_safe_fallback():
+    """If translator can't derive a FROM table, emit an empty DuckDB
+    relation rather than Oracle's `dual`.
+    """
+    sql = _translate("MATCH (x:NotARealLabel) RETURN x.id")
+    assert "dual" not in sql.lower()

{codespine-1.0.3 → codespine-1.0.5}/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() == []