blq-cli 1.0.1__tar.gz → 1.0.2__tar.gz

blq_cli-1.0.2/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## v1.0.2
+
+### Bug fixes
+- **Self-heal DBs stuck without `extension_data`.** The 2.3->2.4 migration renamed `sandbox` -> `extension_data` via `RENAME COLUMN`, which DuckDB blocks when non-view dependencies (FKs/constraints) exist on `attempts`/`invocations` — even after dropping views. The rename failed silently but the schema version advanced anyway, leaving DBs permanently stuck without `extension_data` and crashing every `write_attempt` ("Table attempts does not have a column extension_data"). `_ensure_schema` now self-heals version-independently: it gates on a missing column, adds `extension_data` via `ADD COLUMN` (never blocked), copies any existing `sandbox` data across (wrapped as `{"sandbox": ...}`, no data loss), and re-applies the idempotent schema to recreate views. Healthy/fresh DBs stay a fast no-op. Repairs on next connect (the CLI heals on the next `blq run`; a running MCP server heals after restart).

{blq_cli-1.0.1 → blq_cli-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blq-cli
-Version: 1.0.1
+Version: 1.0.2
 Summary: Build Log Query - capture and query build/test logs with DuckDB
 Project-URL: Homepage, https://blq-cli.readthedocs.io/
 Project-URL: Repository, https://github.com/teaguesterling/blq-cli

{blq_cli-1.0.1 → blq_cli-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "blq-cli"
-version = "1.0.1"
+version = "1.0.2"
 description = "Build Log Query - capture and query build/test logs with DuckDB"
 readme = "README.md"
 license = "MIT"

{blq_cli-1.0.1 → blq_cli-1.0.2}/src/blq/bird.py

@@ -420,13 +420,26 @@ class BirdStore:
                 ).fetchone()
                 if result:
                     current_version = result[0]
-                    # Apply any pending migrations
-                    cls._apply_migrations(conn, current_version)
-                    return
             except duckdb.Error:
                 pass  # Table doesn't exist, need to create
 
-        # Load schema from SQL file
+        if current_version is not None and not force:
+            # Existing DB. Only touch it when there's pending migration work or a
+            # column a past (possibly silently-failed) migration never added;
+            # otherwise this is a fast no-op.
+            if not cls._needs_repair(conn, current_version):
+                return
+            # DuckDB blocks column ALTER/RENAME while views depend on the table
+            # (this is what left old DBs stuck without extension_data). Drop all
+            # views first so migrations + the reconcile can alter the base tables;
+            # re-applying the schema below recreates every view.
+            cls._drop_all_views(conn)
+            cls._apply_migrations(conn, current_version)
+            cls._reconcile_schema(conn)
+
+        # Load schema from SQL file (idempotent: CREATE TABLE IF NOT EXISTS,
+        # INSERT OR IGNORE, CREATE OR REPLACE VIEW — safe to re-apply, and it
+        # recreates any views dropped above).
         schema_path = Path(__file__).parent / "bird_schema.sql"
         if schema_path.exists():
             schema_sql = schema_path.read_text()
@@ -504,6 +517,92 @@ class BirdStore:
 
         return statements
 
+    @classmethod
+    def _needs_repair(cls, conn: duckdb.DuckDBPyConnection, current_version: str) -> bool:
+        """True if the DB needs migration/repair — pending version bump OR a
+        required column a past (possibly silently-failed) migration never added.
+
+        Keeps the common path a fast no-op: a fully current DB returns False, so
+        _ensure_schema doesn't drop/recreate views on every connect.
+        """
+        try:
+            parts = [int(p) for p in current_version.split(".")]
+            major, minor = parts[0], parts[1] if len(parts) > 1 else 0
+            if (major, minor) < (3, 0):
+                return True
+        except (ValueError, IndexError):
+            return True  # unparseable version — reconcile to be safe
+        # Self-heal for migrations that failed silently on dependent views and
+        # then let the version advance past themselves (leaving no column).
+        for table in ("attempts", "invocations"):
+            try:
+                has = conn.execute(
+                    "SELECT 1 FROM information_schema.columns "
+                    f"WHERE table_name = '{table}' AND column_name = 'extension_data'"
+                ).fetchone()
+                if not has:
+                    return True
+            except duckdb.Error:
+                return True
+        return False
+
+    @staticmethod
+    def _drop_all_views(conn: duckdb.DuckDBPyConnection) -> None:
+        """Drop all views so base-table column ALTER/RENAME isn't blocked by
+        dependents. The schema is re-applied afterward (CREATE OR REPLACE VIEW)
+        to recreate them."""
+        try:
+            views = conn.execute(
+                "SELECT table_name FROM information_schema.tables "
+                "WHERE table_type = 'VIEW'"
+            ).fetchall()
+        except duckdb.Error:
+            return
+        for (name,) in views:
+            try:
+                conn.execute(f'DROP VIEW IF EXISTS "{name}" CASCADE')
+            except duckdb.Error:
+                pass
+
+    @classmethod
+    def _reconcile_schema(cls, conn: duckdb.DuckDBPyConnection) -> None:
+        """Version-independent self-heal: ensure `extension_data` exists on
+        attempts and invocations even if a past migration failed silently (blocked
+        by dependent views) and the schema version advanced past it. Views must
+        already be dropped by the caller so the ALTER/RENAME can proceed.
+
+        Uses ADD COLUMN + data copy, NOT rename: RENAME COLUMN on these tables is
+        blocked by non-view dependencies (FKs/constraints) that persist even after
+        dropping views, whereas ADD COLUMN is never blocked. Existing `sandbox`
+        data (from the 2.3 migration) is copied into the new column wrapped as
+        {"sandbox": ...}; the now-redundant `sandbox` column is left in place
+        (harmless, and DROP COLUMN hits the same dependency wall).
+        """
+        for table in ("attempts", "invocations"):
+            try:
+                cols = {
+                    r[0]
+                    for r in conn.execute(
+                        "SELECT column_name FROM information_schema.columns "
+                        f"WHERE table_name = '{table}'"
+                    ).fetchall()
+                }
+                if "extension_data" in cols:
+                    continue
+                conn.execute(f"ALTER TABLE {table} ADD COLUMN extension_data JSON")
+                if "sandbox" in cols:
+                    conn.execute(
+                        f"UPDATE {table} SET extension_data = "
+                        f"json_object('sandbox', sandbox) WHERE sandbox IS NOT NULL"
+                    )
+                    logger.info(
+                        f"Repaired {table}: added extension_data (copied sandbox data)"
+                    )
+                else:
+                    logger.info(f"Repaired {table}: added extension_data")
+            except duckdb.Error as e:
+                logger.warning(f"Schema reconcile warning ({table}): {e}")
+
     @classmethod
     def _apply_migrations(cls, conn: duckdb.DuckDBPyConnection, current_version: str) -> None:
         """Apply schema migrations from current version to latest.
@@ -557,42 +656,15 @@ class BirdStore:
             # Update schema version
             conn.execute("UPDATE blq_metadata SET value = '2.3.0' WHERE key = 'schema_version'")
 
-        # Migration: 2.3.0 -> 2.4.0 (rename sandbox to extension_data)
+        # Migration: 2.3.0 -> 2.4.0 (sandbox -> extension_data).
+        # RENAME COLUMN is blocked by non-view dependencies on these tables, so
+        # this is done as ADD + copy via _reconcile_schema (which is idempotent
+        # and always succeeds), rather than the RENAME that silently failed and
+        # left old DBs stuck without extension_data.
         if (major, minor) < (2, 4):
-            migration_ok = True
-            for table in ("attempts", "invocations"):
-                try:
-                    # Check if old column exists
-                    result = conn.execute(
-                        "SELECT column_name FROM information_schema.columns "
-                        f"WHERE table_name = '{table}' AND column_name = 'sandbox'"
-                    ).fetchone()
-                    if result:
-                        conn.execute(f"ALTER TABLE {table} RENAME COLUMN sandbox TO extension_data")
-                        # Wrap existing sandbox data in {"sandbox": ...} envelope
-                        conn.execute(
-                            f"UPDATE {table} SET extension_data = "
-                            f"json_object('sandbox', extension_data) "
-                            f"WHERE extension_data IS NOT NULL"
-                        )
-                        logger.info(f"Migration: Renamed sandbox to extension_data in {table}")
-                        migrations_applied = True
-                    else:
-                        # Check if new column exists, add if not
-                        result = conn.execute(
-                            "SELECT column_name FROM information_schema.columns "
-                            f"WHERE table_name = '{table}' AND column_name = 'extension_data'"
-                        ).fetchone()
-                        if not result:
-                            conn.execute(f"ALTER TABLE {table} ADD COLUMN extension_data JSON")
-                            logger.info(f"Migration: Added extension_data column to {table}")
-                            migrations_applied = True
-                except duckdb.Error as e:
-                    logger.warning(f"Migration warning: {e}")
-                    migration_ok = False
-
-            if migration_ok:
-                conn.execute("UPDATE blq_metadata SET value = '2.4.0' WHERE key = 'schema_version'")
+            cls._reconcile_schema(conn)
+            migrations_applied = True
+            conn.execute("UPDATE blq_metadata SET value = '2.4.0' WHERE key = 'schema_version'")
 
         # Migration: 2.4.0 -> 3.0.0 (directory rename .lq -> .bird, no table changes)
         if (major, minor) < (3, 0):

blq_cli-1.0.2/tests/test_schema_repair.py

@@ -0,0 +1,95 @@
+"""Regression tests for schema self-heal.
+
+An old migration renamed `sandbox` -> `extension_data`, but RENAME COLUMN is
+blocked by dependencies on `attempts`/`invocations`, so it failed silently and
+the schema version advanced past it — leaving DBs stuck without `extension_data`
+and crashing `write_attempt`. `_ensure_schema` now self-heals (ADD + copy),
+version-independently, without losing the old `sandbox` data.
+"""
+
+from pathlib import Path
+
+import duckdb
+
+import blq.bird as _bird_mod
+from blq.bird import BirdStore
+
+SCHEMA = (Path(_bird_mod.__file__).parent / "bird_schema.sql").read_text()
+
+
+def _apply(conn, sql_text):
+    for stmt in BirdStore._split_sql_statements(sql_text):
+        try:
+            conn.execute(stmt)
+        except duckdb.Error as e:
+            if "already exists" not in str(e).lower():
+                pass
+
+
+def _cols(conn, table):
+    return {
+        r[0]
+        for r in conn.execute(
+            f"SELECT column_name FROM information_schema.columns WHERE table_name='{table}'"
+        ).fetchall()
+    }
+
+
+def _build_stuck_db(path):
+    """A DB from the era when the column was `sandbox` (tables + views all on
+    `sandbox`), version 3.0.0 — exactly what a silently-failed 2.4 RENAME left."""
+    c = duckdb.connect(str(path))
+    _apply(c, SCHEMA.replace("extension_data", "sandbox"))
+    c.execute(
+        "INSERT INTO attempts (session_id, cwd, cmd, client_id, sandbox) "
+        "VALUES ('s1', '/tmp', 'build', 'blq-test', '{\"network\":\"none\"}'::JSON)"
+    )
+    c.execute("UPDATE blq_metadata SET value='3.0.0' WHERE key='schema_version'")
+    c.close()
+
+
+def test_stuck_db_self_heals_and_preserves_data(tmp_path):
+    bird = tmp_path / ".bird"
+    bird.mkdir()
+    db = bird / "blq.duckdb"
+    _build_stuck_db(db)
+
+    c = duckdb.connect(str(db))
+    assert "sandbox" in _cols(c, "attempts")
+    assert "extension_data" not in _cols(c, "attempts")
+    assert BirdStore._needs_repair(c, "3.0.0") is True
+
+    BirdStore._ensure_schema(c, bird)
+
+    # extension_data added on both tables, sandbox data copied + wrapped
+    assert "extension_data" in _cols(c, "attempts")
+    assert "extension_data" in _cols(c, "invocations")
+    val = c.execute("SELECT extension_data FROM attempts WHERE session_id='s1'").fetchone()[0]
+    assert "network" in str(val) and "sandbox" in str(val)
+
+    # views recreated, and the write that used to crash now succeeds
+    nviews = c.execute(
+        "SELECT count(*) FROM information_schema.tables WHERE table_type='VIEW'"
+    ).fetchone()[0]
+    assert nviews >= 4
+    c.execute(
+        "INSERT INTO attempts (session_id, cwd, cmd, client_id, extension_data) "
+        "VALUES ('s2', '/tmp', 'x', 'blq-test', '{\"a\":1}'::JSON)"
+    )
+
+    # converges: a repaired DB is a fast no-op on the next open
+    assert BirdStore._needs_repair(c, "3.0.0") is False
+    c.close()
+
+
+def test_fresh_db_is_healthy_and_no_op(tmp_path):
+    bird = tmp_path / ".bird"
+    bird.mkdir()
+    c = duckdb.connect(str(bird / "blq.duckdb"))
+    BirdStore._ensure_schema(c, bird)  # fresh init
+    assert "extension_data" in _cols(c, "attempts")
+    assert BirdStore._needs_repair(c, "3.0.0") is False
+    # re-open is a no-op and stays healthy
+    BirdStore._ensure_schema(c, bird)
+    assert "extension_data" in _cols(c, "attempts")
+    c.close()