assertion-cli 0.1.0__tar.gz

assertion_cli-0.1.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: assertion-cli
+Version: 0.1.0
+Summary: CLI for the Assertion API
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: typer>=0.24.1
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: respx>=0.22; extra == "test"
+
+# Assertion CLI
+
+CLI for the Assertion API.
+
+## Usage
+
+The CLI currently targets a local backend at `http://localhost:8000`.
+
+Run locally from the workspace:
+
+```bash
+uv run --package assertion-cli asrt --help
+```
+
+Install from Git as a `uv` tool:
+
+```bash
+uv tool install git+ssh://git@github.com/prooflayer-ai/backend.git#subdirectory=cli
+```
+
+The CLI package declares all of its direct runtime dependencies. At the moment
+that set is `httpx`, `pydantic`, and `typer`.
+
+After installation:
+
+```bash
+asrt stacks
+asrt checkpoint --stack <stack-id> "Implemented X\nUpdated Y"
+asrt checkpoint --continue "Implemented Y"
+asrt decision --yes <checkpoint-id>   # optional, only after a failed checkpoint
+asrt verify
+```
+
+This expects the installer to already have GitHub SSH access to `prooflayer-ai/backend`.

assertion_cli-0.1.0/README.md

@@ -0,0 +1,34 @@
+# Assertion CLI
+
+CLI for the Assertion API.
+
+## Usage
+
+The CLI currently targets a local backend at `http://localhost:8000`.
+
+Run locally from the workspace:
+
+```bash
+uv run --package assertion-cli asrt --help
+```
+
+Install from Git as a `uv` tool:
+
+```bash
+uv tool install git+ssh://git@github.com/prooflayer-ai/backend.git#subdirectory=cli
+```
+
+The CLI package declares all of its direct runtime dependencies. At the moment
+that set is `httpx`, `pydantic`, and `typer`.
+
+After installation:
+
+```bash
+asrt stacks
+asrt checkpoint --stack <stack-id> "Implemented X\nUpdated Y"
+asrt checkpoint --continue "Implemented Y"
+asrt decision --yes <checkpoint-id>   # optional, only after a failed checkpoint
+asrt verify
+```
+
+This expects the installer to already have GitHub SSH access to `prooflayer-ai/backend`.

