buildai-cli 0.3.89__tar.gz → 0.3.91__tar.gz

{buildai_cli-0.3.89 → buildai_cli-0.3.91}/PKG-INFO

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

{buildai_cli-0.3.89 → buildai_cli-0.3.91}/cli/commands/ego_frame_search.py

@@ -567,3 +567,79 @@ def queue_missing_sampled_frames(
         render(manifest, format=format)
 
     asyncio.run(run())
+
+
+@app.command("queue-missing-demian-labels")
+def queue_missing_demian_labels(
+    ctx: typer.Context,
+    corpus_key: list[str] = typer.Option(..., "--corpus-key", help="Corpus key. Repeatable."),
+    selection_kind: str = typer.Option("near_90s", "--selection-kind"),
+    observation_kind: str = typer.Option("demian_frame_label_v1", "--observation-kind"),
+    label_model_id: str = typer.Option("demian-v1", "--label-model-id"),
+    label_prompt_version: str = typer.Option(
+        "demian-frame-label-v1",
+        "--label-prompt-version",
+    ),
+    model_config_hash: str | None = typer.Option(None, "--model-config-hash"),
+    endpoint_url: str | None = typer.Option(None, "--endpoint-url"),
+    limit: int | None = typer.Option(None, "--limit", min=1, help="Cap selected frames."),
+    idempotency_key: str = typer.Option(..., "--idempotency-key", help="Manifest idempotency key."),
+    cost_cap_usd: float | None = typer.Option(None, "--cost-cap-usd", min=0.0),
+    max_parallel_requests: int = typer.Option(1, "--max-parallel-requests", min=1),
+    endpoint_timeout_sec: int = typer.Option(300, "--endpoint-timeout-sec", min=1),
+    write: bool = typer.Option(False, "--write", help="Create the processing manifest."),
+    format: Format = format_option(),
+) -> None:
+    """Queue missing-only DeMiAn labels for canonical sampled corpus frames."""
+    _require_internal_admin_for_write(ctx, write=write)
+    settings = _settings_for_command(ctx, write=write)
+
+    async def run() -> None:
+        from dal.processing import media_jobs
+
+        async with get_cli_context(settings, profile=(ctx.obj or {}).get("cli_profile")) as (
+            _db,
+            dal_ctx,
+        ):
+            selection_spec = {
+                "kind": "by_corpus",
+                "corpus_keys": corpus_key,
+                "selection_kind": selection_kind,
+                "observation_kind": observation_kind,
+                "label_model_id": label_model_id,
+                "label_prompt_version": label_prompt_version,
+                "model_config_hash": model_config_hash,
+                "endpoint_url": endpoint_url,
+                "limit": limit,
+                "only_missing_labels": True,
+                "max_parallel_requests_per_worker": max_parallel_requests,
+                "endpoint_timeout_sec": endpoint_timeout_sec,
+            }
+            sink_overrides = {
+                "observation": {
+                    "table": "observations.frame_observations",
+                    "observation_kind": observation_kind,
+                }
+            }
+            resource_overrides = {"cost_cap_usd": cost_cap_usd} if cost_cap_usd is not None else {}
+            if write:
+                manifest = await media_jobs.queue_processor_job(
+                    dal_ctx,
+                    processor_ref=media_jobs.DEMIAN_FRAME_LABEL_PROCESSOR_REF,
+                    selection_spec=selection_spec,
+                    sink_overrides=sink_overrides,
+                    resource_overrides=resource_overrides,
+                    submitted_by_principal=_SUBMITTED_BY,
+                    idempotency_key=idempotency_key,
+                )
+            else:
+                manifest = {
+                    "dry_run": True,
+                    "processor_ref": media_jobs.DEMIAN_FRAME_LABEL_PROCESSOR_REF,
+                    "selection_spec": selection_spec,
+                    "sink_overrides": sink_overrides,
+                    "resource_overrides": resource_overrides,
+                }
+        render(manifest, format=format)
+
+    asyncio.run(run())

{buildai_cli-0.3.89 → buildai_cli-0.3.91}/cli/commands/spec.py

@@ -77,7 +77,13 @@ def _resolve_buildspec(repo_root: Path | None) -> list[str]:
     )
 
 
