assertion-cli 0.1.0__py3-none-any.whl

session.py

@@ -0,0 +1,220 @@
+from pathlib import Path
+
+from pydantic import ValidationError
+
+from api import AssertionClient
+from git import (
+    exit_with_error,
+    find_git_root,
+    get_origin_github_repo,
+    require_head_pushed,
+)
+from models import MetadataPayload, SessionContext, render_stack_list
+
+ASSERTION_DIR_NAME = ".assertion"
+PROMPTS_FILE_NAME = "prompts"
+CHECKPOINT_FILE_NAME = "checkpoint"
+METADATA_FILE_NAME = "metadata.json"
+
+
+def _require_repo_ready(start_path: Path) -> Path:
+    repo_root = find_git_root(start_path)
+    require_head_pushed(repo_root)
+    return repo_root
+
+
+def _load_metadata(metadata_path: Path) -> MetadataPayload | None:
+    if not metadata_path.exists():
+        return None
+    try:
+        return MetadataPayload.model_validate_json(
+            metadata_path.read_text(encoding="utf-8")
+        )
+    except (ValidationError, ValueError) as exc:
+        exit_with_error(
+            f"Corrupt {metadata_path.name}: {exc}. "
+            "Delete .assertion/ and start a new session."
+        )
+
+
+def _build_context(repo_root: Path) -> SessionContext:
+    assertion_dir = repo_root / ASSERTION_DIR_NAME
+    return SessionContext(
+        repo_root=repo_root,
+        assertion_dir=assertion_dir,
+        prompts_path=assertion_dir / PROMPTS_FILE_NAME,
+        checkpoint_path=assertion_dir / CHECKPOINT_FILE_NAME,
+        metadata_path=assertion_dir / METADATA_FILE_NAME,
+    )
+
+
+def _create_session(
+    repo_root: Path,
+    session_id: str,
+    stack_id: str,
+) -> SessionContext:
+    ctx = _build_context(repo_root)
+    ctx.assertion_dir.mkdir(exist_ok=True)
+
+    # Don't touch the prompts file — the agent appends to it via `asrt prompt`.
+    ctx.checkpoint_path.write_text("", encoding="utf-8")
+    ctx.metadata_path.write_text(
+        MetadataPayload(
+            session_id=session_id,
+            stack_id=stack_id,
+        ).model_dump_json(indent=2)
+        + "\n",
+        encoding="utf-8",
+    )
+
+    return ctx
+
+
+def _require_prompts_file(ctx: SessionContext) -> None:
+    if (
+        not ctx.prompts_path.exists()
+        or not ctx.prompts_path.read_text(encoding="utf-8").strip()
+    ):
+        exit_with_error(
+            f"ERROR: {ASSERTION_DIR_NAME}/{PROMPTS_FILE_NAME} is missing or empty.\n"
+            'Record at least one customer prompt with `asrt prompt "<message>"` before running checkpoint.'
+        )
+
+
+def _stacks_hint() -> str:
+    """Fetch available stacks and return a formatted hint for error messages."""
+    try:
+        client = AssertionClient()
+        stacks = client.stacks()
+        return (
+            "\n\nAvailable stacks:\n"
+            + render_stack_list(stacks)
+            + "\n\nTo start a new session:\n"
+            '  asrt checkpoint --stack <STACK_ID> "<progress message>"'
+        )
+    except SystemExit:
+        return (
+            "\n\nRun `asrt stacks` to see available stack IDs, then:\n"
+            '  asrt checkpoint --stack <STACK_ID> "<progress message>"'
+        )
+
+
+def resolve_stack_id_for_repo(repo_root: Path) -> str:
+    """Pick the stack whose `repo` field matches the current repo's origin.
+
+    Exits with a clear error if zero or more than one stack matches. The
+    enforcement is here (in the CLI) so the coding agent does not have to
+    follow a compliance rule — the rule is mechanical.
+    """
+    owner_name = get_origin_github_repo(repo_root)
+    if owner_name is None:
+        exit_with_error(
+            "Could not determine this repo's GitHub `owner/name` from the `origin` "
+            "remote. Pass `--stack <id>` explicitly to override."
+        )
+
+    client = AssertionClient()
+    stacks = client.stacks()
+
+    if not stacks:
+        exit_with_error(
+            "No verification stacks exist in this workspace yet. Open the "
+            "Assertion web app, create a stack, and attach this repo "
+            f"(`{owner_name}`) to it. Then re-run the command."
+        )
+
+    matches = [s for s in stacks if s.repo.strip() == owner_name]
+
+    if len(matches) == 1:
+        return matches[0].id
+    if len(matches) == 0:
+        bound_repos = sorted({s.repo.strip() for s in stacks})
+        exit_with_error(
+            f"No verification stack is attached to this repo (`{owner_name}`)."
+            f" Other stacks in this workspace are attached to: {', '.join(bound_repos)}."
+            " Open the Assertion web app, choose a stack,"
+            " and attach this repo to it. Then re-run the command."
+        )
+    # More than one match — let the agent / user pick explicitly.
+    names = ", ".join(f"{s.name} ({s.id})" for s in matches)
+    exit_with_error(
+        f"Multiple stacks are attached to `{owner_name}`: {names}. "
+        "Pass `--stack <id>` to disambiguate."
+    )
+
+
+def start_new_session(
+    *,
+    start_path: Path,
+    stack_id: str,
+) -> tuple[SessionContext, MetadataPayload]:
+    """Create a new verification session with --stack."""
+    repo_root = _require_repo_ready(start_path)
+
+    client = AssertionClient()
+    init_resp = client.init()
+
+    valid_ids = {s.id for s in init_resp.stacks}
+    if stack_id not in valid_ids:
+        exit_with_error(f"ERROR: Unknown stack '{stack_id}'." + _stacks_hint())
+
+    ctx = _create_session(
+        repo_root,
+        session_id=init_resp.session_id,
+        stack_id=stack_id,
+    )
+    _require_prompts_file(ctx)
+    metadata = _load_metadata(ctx.metadata_path)
+    assert metadata is not None
+    return ctx, metadata
+
+
+def continue_session(
+    *,
+    start_path: Path,
+) -> tuple[SessionContext, MetadataPayload]:
+    """Continue an existing session with --continue."""
+    repo_root = _require_repo_ready(start_path)
+    ctx = _build_context(repo_root)
+
+    existing = _load_metadata(ctx.metadata_path)
+    if existing is None:
+        exit_with_error("ERROR: No active session to continue." + _stacks_hint())
+
+    _require_prompts_file(ctx)
+    return ctx, existing
+
+
+def load_existing_session(start_path: Path) -> tuple[SessionContext, MetadataPayload]:
+    """Load an existing session or fail. Used by verify."""
+    repo_root = _require_repo_ready(start_path)
+    ctx = _build_context(repo_root)
+
+    existing = _load_metadata(ctx.metadata_path)
+    if existing is None:
+        exit_with_error(
+            "ERROR: No active session. Run a checkpoint first." + _stacks_hint()
+        )
+
+    return ctx, existing
+
+
+def append_checkpoint_entry(checkpoint_path: Path, message: str) -> None:
+    normalized = message.rstrip("\n")
+    if not normalized.strip():
+        exit_with_error("Checkpoint message must not be empty.")
+    with checkpoint_path.open("a", encoding="utf-8") as f:
+        f.write(f"{normalized}\n\n")
+
+
+def update_metadata_head(
+    metadata_path: Path,
+    metadata: MetadataPayload,
+    head_sha: str,
+    head_branch: str | None = None,
+) -> MetadataPayload:
+    updated = metadata.model_copy(
+        update={"head_sha": head_sha, "head_branch": head_branch}
+    )
+    metadata_path.write_text(updated.model_dump_json(indent=2) + "\n", encoding="utf-8")
+    return updated