assertion-cli 0.5.8__tar.gz → 0.5.10__tar.gz

{assertion_cli-0.5.8 → assertion_cli-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.8
+Version: 0.5.10
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{assertion_cli-0.5.8 → assertion_cli-0.5.10}/assertion_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.8
+Version: 0.5.10
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{assertion_cli-0.5.8 → assertion_cli-0.5.10}/bundle.py

@@ -6,6 +6,7 @@ from models import MetadataPayload
 
 ASSERTION_DIR_NAME = ".assertion"
 DIFF_ARCHIVE_PATH = "git.diff"
+UNCOMMITTED_DIFF_ARCHIVE_PATH = "uncommitted.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"
@@ -30,6 +31,7 @@ def build_bundle(
     *,
     metadata: MetadataPayload,
     diff_text: str,
+    uncommitted_diff_text: str,
     prompts_text: str,
     checkpoint_text: str,
 ) -> bytes:
@@ -39,4 +41,5 @@ def build_bundle(
         zf.writestr(PROMPTS_ARCHIVE_PATH, prompts_text)
         zf.writestr(CHECKPOINT_ARCHIVE_PATH, checkpoint_text)
         zf.writestr(DIFF_ARCHIVE_PATH, diff_text)
+        zf.writestr(UNCOMMITTED_DIFF_ARCHIVE_PATH, uncommitted_diff_text)
     return buf.getvalue()

assertion_cli-0.5.10/git.py

@@ -0,0 +1,247 @@
+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], *, preserve_stdout: bool = False
+) -> 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 if preserve_stdout else 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 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_upstream_ref(repo_root: Path) -> str | None:
+    """Return the upstream tracking ref (e.g. ``origin/main``).
+
+    Tries HEAD's configured upstream first, then falls through increasingly
+    general heuristics to find a remote ref to compute a merge-base against:
+    same-named remote branch, closest remote ancestor (via
+    ``git branch -r --merged HEAD`` + ``git merge-base``), then well-known
+    default branch names. Returns ``None`` when none are available.
+    """
+
+    # 1. Configured upstream (git branch -u).
+    try:
+        return run_git_command(
+            repo_root, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]
+        )
+    except RuntimeError:
+        pass
+
+    # 2. Same branch name on remote (has been pushed at least once).
+    head_branch = get_head_branch(repo_root)
+    if head_branch is not None:
+        fallback = f"origin/{head_branch}"
+        try:
+            run_git_command(repo_root, ["rev-parse", "--verify", fallback])
+        except RuntimeError:
+            pass
+        else:
+            return fallback
+
+    # 3. Closest remote ancestor — handles branches based on other pushed
+    #    branches (e.g. my-feature on my-feature-base). Uses --merged HEAD
+    #    so only remote branches in HEAD's ancestry are considered; a branch
+    #    whose tip moved forward after we branched off is correctly excluded.
+    try:
+        merged = run_git_command(
+            repo_root,
+            [
+                "branch", "-r", "--merged", "HEAD",
+                "--format=%(refname:short)",
+            ],
+        )
+        ancestors = [r for r in merged.splitlines() if r]
+        if ancestors:
+            return run_git_command(
+                repo_root, ["merge-base", "HEAD", *ancestors]
+            )
+    except RuntimeError:
+        pass
+
+    # 4. Remote's default branch (symbolic ref, usually origin/main).
+    try:
+        run_git_command(repo_root, ["rev-parse", "--verify", "origin/HEAD"])
+    except RuntimeError:
+        pass
+    else:
+        return "origin/HEAD"
+
+    # 5. Conventional default branch name.
+    try:
+        run_git_command(repo_root, ["rev-parse", "--verify", "origin/main"])
+    except RuntimeError:
+        pass
+    else:
+        return "origin/main"
+
+    # 6. Legacy default branch name.
+    try:
+        run_git_command(repo_root, ["rev-parse", "--verify", "origin/master"])
+    except RuntimeError:
+        pass
+    else:
+        return "origin/master"
+
+    return None
+
+
+def get_merge_base(repo_root: Path, upstream: str) -> str:
+    """Return the merge-base of ``HEAD`` and *upstream*."""
+    try:
+        return run_git_command(repo_root, ["merge-base", "HEAD", upstream])
+    except RuntimeError as exc:
+        exit_with_error(
+            f"Failed to compute merge-base between HEAD and {upstream}: {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 _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
+
+
+# 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 by `asrt install` and have nothing to do with the user's feature
+# work. CLAUDE.md / AGENTS.md are intentionally NOT in this list: `asrt install`
+# writes a small pointer block into them once at onboarding (meant to be
+# committed before work starts, so it never shows in a work-session diff), but
+# the rest of those files is the user's own and must flow through to reviewers.
+_ASSERTION_EXCLUDED_PATHSPECS = [
+    ":(exclude).assertion",
+    ":(exclude).claude/skills/assertion-cli",
+    ":(exclude).agents/skills/assertion-cli",
+]
+
+
+def _build_tracked_diff(repo_root: Path, base: str) -> str:
+    """``git diff <base>`` for tracked files, excluding assertion-owned paths."""
+    return run_git_command(
+        repo_root,
+        ["diff", base, "--", *_ASSERTION_EXCLUDED_PATHSPECS],
+        preserve_stdout=True,
+    )
+
+
+def _build_untracked_diffs(repo_root: Path) -> list[str]:
+    """Diff of every untracked (but non-ignored) file as a new-file diff."""
+    output = run_git_command(
+        repo_root,
+        [
+            "ls-files",
+            "--others",
+            "--exclude-standard",
+            "--",
+            *_ASSERTION_EXCLUDED_PATHSPECS,
+        ],
+    )
+    return [
+        _build_untracked_diff(repo_root, rel_path)
+        for rel_path in output.splitlines()
+        if rel_path
+    ]
+
+
+def _join_diffs(parts: list[str]) -> str:
+    parts = [_ensure_trailing_newline(p) for p in parts if p]
+    return "".join(parts)
+
+
+def get_uncommitted_diff(repo_root: Path) -> str:
+    """Build a diff of **only uncommitted** changes (staged + unstaged +
+    untracked).
+
+    ``git diff HEAD`` compares the working tree directly to ``HEAD``, so
+    local commits are excluded — only changes the agent hasn't committed yet
+    appear.
+    """
+    try:
+        tracked = _build_tracked_diff(repo_root, "HEAD")
+        untracked = _build_untracked_diffs(repo_root)
+        return _join_diffs([tracked, *untracked])
+    except RuntimeError as exc:
+        exit_with_error(f"Failed to collect uncommitted diff: {exc}")
+
+
+def get_full_diff(repo_root: Path, base_sha: str) -> str:
+    """Build a unified diff from ``base_sha`` to the current working tree.
+
+    ``git diff <base_sha>`` captures everything since the base commit —
+    local commits, staged changes, unstaged changes, and untracked files.
+    This is the diff the backend uses to reconstruct the full working state
+    (for terminal/browser sandboxes).
+    """
+    try:
+        tracked = _build_tracked_diff(repo_root, base_sha)
+        untracked = _build_untracked_diffs(repo_root)
+        return _join_diffs([tracked, *untracked])
+    except RuntimeError as exc:
+        exit_with_error(f"Failed to collect full diff: {exc}")
+
+
+def _ensure_trailing_newline(value: str) -> str:
+    return value if value.endswith("\n") else value + "\n"

{assertion_cli-0.5.8 → assertion_cli-0.5.10}/main.py

@@ -14,9 +14,12 @@ from bundle import build_bundle
 from git import (
     exit_with_error,
     find_git_root,
+    get_full_diff,
     get_head_branch,
-    get_head_sha,
+    get_merge_base,
     get_uncommitted_diff,
+    get_upstream_ref,
+    run_git_command,
 )
 from link import load_link, save_link
 from models import CheckpointResponse, SessionStatus, render_stack_list
@@ -260,13 +263,42 @@ session_app = typer.Typer(help="Manage Assertion work sessions.")
 app.add_typer(session_app, name="session")
 
 
+def _resolve_diff_base(repo_root: Path) -> str:
+    """Compute the merge-base with the upstream tracking branch.
+
+    Fetches from origin first so the merge-base SHA is guaranteed to exist
+    on the remote when the backend checks it out — stale remote tracking
+    refs (from a force-pushed or rebased branch) would otherwise produce a
+    merge-base that's no longer reachable from any remote ref.
+
+    Errors out when no upstream can be resolved (detached HEAD, no tracking
+    branch, branch not pushed to remote).
+    """
+    try:
+        run_git_command(repo_root, ["fetch", "--no-tags", "origin"])
+    except RuntimeError:
+        pass  # non-fatal: offline or unavailable; proceed with stale refs
+
+    upstream = get_upstream_ref(repo_root)
+    if upstream is None:
+        exit_with_error(
+            "Cannot determine the diff base: no upstream tracking branch found.\n"
+            "Make sure you are on a branch that has been pushed to a remote "
+            "with a tracking branch configured, e.g.:\n"
+            "  git push -u origin <branch>\n"
+            "Or use an existing branch that tracks an upstream.",
+        )
+    return get_merge_base(repo_root, upstream)
+
+
 @session_app.command("start")
 def session_start() -> None:
-    """Record the current HEAD SHA as the diff base for this repo's work session.
+    """Record the merge-base with the upstream tracking branch as the diff base.
 
-    The base is what the backend `git checkout`s against before applying the
-    diff — capturing it once here means later commands don't need to rediscover
-    it (which previously broke in sandboxes with no remote-tracking refs).
+    Unlike the old HEAD-based approach, the merge-base always exists on the
+    remote so the backend can check it out. Branches without a remote tracking
+    ref (detached HEAD, no upstream, not pushed) are rejected with a clear
+    message — run ``asrt session start`` from a branch with an upstream.
 
     `session start` does not write skill files — that is `asrt install`, the
     one-time onboarding step. It also never touches user content in `CLAUDE.md` /
@@ -276,7 +308,7 @@ def session_start() -> None:
     repo_root = find_git_root(Path.cwd())
     _ensure_gitignore_limits_assertion_state(repo_root)
 
-    base_sha = get_head_sha(repo_root)
+    base_sha = _resolve_diff_base(repo_root)
     assertion_dir = repo_root / ASSERTION_DIR_NAME
     assertion_dir.mkdir(exist_ok=True)
     base_sha_path = assertion_dir / BASE_SHA_FILE_NAME
@@ -294,9 +326,9 @@ def session_start() -> None:
 
 @app.command("new")
 def new() -> None:
-    """Reset local Assertion run state and record current HEAD as the diff base."""
+    """Reset local Assertion run state and record the merge-base as the diff base."""
     repo_root = find_git_root(Path.cwd())
-    base_sha = get_head_sha(repo_root)
+    base_sha = _resolve_diff_base(repo_root)
     assertion_dir = repo_root / ASSERTION_DIR_NAME
     assertion_dir.mkdir(exist_ok=True)
 
@@ -401,13 +433,10 @@ def checkpoint(
     assert stack_id is not None
 
     append_checkpoint_entry(ctx.checkpoint_path, message)
-    # Base SHA is whatever `asrt session start` recorded for this repo. Backend
-    # uses it as the checkout target before applying the diff. Pinning it at
-    # session-start time (instead of rediscovering per command) means sandboxes
-    # without remote-tracking refs — e.g. Codex Cloud — still work.
     base_sha = read_init_base_sha(ctx.assertion_dir)
     head_branch = get_head_branch(ctx.repo_root)
-    diff_text = get_uncommitted_diff(ctx.repo_root, base_sha)
+    diff_text = get_full_diff(ctx.repo_root, base_sha)
+    uncommitted_diff_text = get_uncommitted_diff(ctx.repo_root)
     metadata = update_metadata_anchor(
         ctx.metadata_path, metadata, base_sha, head_branch=head_branch
     )
@@ -415,6 +444,7 @@ def checkpoint(
     bundle_bytes = build_bundle(
         metadata=metadata,
         diff_text=diff_text,
+        uncommitted_diff_text=uncommitted_diff_text,
         prompts_text=ctx.prompts_path.read_text(encoding="utf-8"),
         checkpoint_text=message,
     )
@@ -505,11 +535,10 @@ def verify(
     ctx, metadata = load_existing_session(Path.cwd())
     stack_id = metadata.stack_id
     assert stack_id is not None
-    # See checkpoint() for why the base is the SHA `asrt session start`
-    # recorded, not local HEAD.
     base_sha = read_init_base_sha(ctx.assertion_dir)
     head_branch = get_head_branch(ctx.repo_root)
-    diff_text = get_uncommitted_diff(ctx.repo_root, base_sha)
+    diff_text = get_full_diff(ctx.repo_root, base_sha)
+    uncommitted_diff_text = get_uncommitted_diff(ctx.repo_root)
     metadata = update_metadata_anchor(
         ctx.metadata_path, metadata, base_sha, head_branch=head_branch
     )
@@ -517,6 +546,7 @@ def verify(
     bundle_bytes = build_bundle(
         metadata=metadata,
         diff_text=diff_text,
+        uncommitted_diff_text=uncommitted_diff_text,
         prompts_text=ctx.prompts_path.read_text(encoding="utf-8"),
         checkpoint_text=ctx.checkpoint_path.read_text(encoding="utf-8"),
     )

{assertion_cli-0.5.8 → assertion_cli-0.5.10}/pyproject.toml

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

{assertion_cli-0.5.8 → assertion_cli-0.5.10}/session.py

@@ -19,15 +19,16 @@ BASE_SHA_FILE_NAME = "base_sha"
 def read_init_base_sha(assertion_dir: Path) -> str:
     """Return the diff base SHA recorded by `asrt session start`.
 
-    Exits with a clear error if `asrt session start` hasn't been run or the file
-    is empty. The base SHA is the commit the backend `git checkout`s against
-    before applying the diff, so every checkpoint/verify must have it.
+    The base SHA is the merge-base with the upstream tracking branch — always
+    fetchable from the remote. Every checkpoint/verify reads this value; it
+    never changes within a session.
     """
     path = assertion_dir / BASE_SHA_FILE_NAME
     if not path.exists():
         exit_with_error(
             "No diff base recorded for this repo. Run `asrt session start` "
-            "first — it captures the HEAD SHA that checkpoint/verify diff against."
+            "first — it captures the merge-base SHA that checkpoint/verify "
+            "diff against."
         )
     content = path.read_text(encoding="utf-8").strip()
     if not content:

{assertion_cli-0.5.8 → assertion_cli-0.5.10}/tests/test_bundle.py

@@ -15,6 +15,7 @@ def test_build_bundle_writes_session_metadata() -> None:
     bundle_bytes = build_bundle(
         metadata=metadata,
         diff_text="diff --git a/file b/file",
+        uncommitted_diff_text="diff --git a/file b/file",
         prompts_text='{"ts": "2026-05-28T14:32:01Z", "text": "Do the thing"}\n',
         checkpoint_text="Checkpoint text",
     )
@@ -31,3 +32,10 @@ def test_build_bundle_writes_session_metadata() -> None:
 
         prompts_raw = zf.read(".assertion/prompts").decode("utf-8")
         assert '"text": "Do the thing"' in prompts_raw
+
+        # Both diffs are included in the bundle.
+        git_diff = zf.read("git.diff").decode("utf-8")
+        assert "diff --git a/file b/file" in git_diff
+
+        uncommitted_diff = zf.read("uncommitted.diff").decode("utf-8")
+        assert "diff --git a/file b/file" in uncommitted_diff