assertion-cli 0.5.4__tar.gz → 0.5.5__tar.gz

{assertion_cli-0.5.4 → assertion_cli-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.4
+Version: 0.5.5
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
@@ -39,6 +39,7 @@ that set is `httpx`, `pydantic`, `python-dotenv`, and `typer`.
 After installation:
 
 ```bash
+asrt new                               # reset local run state for a fresh session
 asrt stacks
 asrt checkpoint --stack <stack-id> "Implemented X\nUpdated Y"
 asrt checkpoint --continue "Implemented Y"
@@ -49,13 +50,19 @@ asrt verify-status                     # one-shot poll; loop with your own sleep
 
 ## Publishing a new version
 
-```bash
-# 1. Bump the version in cli/pyproject.toml.
-# 2. Build the sdist + wheel.
-uv build --package assertion-cli
-# 3. Upload (requires UV_PUBLISH_TOKEN, or `--token` on the command).
-uv publish dist/*
-# 4. Tag the release so consumers can correlate to git:
-git tag cli-v$(grep '^version = ' pyproject.toml | head -1 | cut -d'"' -f2)
-git push origin --tags
-```
+1. **Bump the version** in `cli/pyproject.toml`.
+2. **Commit and push** to `main`.
+
+That's it. The `Publish CLI to PyPI` workflow auto-triggers on pushes that
+change `cli/pyproject.toml`. It reads the version from the file, runs tests,
+builds, publishes to PyPI, pushes a `cli-v<version>` tag, and creates a
+GitHub Release with auto-generated notes.
+
+If the version hasn't changed (e.g. you updated a dependency), the workflow
+skips publishing — only version bumps trigger a release.
+
+You can also trigger the workflow manually from the GitHub Actions UI — it
+reads the version from the current `pyproject.toml` on `main`.
+
+**Prerequisite**: `PYPI_TOKEN` must be set as a GitHub Actions secret — a
+PyPI API token with upload scope for `assertion-cli`.

{assertion_cli-0.5.4 → assertion_cli-0.5.5}/README.md

@@ -25,6 +25,7 @@ that set is `httpx`, `pydantic`, `python-dotenv`, and `typer`.
 After installation:
 
 ```bash
+asrt new                               # reset local run state for a fresh session
 asrt stacks
 asrt checkpoint --stack <stack-id> "Implemented X\nUpdated Y"
 asrt checkpoint --continue "Implemented Y"
@@ -35,13 +36,19 @@ asrt verify-status                     # one-shot poll; loop with your own sleep
 
 ## Publishing a new version
 
-```bash
-# 1. Bump the version in cli/pyproject.toml.
-# 2. Build the sdist + wheel.
-uv build --package assertion-cli
-# 3. Upload (requires UV_PUBLISH_TOKEN, or `--token` on the command).
-uv publish dist/*
-# 4. Tag the release so consumers can correlate to git:
-git tag cli-v$(grep '^version = ' pyproject.toml | head -1 | cut -d'"' -f2)
-git push origin --tags
-```
+1. **Bump the version** in `cli/pyproject.toml`.
+2. **Commit and push** to `main`.
+
+That's it. The `Publish CLI to PyPI` workflow auto-triggers on pushes that
+change `cli/pyproject.toml`. It reads the version from the file, runs tests,
+builds, publishes to PyPI, pushes a `cli-v<version>` tag, and creates a
+GitHub Release with auto-generated notes.
+
+If the version hasn't changed (e.g. you updated a dependency), the workflow
+skips publishing — only version bumps trigger a release.
+
+You can also trigger the workflow manually from the GitHub Actions UI — it
+reads the version from the current `pyproject.toml` on `main`.
+
+**Prerequisite**: `PYPI_TOKEN` must be set as a GitHub Actions secret — a
+PyPI API token with upload scope for `assertion-cli`.

{assertion_cli-0.5.4 → assertion_cli-0.5.5}/assertion_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.4
+Version: 0.5.5
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
@@ -39,6 +39,7 @@ that set is `httpx`, `pydantic`, `python-dotenv`, and `typer`.
 After installation:
 
 ```bash
+asrt new                               # reset local run state for a fresh session
 asrt stacks
 asrt checkpoint --stack <stack-id> "Implemented X\nUpdated Y"
 asrt checkpoint --continue "Implemented Y"
@@ -49,13 +50,19 @@ asrt verify-status                     # one-shot poll; loop with your own sleep
 
 ## Publishing a new version
 
-```bash
-# 1. Bump the version in cli/pyproject.toml.
-# 2. Build the sdist + wheel.
-uv build --package assertion-cli
-# 3. Upload (requires UV_PUBLISH_TOKEN, or `--token` on the command).
-uv publish dist/*
-# 4. Tag the release so consumers can correlate to git:
-git tag cli-v$(grep '^version = ' pyproject.toml | head -1 | cut -d'"' -f2)
-git push origin --tags
-```
+1. **Bump the version** in `cli/pyproject.toml`.
+2. **Commit and push** to `main`.
+
+That's it. The `Publish CLI to PyPI` workflow auto-triggers on pushes that
+change `cli/pyproject.toml`. It reads the version from the file, runs tests,
+builds, publishes to PyPI, pushes a `cli-v<version>` tag, and creates a
+GitHub Release with auto-generated notes.
+
+If the version hasn't changed (e.g. you updated a dependency), the workflow
+skips publishing — only version bumps trigger a release.
+
+You can also trigger the workflow manually from the GitHub Actions UI — it
+reads the version from the current `pyproject.toml` on `main`.
+
+**Prerequisite**: `PYPI_TOKEN` must be set as a GitHub Actions secret — a
+PyPI API token with upload scope for `assertion-cli`.

{assertion_cli-0.5.4 → assertion_cli-0.5.5}/assertion_cli.egg-info/SOURCES.txt

@@ -23,5 +23,6 @@ tests/test_git.py
 tests/test_init.py
 tests/test_link.py
 tests/test_main.py
+tests/test_new.py
 tests/test_prompt.py
 tests/test_session.py

{assertion_cli-0.5.4 → assertion_cli-0.5.5}/main.py

@@ -3,33 +3,13 @@ import importlib.metadata
 import importlib.resources
 import json
 import re
+import shutil
 from datetime import datetime, timezone
 from pathlib import Path
 
 import httpx
 import typer
 
-
-_VERSION: str | None = None
-
-
-def _get_version() -> str:
-    global _VERSION
-    if _VERSION is not None:
-        return _VERSION
-    try:
-        _VERSION = importlib.metadata.version("assertion-cli")
-    except importlib.metadata.PackageNotFoundError:
-        pyproject = Path(__file__).resolve().parent / "pyproject.toml"
-        if pyproject.exists():
-            import tomllib
-
-            data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
-            _VERSION = data["project"]["version"]
-        else:
-            _VERSION = "0.0.0"
-    return _VERSION
-
 from api import AssertionClient
 from bundle import build_bundle
 from git import (
@@ -54,6 +34,27 @@ from session import (
     update_metadata_anchor,
 )
 
+_VERSION: str | None = None
+
+
+def _get_version() -> str:
+    global _VERSION
+    if _VERSION is not None:
+        return _VERSION
+    try:
+        _VERSION = importlib.metadata.version("assertion-cli")
+    except importlib.metadata.PackageNotFoundError:
+        pyproject = Path(__file__).resolve().parent / "pyproject.toml"
+        if pyproject.exists():
+            import tomllib
+
+            data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+            _VERSION = data["project"]["version"]
+        else:
+            _VERSION = "0.0.0"
+    return _VERSION
+
+
 app = typer.Typer(help="Assertion CLI")
 
 
@@ -261,6 +262,31 @@ def init() -> None:
     typer.echo("  - asrt verify at completion, then PR")
 
 
+@app.command("new")
+def new() -> None:
+    """Reset local Assertion run state and record current HEAD as the diff base."""
+    repo_root = find_git_root(Path.cwd())
+    base_sha = get_head_sha(repo_root)
+    assertion_dir = repo_root / ASSERTION_DIR_NAME
+    assertion_dir.mkdir(exist_ok=True)
+
+    removed = 0
+    for child in assertion_dir.iterdir():
+        if child.is_dir():
+            shutil.rmtree(child)
+        else:
+            child.unlink()
+        removed += 1
+
+    base_sha_path = assertion_dir / BASE_SHA_FILE_NAME
+    base_sha_path.write_text(base_sha + "\n", encoding="utf-8")
+
+    typer.echo(f"Cleared {removed} .assertion entr{'y' if removed == 1 else 'ies'}.")
+    typer.echo(
+        f"Recorded diff base {base_sha[:12]} → {base_sha_path.relative_to(repo_root)}"
+    )
+
+
 @app.command("prompt")
 def prompt_cmd(
     text: str = typer.Argument(..., help="User prompt text to record."),

{assertion_cli-0.5.4 → assertion_cli-0.5.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "assertion-cli"
-version = "0.5.4"
+version = "0.5.5"
 description = "CLI for the Assertion API"
 readme = "README.md"
 requires-python = ">=3.13"

{assertion_cli-0.5.4 → assertion_cli-0.5.5}/templates/SKILL.md

@@ -16,9 +16,9 @@ Before any `asrt` call:
 - You are inside a git repository.
 - `asrt init` has been run in this repo. It records the current HEAD as the diff base that every checkpoint/verify diffs against, and installs the skill files you are reading right now. If `asrt checkpoint` or `asrt verify` errors with "No diff base recorded", run `asrt init` and retry.
 
-**Starting a fresh session:** when beginning a new session, delete the contents of `.assertion/` first. This clears the previous session's in-flight state (metadata, prompts log, link) so a new session starts clean and anchors to the stack you pick on the first checkpoint. Only the user should do this — it resets the session.
+**Starting a fresh session:** when beginning a new session, run `asrt new` first. This clears the previous session's in-flight state (metadata, prompts log, link, verification status, screenshots) and records the current `HEAD` as the new diff base, so a new session starts clean on the current branch and anchors to the stack you pick on the first checkpoint. Only the user should do this — it resets the session.
 
-Treat `.assertion/metadata.json`, `.assertion/prompts`, and `.assertion/base_sha` as internal state owned by the CLI. Do not create, edit, or delete those files manually — use `asrt prompt` to append to the prompts log.
+Treat `.assertion/metadata.json`, `.assertion/prompts`, and `.assertion/base_sha` as internal state owned by the CLI. Do not create, edit, or delete those files manually — use `asrt prompt` to append to the prompts log and `asrt new` to reset for a fresh session.
 
 `asrt stacks` is read-only and lists every verification stack in the user's workspace, along with the repo each is configured for. Run it once per session before your first checkpoint so you can pick a stack ID; do not hardcode IDs from memory.
 
@@ -105,7 +105,7 @@ When you pass `--stack`, briefly state which stack you chose and why ("Picked st
 | CLI error starts with | What it means | What to do |
 |---|---|---|
 | `No session exists yet and no --stack given.` | First checkpoint of a fresh `.assertion/`, but you didn't pick a stack. | Run `asrt stacks`, pick one using the signals above, pass `--stack <id>`. |
-| `This session is already anchored to a stack.` | You passed `--stack` after a session was already created. The CLI locks the stack at session creation. | Drop the `--stack` flag and re-run `asrt checkpoint "<message>"`. |
+| `This session is already anchored to a stack.` | You passed `--stack` after a session was already created. The CLI locks the stack at session creation. | Drop the `--stack` flag and re-run `asrt checkpoint "<message>"`, or ask the user to run `asrt new` if this should be a fresh session. |
 | `ERROR: Unknown stack '<id>'.` | The `--stack` you passed is not in the workspace. | Re-run `asrt stacks` (the list may have changed) and pass a valid id. |
 | `No diff base recorded for this repo.` | `asrt init` wasn't run. | Run `asrt init` and retry. |
 | `ERROR: No active session to continue.` | You passed `--continue` but there is no session. | Drop `--continue` and pass `--stack <id>` to start one. |

assertion_cli-0.5.5/tests/test_new.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+import main
+
+
+runner = CliRunner()
+
+_GIT_COMMIT_ENV = {
+    "GIT_AUTHOR_NAME": "T",
+    "GIT_AUTHOR_EMAIL": "t@t",
+    "GIT_COMMITTER_NAME": "T",
+    "GIT_COMMITTER_EMAIL": "t@t",
+    "PATH": "/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin",
+}
+
+
+def _run_git(repo: Path, *args: str) -> str:
+    result = subprocess.run(
+        ["git", *args],
+        cwd=repo,
+        capture_output=True,
+        check=True,
+        env={**_GIT_COMMIT_ENV, "HOME": str(repo)},
+        text=True,
+    )
+    return result.stdout.strip()
+
+
+def _init_repo(tmp_path: Path) -> str:
+    _run_git(tmp_path, "init")
+    _run_git(tmp_path, "commit", "--allow-empty", "-m", "init")
+    return _run_git(tmp_path, "rev-parse", "HEAD")
+
+
+def test_new_clears_run_state_and_records_current_head(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    head = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    assertion_dir = tmp_path / ".assertion"
+    (assertion_dir / "screenshots" / "verification-1").mkdir(parents=True)
+    (assertion_dir / "metadata.json").write_text("{}")
+    (assertion_dir / "prompts").write_text("old prompt")
+    (assertion_dir / "checkpoint").write_text("old checkpoint")
+    (assertion_dir / "link").write_text("old link")
+    (assertion_dir / "verify_session_id").write_text("old verification")
+    (assertion_dir / "base_sha").write_text("old-base")
+    (
+        assertion_dir / "screenshots" / "verification-1" / "screenshot_000.png"
+    ).write_bytes(b"png")
+
+    result = runner.invoke(main.app, ["new"])
+
+    assert result.exit_code == 0, result.stderr
+    assert (assertion_dir / "base_sha").read_text() == head + "\n"
+    assert not (assertion_dir / "metadata.json").exists()
+    assert not (assertion_dir / "prompts").exists()
+    assert not (assertion_dir / "checkpoint").exists()
+    assert not (assertion_dir / "link").exists()
+    assert not (assertion_dir / "verify_session_id").exists()
+    assert not (assertion_dir / "screenshots").exists()
+    assert "Recorded diff base" in result.stdout
+
+
+def test_new_succeeds_when_assertion_dir_missing(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    head = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["new"])
+
+    assert result.exit_code == 0, result.stderr
+    assert (tmp_path / ".assertion" / "base_sha").read_text() == head + "\n"
+
+
+def test_new_updates_base_sha_after_head_changes(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    first_head = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    first_result = runner.invoke(main.app, ["new"])
+    assert first_result.exit_code == 0, first_result.stderr
+    assert (tmp_path / ".assertion" / "base_sha").read_text() == first_head + "\n"
+
+    _run_git(tmp_path, "commit", "--allow-empty", "-m", "second")
+    second_head = _run_git(tmp_path, "rev-parse", "HEAD")
+
+    second_result = runner.invoke(main.app, ["new"])
+
+    assert second_result.exit_code == 0, second_result.stderr
+    assert second_head != first_head
+    assert (tmp_path / ".assertion" / "base_sha").read_text() == second_head + "\n"
+
+
+def test_new_leaves_next_checkpoint_requiring_stack(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    assertion_dir = tmp_path / ".assertion"
+    assertion_dir.mkdir()
+    (assertion_dir / "metadata.json").write_text("{}")
+    (assertion_dir / "prompts").write_text("old prompt")
+
+    result = runner.invoke(main.app, ["new"])
+
+    assert result.exit_code == 0, result.stderr
+    assert not (assertion_dir / "metadata.json").exists()