assertion_cli-0.1.0/api.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import os
+from typing import Any, TypeVar
+
+import httpx
+import typer
+from dotenv import find_dotenv, load_dotenv
+from pydantic import BaseModel, ValidationError
+
+from models import (
+    CheckpointResponse,
+    DecisionResponse,
+    ErrorResponse,
+    InitResponse,
+    StatusResponse,
+    VerifyResponse,
+)
+
+T = TypeVar("T", bound=BaseModel)
+
+DEFAULT_BASE_URL = "http://localhost:8000"
+DEFAULT_CHECKPOINT_TIMEOUT_SECONDS = 300.0
+API_TOKEN_ENV = "ASSERTION_API_TOKEN"
+
+# Walk up from cwd looking for a .env so the user can drop their token in the
+# repo root once and forget it. override=False means a real shell `export`
+# still wins over the file — useful for CI.
+_dotenv_path = find_dotenv(usecwd=True)
+if _dotenv_path:
+    load_dotenv(_dotenv_path, override=False)
+
+
+def _base_url() -> str:
+    return os.environ.get("ASSERTION_BASE_URL", DEFAULT_BASE_URL)
+
+
+def _auth_headers() -> dict[str, str]:
+    token = (os.environ.get(API_TOKEN_ENV) or "").strip()
+    if not token:
+        typer.echo(
+            f"Missing {API_TOKEN_ENV}. Generate a token at Settings → Authentication "
+            "in the dashboard, then save it in a .env at your repo root:\n\n"
+            f"  echo '{API_TOKEN_ENV}=alk_...' >> .env\n\n"
+            "(Or export it in your shell.)",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+    return {"Authorization": f"Bearer {token}"}
+
+
+def _parse_response(response: httpx.Response, model: type[T]) -> T:
+    try:
+        return model.model_validate_json(response.text)
+    except ValidationError as exc:
+        raise ValueError(f"Invalid API response: {exc}") from exc
+
+
+def _summarize_error(response: httpx.Response) -> str:
+    try:
+        return ErrorResponse.model_validate_json(response.text).error
+    except ValidationError:
+        body = response.text.strip()
+        return body[:200] if body else "<empty response body>"
+
+
+class AssertionClient:
+    def __init__(self) -> None:
+        self.base_url = _base_url()
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        model: type[T],
+        *,
+        timeout: float = 30.0,
+        **kwargs: Any,
+    ) -> T:
+        url = f"{self.base_url}{path}"
+        headers = {**_auth_headers(), **kwargs.pop("headers", {})}
+        try:
+            response = httpx.request(
+                method, url, timeout=timeout, headers=headers, **kwargs
+            )
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            summary = _summarize_error(exc.response)
+            typer.echo(
+                f"Request failed with status {exc.response.status_code}: {summary}",
+                err=True,
+            )
+            raise typer.Exit(code=1) from exc
+        except httpx.ReadTimeout as exc:
+            typer.echo(f"Request to {url} timed out after {timeout:.0f}s.", err=True)
+            raise typer.Exit(code=1) from exc
+        except httpx.HTTPError as exc:
+            typer.echo(f"Failed to connect to Assertion API at {url}: {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+
+        try:
+            return _parse_response(response, model)
+        except ValueError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(code=1) from exc
+
+    def init(self) -> InitResponse:
+        return self._request("POST", "/api/v0/agent/init", InitResponse, timeout=10.0)
+
+    def _request_no_content(
+        self,
+        method: str,
+        path: str,
+        *,
+        timeout: float = 30.0,
+        **kwargs: Any,
+    ) -> DecisionResponse:
+        url = f"{self.base_url}{path}"
+        headers = {**_auth_headers(), **kwargs.pop("headers", {})}
+        try:
+            response = httpx.request(
+                method, url, timeout=timeout, headers=headers, **kwargs
+            )
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            summary = _summarize_error(exc.response)
+            typer.echo(
+                f"Request failed with status {exc.response.status_code}: {summary}",
+                err=True,
+            )
+            raise typer.Exit(code=1) from exc
+        except httpx.HTTPError as exc:
+            typer.echo(f"Failed to connect to Assertion API at {url}: {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+
+        return DecisionResponse()
+
+    def stacks(self) -> list:
+        """Fetch available stacks (read-only, no session created)."""
+        from models import VerificationStack
+        from pydantic import TypeAdapter
+
+        url = f"{self.base_url}/api/v0/agent/stacks"
+        try:
+            response = httpx.get(url, timeout=10.0, headers=_auth_headers())
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            summary = _summarize_error(exc.response)
+            typer.echo(
+                f"Request failed with status {exc.response.status_code}: {summary}",
+                err=True,
+            )
+            raise typer.Exit(code=1) from exc
+        except httpx.HTTPError as exc:
+            typer.echo(f"Failed to connect to Assertion API at {url}: {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+
+        try:
+            adapter = TypeAdapter(list[VerificationStack])
+            return adapter.validate_json(response.text)
+        except Exception as exc:
+            typer.echo(f"Invalid API response: {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+
+    def verify(
+        self,
+        *,
+        stack_id: str,
+        session_id: str,
+        bundle_bytes: bytes,
+    ) -> VerifyResponse:
+        path = f"/api/v0/agent/verify/{stack_id}/{session_id}"
+        return self._request(
+            "POST",
+            path,
+            VerifyResponse,
+            files={"bundle": ("assertion_bundle.zip", bundle_bytes, "application/zip")},
+        )
+
+    def checkpoint(
+        self,
+        *,
+        stack_id: str,
+        session_id: str,
+        bundle_bytes: bytes,
+    ) -> CheckpointResponse:
+        path = f"/api/v0/agent/checkpoint/{stack_id}/{session_id}"
+        return self._request(
+            "POST",
+            path,
+            CheckpointResponse,
+            timeout=DEFAULT_CHECKPOINT_TIMEOUT_SECONDS,
+            files={"bundle": ("assertion_bundle.zip", bundle_bytes, "application/zip")},
+        )
+
+    def decision(self, *, checkpoint_id: str, decision: str) -> DecisionResponse:
+        return self._request_no_content(
+            "POST",
+            f"/api/v0/agent/decision/{checkpoint_id}",
+            json={"decision": decision},
+            timeout=10.0,
+        )
+
+    def status(self, *, session_id: str) -> StatusResponse:
+        return self._request(
+            "POST",
+            "/api/v0/agent/status",
+            StatusResponse,
+            json={"session_id": session_id},
+            timeout=10.0,
+        )

assertion_cli-0.1.0/assertion_cli.egg-info/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: assertion-cli
+Version: 0.1.0
+Summary: CLI for the Assertion API
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: typer>=0.24.1
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: respx>=0.22; extra == "test"
+
+# Assertion CLI
+
+CLI for the Assertion API.
+
+## Usage
+
+The CLI currently targets a local backend at `http://localhost:8000`.
+
+Run locally from the workspace:
+
+```bash
+uv run --package assertion-cli asrt --help
+```
+
+Install from Git as a `uv` tool:
+
+```bash
+uv tool install git+ssh://git@github.com/prooflayer-ai/backend.git#subdirectory=cli
+```
+
+The CLI package declares all of its direct runtime dependencies. At the moment
+that set is `httpx`, `pydantic`, and `typer`.
+
+After installation:
+
+```bash
+asrt stacks
+asrt checkpoint --stack <stack-id> "Implemented X\nUpdated Y"
+asrt checkpoint --continue "Implemented Y"
+asrt decision --yes <checkpoint-id>   # optional, only after a failed checkpoint
+asrt verify
+```
+
+This expects the installer to already have GitHub SSH access to `prooflayer-ai/backend`.

assertion_cli-0.1.0/assertion_cli.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+README.md
+api.py
+bundle.py
+git.py
+link.py
+main.py
+models.py
+pyproject.toml
+session.py
+assertion_cli.egg-info/PKG-INFO
+assertion_cli.egg-info/SOURCES.txt
+assertion_cli.egg-info/dependency_links.txt
+assertion_cli.egg-info/entry_points.txt
+assertion_cli.egg-info/requires.txt
+assertion_cli.egg-info/top_level.txt
+templates/ACTIVATION.md
+templates/SKILL.md
+templates/__init__.py
+tests/test_api.py
+tests/test_bundle.py
+tests/test_decision.py
+tests/test_git.py
+tests/test_init.py
+tests/test_link.py
+tests/test_main.py
+tests/test_prompt.py
+tests/test_session.py
+tests/test_stack_resolve.py

assertion_cli-0.1.0/assertion_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

assertion_cli-0.1.0/assertion_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+asrt = main:app

assertion_cli-0.1.0/assertion_cli.egg-info/requires.txt

@@ -0,0 +1,8 @@
+httpx>=0.28.1
+pydantic>=2.12.5
+python-dotenv>=1.0
+typer>=0.24.1
+
+[test]
+pytest>=8.0
+respx>=0.22

assertion_cli-0.1.0/assertion_cli.egg-info/top_level.txt

@@ -0,0 +1,8 @@
+api
+assertion_cli_templates
+bundle
+git
+link
+main
+models
+session

assertion_cli-0.1.0/bundle.py

@@ -0,0 +1,26 @@
+import io
+import zipfile
+
+from models import MetadataPayload
+
+ASSERTION_DIR_NAME = ".assertion"
+DIFF_ARCHIVE_PATH = "git.diff"
+METADATA_ARCHIVE_PATH = f"{ASSERTION_DIR_NAME}/metadata.json"
+PROMPTS_ARCHIVE_PATH = f"{ASSERTION_DIR_NAME}/prompts"
+CHECKPOINT_ARCHIVE_PATH = f"{ASSERTION_DIR_NAME}/checkpoint"
+
+
+def build_bundle(
+    *,
+    metadata: MetadataPayload,
+    diff_text: str,
+    prompts_text: str,
+    checkpoint_text: str,
+) -> bytes:
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr(METADATA_ARCHIVE_PATH, metadata.model_dump_json(indent=2) + "\n")
+        zf.writestr(PROMPTS_ARCHIVE_PATH, prompts_text)
+        zf.writestr(CHECKPOINT_ARCHIVE_PATH, checkpoint_text)
+        zf.writestr(DIFF_ARCHIVE_PATH, diff_text)
+    return buf.getvalue()

assertion_cli-0.1.0/git.py

@@ -0,0 +1,189 @@
+import subprocess
+from pathlib import Path
+from typing import NoReturn, Sequence
+
+import typer
+
+
+def exit_with_error(message: str) -> NoReturn:
+    typer.echo(message, err=True)
+    raise typer.Exit(code=1)
+
+
+def run_git_command(repo_root: Path, args: Sequence[str]) -> str:
+    completed = subprocess.run(
+        ["git", *args],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if completed.returncode != 0:
+        message = completed.stderr.strip() or completed.stdout.strip() or "git failed"
+        raise RuntimeError(message)
+    return completed.stdout.strip()
+
+
+def find_git_root(start_path: Path) -> Path:
+    completed = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        cwd=start_path,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if completed.returncode != 0:
+        exit_with_error("Current directory is not inside a git repository.")
+    return Path(completed.stdout.strip())
+
+
+def require_head_pushed(repo_root: Path) -> None:
+    try:
+        remote_refs = run_git_command(
+            repo_root, ["for-each-ref", "--format=%(refname:short)", "refs/remotes"]
+        )
+    except RuntimeError as exc:
+        exit_with_error(f"Failed to inspect remote refs: {exc}")
+
+    refs = [
+        ref for ref in remote_refs.splitlines() if ref and not ref.endswith("/HEAD")
+    ]
+    if not refs:
+        exit_with_error(
+            "Current HEAD commit is not present on any remote-tracking branch."
+        )
+
+    for ref in refs:
+        completed = subprocess.run(
+            ["git", "merge-base", "--is-ancestor", "HEAD", ref],
+            cwd=repo_root,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if completed.returncode == 0:
+            return
+        if completed.returncode != 1:
+            message = (
+                completed.stderr.strip() or completed.stdout.strip() or "git failed"
+            )
+            exit_with_error(f"Failed to verify remote commit state: {message}")
+
+    exit_with_error("Current HEAD commit is not present on any remote-tracking branch.")
+
+
+def get_head_sha(repo_root: Path) -> str:
+    try:
+        return run_git_command(repo_root, ["rev-parse", "HEAD"])
+    except RuntimeError as exc:
+        exit_with_error(f"Failed to get HEAD SHA: {exc}")
+
+
+def get_head_branch(repo_root: Path) -> str | None:
+    """Return the current branch name, or None if HEAD is detached."""
+    try:
+        name = run_git_command(repo_root, ["rev-parse", "--abbrev-ref", "HEAD"])
+    except RuntimeError:
+        return None
+    return name if name and name != "HEAD" else None
+
+
+def get_origin_github_repo(repo_root: Path) -> str | None:
+    """Return the current repo's GitHub `owner/name` from origin, or None if not parseable.
+
+    Accepts the common remote URL forms:
+      git@github.com:owner/name(.git)?
+      https://github.com/owner/name(.git)?
+      ssh://git@github.com/owner/name(.git)?
+    """
+    try:
+        url = run_git_command(repo_root, ["remote", "get-url", "origin"]).strip()
+    except RuntimeError:
+        return None
+    if not url:
+        return None
+
+    if url.startswith("git@github.com:"):
+        path = url[len("git@github.com:") :]
+    elif url.startswith("ssh://git@github.com/"):
+        path = url[len("ssh://git@github.com/") :]
+    elif url.startswith("https://github.com/"):
+        path = url[len("https://github.com/") :]
+    elif url.startswith("http://github.com/"):
+        path = url[len("http://github.com/") :]
+    else:
+        return None
+
+    path = path.rstrip("/")
+    if path.endswith(".git"):
+        path = path[: -len(".git")]
+    if path.count("/") != 1 or not all(path.split("/")):
+        return None
+    return path
+
+
+def _build_untracked_diff(repo_root: Path, rel_path: str) -> str:
+    completed = subprocess.run(
+        [
+            "git",
+            "diff",
+            "--no-index",
+            "--src-prefix=a/",
+            "--dst-prefix=b/",
+            "--",
+            "/dev/null",
+            rel_path,
+        ],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if completed.returncode not in (0, 1):
+        message = completed.stderr.strip() or completed.stdout.strip() or "git failed"
+        raise RuntimeError(message)
+    return completed.stdout.strip()
+
+
+# Paths the assertion-cli owns end-to-end. Excluded from the diff bundle so
+# reviewers don't flag our own bootstrap files as "unrelated changes" — they're
+# generated/refreshed by `asrt init` and `asrt checkpoint` and have nothing to
+# do with the customer's feature work. CLAUDE.md / AGENTS.md are intentionally
+# NOT in this list: those are customer-owned files we only patch a marked
+# block into, so the customer's other edits to them should still flow through.
+_ASSERTION_EXCLUDED_PATHSPECS = [
+    ":(exclude).assertion",
+    ":(exclude).claude/skills/assertion-cli",
+    ":(exclude).agents/skills/assertion-cli",
+]
+
+
+def get_uncommitted_diff(repo_root: Path) -> str:
+    try:
+        tracked = run_git_command(
+            repo_root, ["diff", "--", *_ASSERTION_EXCLUDED_PATHSPECS]
+        )
+        staged = run_git_command(
+            repo_root, ["diff", "--cached", "--", *_ASSERTION_EXCLUDED_PATHSPECS]
+        )
+
+        untracked_output = run_git_command(
+            repo_root,
+            [
+                "ls-files",
+                "--others",
+                "--exclude-standard",
+                "--",
+                *_ASSERTION_EXCLUDED_PATHSPECS,
+            ],
+        )
+        untracked_diffs = [
+            _build_untracked_diff(repo_root, rel_path)
+            for rel_path in untracked_output.splitlines()
+            if rel_path
+        ]
+
+        parts = [p for p in [tracked, staged, "\n".join(untracked_diffs)] if p]
+        return "\n".join(parts)
+    except RuntimeError as exc:
+        exit_with_error(f"Failed to collect git diff: {exc}")

assertion_cli-0.1.0/link.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+from git import exit_with_error
+
+LINK_FILE_NAME = "link"
+
+
+def save_link(assertion_dir: Path, url: str) -> None:
+    (assertion_dir / LINK_FILE_NAME).write_text(url + "\n", encoding="utf-8")
+
+
+def load_link(assertion_dir: Path) -> str:
+    link_path = assertion_dir / LINK_FILE_NAME
+    if not link_path.exists():
+        exit_with_error(
+            "No session link found. Run `asrt verify` first to generate a link."
+        )
+    content = link_path.read_text(encoding="utf-8").strip()
+    if not content:
+        exit_with_error("Session link file is empty. Run `asrt verify` to regenerate.")
+    return content