buildai-cli 0.3.78__tar.gz → 0.3.80__tar.gz

{buildai_cli-0.3.78 → buildai_cli-0.3.80}/.gitignore

@@ -125,6 +125,8 @@ scripts/atlas/
 scripts/dead_assets.json
 scripts/dead_assets.ids.txt
 scripts/figure_h264_1000h/
+/apps/gigcamera/public/prototypes/
+/apps/gigcamera/.local-prototypes/
 
 # Terraform/Terragrunt local artifacts
 **/.terragrunt-cache/

{buildai_cli-0.3.78 → buildai_cli-0.3.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: buildai-cli
-Version: 0.3.78
+Version: 0.3.80
 Summary: Build AI CLI (Typer)
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27.0

{buildai_cli-0.3.78 → buildai_cli-0.3.80}/cli/commands/egoexo.py

@@ -52,9 +52,13 @@ def _request(path: str, *, query_params: list[str] | None = None) -> None:
 @app.command("recording-disposition")
 def recording_disposition(
     recording_id: str = typer.Argument(..., help="media.recordings id."),
+    limit: int = typer.Option(50, "--limit", min=1, max=100, help="Maximum rows."),
 ) -> None:
     """Show why a recording did or did not land in an EgoExo episode."""
-    _request(f"/v1/dashboard/egoexo/recordings/{recording_id}/disposition")
+    _request(
+        f"/v1/dashboard/egoexo/recordings/{recording_id}/disposition",
+        query_params=[f"limit={limit}"],
+    )
 
 
 @app.command("overview")
@@ -66,9 +70,64 @@ def overview() -> None:
 @app.command("recording-history")
 def recording_history(
     recording_id: str = typer.Argument(..., help="media.recordings id."),
+    limit: int = typer.Option(100, "--limit", min=1, max=200, help="Maximum outcome rows."),
 ) -> None:
     """Show disposition plus recording-grain verdict outcomes for one recording."""
-    _request(f"/v1/dashboard/egoexo/recordings/{recording_id}/history")
+    _request(
+        f"/v1/dashboard/egoexo/recordings/{recording_id}/history",
+        query_params=[f"limit={limit}"],
+    )
+
+
+@app.command("batch-history")
+def batch_history(
+    batch_id: str = typer.Argument(..., help="ingest.recording_batches id."),
+    limit: int = typer.Option(100, "--limit", min=1, max=200, help="Maximum outcome rows."),
+) -> None:
+    """Show disposition and batch-grain verdict outcomes for one batch."""
+    _request(
+        f"/v1/dashboard/egoexo/batches/{batch_id}/history",
+        query_params=[f"limit={limit}"],
+    )
+
+
+@app.command("episode-history")
+def episode_history(
+    episode_id: str = typer.Argument(..., help="media.episodes id."),
+    limit: int = typer.Option(100, "--limit", min=1, max=200, help="Maximum outcome rows."),
+) -> None:
+    """Show episode-grain verdict outcomes plus final dispositions."""
+    _request(
+        f"/v1/dashboard/egoexo/episodes/{episode_id}/verdict-history",
+        query_params=[f"limit={limit}"],
+    )
+
+
+@app.command("events")
+def events(
+    limit: int = typer.Option(50, "--limit", min=1, max=200, help="Maximum outcome rows."),
+    table_name: str | None = typer.Option(None, "--table", help="Outcome table filter."),
+    stage: str | None = typer.Option(None, "--stage", help="Stage filter."),
+    status: str | None = typer.Option(None, "--status", help="Status filter."),
+    reason: str | None = typer.Option(None, "--reason", help="Reason or failure-class filter."),
+    batch_id: str | None = typer.Option(None, "--batch-id", help="Batch id filter."),
+    episode_id: str | None = typer.Option(None, "--episode-id", help="Episode id filter."),
+    recording_id: str | None = typer.Option(None, "--recording-id", help="Recording id filter."),
+) -> None:
+    """Show a bounded verdict-plane event log for investigation."""
+    query_params = [f"limit={limit}"]
+    for key, value in [
+        ("table_name", table_name),
+        ("stage", stage),
+        ("status", status),
+        ("reason", reason),
+        ("batch_id", batch_id),
+        ("episode_id", episode_id),
+        ("recording_id", recording_id),
+    ]:
+        if value:
+            query_params.append(f"{key}={value}")
+    _request("/v1/dashboard/egoexo/verdict/events", query_params=query_params)
 
 
 @app.command("runtime-errors")

{buildai_cli-0.3.78 → buildai_cli-0.3.80}/cli/commands/gigcamera.py

@@ -4,11 +4,12 @@ from __future__ import annotations
 
 import asyncio
 import hashlib
+import json
 from dataclasses import asdict, is_dataclass
 from datetime import date
 from decimal import Decimal
 from time import monotonic
-from typing import Literal, cast
+from typing import Any, Literal, cast
 from uuid import UUID
 
 import typer
@@ -157,6 +158,20 @@ def _renderable_result(value: object) -> object:
     return value
 
 
+def _parse_json_object(value: str, *, option_name: str) -> dict[str, Any]:
+    """Parse a JSON object option while returning a clear CLI error."""
+
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError as exc:
+        error(f"{option_name} must be valid JSON: {exc}")
+        raise typer.Exit(1) from exc
+    if not isinstance(parsed, dict):
+        error(f"{option_name} must decode to a JSON object.")
+        raise typer.Exit(1)
+    return parsed
+
+
 def _parse_ist_day(value: str, *, field_name: str) -> date:
     """Parse one ISO calendar day supplied as a GigCamera IST boundary."""
 
@@ -173,6 +188,148 @@ def _idempotency_key(base: str, *, run_suffix: str | None) -> str:
     return f"{base}:{suffix}" if suffix else base
 
 
+@app.command("daily-quest-config-show")
+def daily_quest_config_show(
+    ctx: typer.Context,
+    config_key: str = typer.Option(
+        "gigcamera_daily_quest_v1",
+        "--config-key",
+        help="Config key to inspect.",
+    ),
+    version: int | None = typer.Option(
+        None,
+        "--version",
+        min=1,
+        help="Exact config version. Omit to resolve the active rollout config.",
+    ),
+    cohort_key: str | None = typer.Option(
+        None,
+        "--cohort-key",
+        help="Optional rollout cohort key used for active resolution.",
+    ),
+    experiment_key: str | None = typer.Option(
+        None,
+        "--experiment-key",
+        help="Optional experiment key used for active resolution.",
+    ),
+    variant_key: str | None = typer.Option(
+        None,
+        "--variant-key",
+        help="Optional variant key used for active resolution.",
+    ),
+    format: Format = format_option(),
+) -> None:
+    """Inspect Daily Quest config through the same DAL read path used by runtime code."""
+
+    settings = _settings_for_command(ctx, write=False)
+
+    async def run() -> None:
+        from dal.gigcamera import daily_quest_config as daily_quest_config_dal
+
+        async with get_cli_context(settings, profile=(ctx.obj or {}).get("cli_profile")) as (
+            _db,
+            dal_ctx,
+        ):
+            if version is None:
+                config = await daily_quest_config_dal.get_active_config(
+                    dal_ctx,
+                    config_key=config_key,
+                    cohort_key=cohort_key,
+                    experiment_key=experiment_key,
+                    variant_key=variant_key,
+                )
+                mode = "active"
+            else:
+                config = await daily_quest_config_dal.get_config(
+                    dal_ctx,
+                    config_key=config_key,
+                    version=version,
+                )
+                mode = "version"
+
+        render({"mode": mode, "config": config}, format=format)
+
+    asyncio.run(run())
+
+
+@app.command("daily-quest-config-update")
+def daily_quest_config_update(
+    ctx: typer.Context,
+    config_key: str = typer.Option(
+        "gigcamera_daily_quest_v1",
+        "--config-key",
+        help="Config key to update.",
+    ),
+    version: int = typer.Option(1, "--version", min=1, help="Config version to update."),
+    patch_json: str = typer.Option(
+        ...,
+        "--patch-json",
+        help="JSON object of config fields to change. Use decimal strings for money values.",
+    ),
+    reason: str = typer.Option(
+        ...,
+        "--reason",
+        help="Human-readable rollout/audit reason for this config change.",
+    ),
+    write: bool = typer.Option(False, "--write", help="Persist the update and append audit."),
+    format: Format = format_option(),
+) -> None:
+    """Preview or apply a Daily Quest config patch without redeploying services."""
+
+    settings = _settings_for_command(ctx, write=write)
+    patch = _parse_json_object(patch_json, option_name="--patch-json")
+    _require_internal_admin_for_write(ctx, write=write)
+
+    async def run() -> None:
+        from dal.gigcamera import daily_quest_config as daily_quest_config_dal
+
+        async with get_cli_context(settings, profile=(ctx.obj or {}).get("cli_profile")) as (
+            _db,
+            dal_ctx,
+        ):
+            before = await daily_quest_config_dal.get_config(
+                dal_ctx,
+                config_key=config_key,
+                version=version,
+            )
+            if before is None:
+                raise LookupError(f"Daily Quest config {config_key} v{version} does not exist")
+
+            if write:
+                async with dal_ctx.transaction():
+                    after = await daily_quest_config_dal.update_config(
+                        dal_ctx,
+                        config_key=config_key,
+                        version=version,
+                        patch=patch,
+                        reason=reason,
+                    )
+            else:
+                after = await daily_quest_config_dal.preview_config_update(
+                    dal_ctx,
+                    config_key=config_key,
+                    version=version,
+                    patch=patch,
+                )
+
+        render(
+            {
+                "dry_run": not write,
+                "config_key": config_key,
+                "version": version,
+                "reason": reason,
+                "before": before,
+                "after": after,
+                "next_step": None
+                if write
+                else "rerun with --write --profile internal_admin to persist",
+            },
+            format=format,
+        )
+
+    asyncio.run(run())
+
+
 @app.command("admin-analytics-read-model-refresh")
 def admin_analytics_read_model_refresh(
     ctx: typer.Context,

{buildai_cli-0.3.78 → buildai_cli-0.3.80}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "buildai-cli"
-version = "0.3.78"
+version = "0.3.80"
 description = "Build AI CLI (Typer)"
 requires-python = ">=3.11"
 dependencies = [