codespine 1.0.4__tar.gz → 1.0.5__tar.gz

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

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

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

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

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

@@ -537,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:

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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codespine"
-version = "1.0.4"
+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.4 → 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()