-CONTEXT_SETTINGS = {"allow_extra_args": True, "ignore_unknown_options": True}
+CONTEXT_SETTINGS = {
+    "allow_extra_args": True,
+    "ignore_unknown_options": True,
+    # Disable Click's eager --help so `spec <verb> --help` reaches the wrapped
+    # engine (or `cmd_pr`'s argparse) instead of the generic wrapper help.
+    "help_option_names": [],
+}
 
 
 def run_buildspec(args: list[str]) -> int:
@@ -150,6 +156,124 @@ def doctor() -> int:
     return 0 if healthy else 1
 
 
+def _print_active_changes(repo_root: Path) -> None:
+    """List active (non-archived) change ids to guide a missing/incorrect arg."""
+
+    changes_dir = repo_root / "buildspec" / "changes"
+    if not changes_dir.is_dir():
+        return
+    names = sorted(p.name for p in changes_dir.iterdir() if p.is_dir() and p.name != "archive")
+    if names:
+        info("Active changes:")
+        for name in names:
+            info(f"  {name}")
+
+
+def cmd_pr(args: list[str]) -> int:
+    """Render a reviewer-ready PR body from a BuildSpec change folder.
+
+    Prints the body (default), writes it with ``--body-file``, or opens the PR
+    with ``--create`` via ``gh pr create``. The change-id is a required argument:
+    branches do not encode it and many changes share a branch.
+    """
+
+    import argparse
+    import tempfile
+
+    from cli.commands.spec_pr import default_title, render_pr_body, resolve_change_dir
+
+    repo_root = _repo_root()
+    if repo_root is None:
+        error("Run `buildai spec pr` from the Build AI repo checkout.")
+        return 1
+
+    parser = argparse.ArgumentParser(
+        prog="buildai spec pr",
+        description="Render a pull-request body from a BuildSpec change.",
+    )
+    parser.add_argument("change_id", nargs="?", help="BuildSpec change id (required).")
+    parser.add_argument(
+        "--body-file", help="Write the rendered body to this path instead of stdout."
+    )
+    parser.add_argument("--create", action="store_true", help="Open the PR with `gh pr create`.")
+    parser.add_argument("--title", help="PR title; prefer a Conventional Commit subject.")
+    parser.add_argument("--base", default="main", help="Base branch for --create (default: main).")
+    parser.add_argument("--draft", action="store_true", help="Create the PR as a draft.")
+    try:
+        ns = parser.parse_args(args)
+    except SystemExit as exc:  # argparse already printed help or a usage error
+        return int(exc.code or 0)
+
+    if not ns.change_id:
+        error(
+            "Usage: buildai spec pr <change-id> "
+            "[--body-file PATH | --create] [--title T] [--base B] [--draft]"
+        )
+        _print_active_changes(repo_root)
+        return 1
+
+    change_dir = resolve_change_dir(repo_root, ns.change_id)
+    if change_dir is None:
+        error(
+            f"No change folder for '{ns.change_id}' under buildspec/changes/ (active or archived)."
+        )
+        _print_active_changes(repo_root)
+        return 1
+
+    body = render_pr_body(change_dir, ns.change_id, repo_root)
+    title = ns.title or default_title(ns.change_id)
+
+    if ns.create:
+        if not shutil.which("gh"):
+            error(
+                "`gh` CLI not found. Install GitHub CLI, or use `--body-file` then `gh pr create`."
+            )
+            return 1
+        if not ns.title:
+            info(
+                f"No --title given; using derived '{title}'. Prefer a Conventional Commit subject."
+            )
+        with tempfile.NamedTemporaryFile(
+            "w", suffix=".md", delete=False, encoding="utf-8"
+        ) as handle:
+            handle.write(body)
+            body_path = handle.name
+        command = [
+            "gh",
+            "pr",
+            "create",
+            "--title",
+            title,
+            "--body-file",
+            body_path,
+            "--base",
+            ns.base,
+        ]
+        if ns.draft:
+            command.append("--draft")
+        try:
+            code = subprocess.run(command, cwd=repo_root).returncode
+            if code == 0:
+                info(
+                    "PR opened. Fill in the Validation block (and any blank "
+                    "PR-local sections) before requesting review."
+                )
+            return code
+        finally:
+            try:
+                os.unlink(body_path)
+            except OSError:
+                pass
+
+    if ns.body_file:
+        Path(ns.body_file).write_text(body, encoding="utf-8")
+        info(f"Wrote PR body to {ns.body_file}")
+        return 0
+
+    print(body)
+    return 0
+
+
 def spec_command(
     ctx: typer.Context,
     args: list[str] | None = typer.Argument(
@@ -162,6 +286,8 @@ def spec_command(
     forwarded = list(args or []) + list(ctx.args)
     if forwarded and forwarded[0] == "doctor":
         raise typer.Exit(code=doctor())
+    if forwarded and forwarded[0] == "pr":
+        raise typer.Exit(code=cmd_pr(forwarded[1:]))
     if not forwarded:
         forwarded = ["--help"]
     try:

buildai_cli-0.3.91/cli/commands/spec_pr.py

@@ -0,0 +1,303 @@
+"""Render a reviewer-ready pull-request body from a BuildSpec change folder.
+
+`uv run buildai spec pr <change-id>` projects a finished change into a PR body
+instead of asking the author to re-type what `proposal.md`, `design.md`, and
+`specs/**/spec.md` already hold. The rendered body is a *view* of the change,
+never a copy, so the change folder stays the single source of truth.
+
+This module is pure (no console or process IO) so it can be unit-tested. The CLI
+glue — argument parsing, `--body-file`, and `gh pr create` — lives in
+`cli.commands.spec`.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_HEADING_RE = re.compile(r"^(#{1,6})\s+(.*\S)\s*$")
+_COMMENT_RE = re.compile(r"<!--.*?-->", re.DOTALL)
+_TASK_DONE_RE = re.compile(r"^\s*-\s*\[x\]", re.MULTILINE | re.IGNORECASE)
+_TASK_ANY_RE = re.compile(r"^\s*-\s*\[[ xX]\]", re.MULTILINE)
+_FENCE_RE = re.compile(r"^\s*(```|~~~)")
+_ARCHIVE_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}-")
+
+_HEADER = (
+    "<!-- Rendered by `uv run buildai spec pr {change_id}`. "
+    "It is a view of the BuildSpec change, not the diff — reconcile "
+    "'What changed' against the actual diff before submitting. -->"
+)
+
+_VALIDATION_SKELETON = (
+    "- [ ] Local checks run:\n"
+    "- [ ] Relevant tests run:\n"
+    "- [ ] UI/screenshots attached, if applicable:\n"
+    "- [ ] Generated artifacts updated, if applicable:"
+)
+
+_DATA_SKELETON = (
+    "Fill this out for any change that publishes, repairs, consumes, or trains "
+    "on data. Write `N/A` only when the PR has no data/artifact/training "
+    "impact.\n\n"
+    "- Dataset / artifact contract:\n"
+    "- External artifact identifiers:\n"
+    "  - GCS URI + generation, Modal run id, DB query, checksum, or equivalent:\n"
+    "- Producer commit:\n"
+    "- Consumer / loader commit:\n"
+    "- Validation report or command output:\n"
+    "- Downstream owner/action:"
+)
+
+
+def _split_sections(text: str) -> dict[str, str]:
+    """Map each level-2 (`## `) heading, lowercased, to its body text.
+
+    Deeper headings (`### `, `#### `) stay inside the enclosing section body so
+    requirement/scenario structure in spec deltas is preserved.
+    """
+
+    sections: dict[str, str] = {}
+    current: str | None = None
+    buf: list[str] = []
+    in_fence = False
+    for line in text.splitlines():
+        # Only track fences inside a section. Preamble (before the first `## `)
+        # is never rendered, so an unbalanced preamble fence cannot leak its
+        # state into — and swallow — the first real section.
+        if current is not None and _FENCE_RE.match(line):
+            in_fence = not in_fence
+            buf.append(line)
+            continue
+        match = _HEADING_RE.match(line)
+        if not in_fence and match and len(match.group(1)) == 2:
+            if current is not None:
+                sections[current] = "\n".join(buf).strip()
+            current = match.group(2).strip().lower()
+            buf = []
+        elif current is not None:
+            buf.append(line)
+    if current is not None:
+        sections[current] = "\n".join(buf).strip()
+    return sections
+
+
+def _strip_placeholders(body: str) -> str:
+    """Remove HTML comments and bare template bullets so empties read as empty."""
+
+    body = _COMMENT_RE.sub("", body)
+    kept: list[str] = []
+    for line in body.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped in {"-", "*", ">"}:
+            continue
+        kept.append(line.rstrip())
+    return "\n".join(kept).strip()
+
+
+def _is_empty(body: str) -> bool:
+    """True when a section carries no substantive content (only comments/blanks)."""
+
+    return not _strip_placeholders(body)
+
+
+def _section(sections: dict[str, str], *names: str) -> str:
+    """Return the first non-empty section body matching any alias name."""
+
+    for name in names:
+        body = sections.get(name.lower())
+        if body and not _is_empty(body):
+            return body.strip()
+    return ""
+
+
+def _labeled(label: str, body: str) -> str:
+    return f"**{label}**\n\n{body.strip()}" if body.strip() else ""
+
+
+def _join_parts(parts: list[str]) -> str:
+    return "\n\n".join(part.strip() for part in parts if part and part.strip())
+
+
+def _demote(text: str, by: int = 2) -> str:
+    """Push every Markdown heading down `by` levels (capped at 6) so embedded
+    spec headings nest under the PR's own `##` sections instead of competing."""
+
+    out: list[str] = []
+    in_fence = False
+    for line in text.splitlines():
+        if _FENCE_RE.match(line):
+            in_fence = not in_fence
+            out.append(line)
+            continue
+        match = re.match(r"^(#{1,6})(\s.*)$", line)
+        if not in_fence and match:
+            level = min(6, len(match.group(1)) + by)
+            out.append("#" * level + match.group(2))
+        else:
+            out.append(line)
+    return "\n".join(out)
+
+
+def _read(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8")
+    except (FileNotFoundError, OSError):
+        return ""
+
+
+def count_tasks(text: str) -> tuple[int, int]:
+    """Return (checked, total) task checkboxes in a tasks.md body."""
+
+    return len(_TASK_DONE_RE.findall(text)), len(_TASK_ANY_RE.findall(text))
+
+
+def _render_spec_deltas(change_dir: Path) -> str:
+    """Render every `specs/**/spec.md` delta, headings demoted, capability-labeled."""
+
+    specs_root = change_dir / "specs"
+    if not specs_root.is_dir():
+        return ""
+    parts: list[str] = []
+    for spec in sorted(specs_root.rglob("spec.md")):
+        content = _read(spec).strip()
+        if not content:
+            continue
+        capability = spec.parent.name
+        parts.append(f"**Capability: `{capability}`**\n\n{_demote(content)}")
+    return _join_parts(parts)
+
+
+def resolve_change_dir(repo_root: Path, change_id: str) -> Path | None:
+    """Locate a change folder by id, whether active or archived.
+
+    Active changes live at `buildspec/changes/<id>/`; archived ones are renamed
+    to `buildspec/changes/archive/<date>-<id>/`, so the archive is matched on the
+    `-<id>` suffix (newest wins).
+    """
+
+    active = repo_root / "buildspec" / "changes" / change_id
+    if active.is_dir():
+        return active
+    archive = repo_root / "buildspec" / "changes" / "archive"
+    if archive.is_dir():
+        # Archived dirs are `YYYY-MM-DD-<change-id>`. Strip the date prefix and
+        # match the id EXACTLY — a plain suffix test would let `setup` resolve
+        # `2026-06-01-database-setup`. Newest (last-sorted) wins on a true tie.
+        matches = sorted(
+            path
+            for path in archive.iterdir()
+            if path.is_dir() and _ARCHIVE_DATE_RE.sub("", path.name) == change_id
+        )
+        if matches:
+            return matches[-1]
+    return None
+
+
+def _find_repo_root(change_dir: Path) -> Path:
+    """Repo root for a change dir — active or archived — found as the nearest
+    ancestor that contains a `buildspec/` directory."""
+
+    for parent in change_dir.parents:
+        if (parent / "buildspec").is_dir():
+            return parent
+    return change_dir.parents[-1]
+
+
+def _change_path_label(repo_root: Path, change_dir: Path) -> str:
+    try:
+        return str(change_dir.relative_to(repo_root))
+    except ValueError:
+        return str(change_dir)
+
+
+def default_title(change_id: str) -> str:
+    """Humanize a change-id into a fallback PR title (author should set the real one)."""
+
+    words = change_id.replace("-", " ").replace("_", " ").strip()
+    return words[:1].upper() + words[1:] if words else change_id
+
+
+def render_pr_body(change_dir: Path, change_id: str, repo_root: Path | None = None) -> str:
+    """Assemble a PR-body markdown projection of a change folder.
+
+    Auto sections (why/what/approach/trade-offs/contracts/scope/rollback/caveats)
+    render from proposal/design/spec content and are omitted when their source is
+    empty. The Linked-BuildSpec, Validation, and Data-handoff blocks always render
+    because they are PR-local and human-filled.
+    """
+
+    repo_root = repo_root or _find_repo_root(change_dir)
+    proposal = _split_sections(_read(change_dir / "proposal.md"))
+    design = _split_sections(_read(change_dir / "design.md"))
+    done, total = count_tasks(_read(change_dir / "tasks.md"))
+
+    linked = [f"- Change: `{_change_path_label(repo_root, change_dir)}`"]
+    if total:
+        linked.append(f"- Implementation: {done}/{total} tasks checked in the change ledger")
+    linked.append("- Closes: <!-- #issue or N/A -->")
+    linked.append("")
+    linked.append(f"BuildSpec: {change_id}")
+
+    # (title, content, always_render)
+    blocks: list[tuple[str, str, bool]] = [
+        ("Linked BuildSpec & issues", "\n".join(linked), True),
+        (
+            "Why / context",
+            _join_parts([_section(proposal, "Why"), _section(design, "Context")]),
+            False,
+        ),
+        ("What changed", _section(proposal, "What Changes", "What Changed"), False),
+        ("Approach & alternatives considered", _section(design, "Decisions"), False),
+        (
+            "Trade-offs & risks",
+            _section(design, "Risks / Trade-offs", "Risks/Trade-offs", "Risks", "Trade-offs"),
+            False,
+        ),
+        ("Contract deltas & how to verify", _render_spec_deltas(change_dir), False),
+        (
+            "Scope & non-goals",
+            _join_parts(
+                [
+                    _labeled("Impact", _section(proposal, "Impact")),
+                    _section(design, "Goals / Non-Goals", "Goals/Non-Goals"),
+                    _labeled("Out of scope", _section(proposal, "Out of Scope")),
+                ]
+            ),
+            False,
+        ),
+        (
+            "Rollout & rollback",
+            _join_parts(
+                [
+                    _section(
+                        design,
+                        "Migration Plan",
+                        "Proposed Migration Shape",
+                        "Migration",
+                        "Rollout Plan",
+                    ),
+                    _labeled("Rollback", _section(design, "Rollback", "Rollback Strategy")),
+                ]
+            ),
+            False,
+        ),
+        ("Validation", _VALIDATION_SKELETON, True),
+        ("Data, artifact, or training handoff", _DATA_SKELETON, True),
+        (
+            "Caveats, follow-up & open questions",
+            _join_parts(
+                [
+                    _section(design, "Open Questions"),
+                    _labeled("Discussion capture", _section(proposal, "Discussion Capture")),
+                ]
+            ),
+            False,
+        ),
+    ]
+
+    rendered = [_HEADER.format(change_id=change_id)]
+    for title, content, always in blocks:
+        if not always and _is_empty(content):
+            continue
+        rendered.append(f"## {title}\n\n{content.strip()}")
+    return "\n\n".join(rendered).strip() + "\n"

{buildai_cli-0.3.89 → buildai_cli-0.3.91}/pyproject.toml

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