whiletrue 0.1.0__py3-none-any.whl

whiletrue/git/modules.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from whiletrue.basics.process import run_command, tail
+from whiletrue.core import (
+    ActionModule,
+    Emit,
+    Ports,
+    PortSpec,
+    StepContext,
+    define_action,
+)
+from whiletrue.core.module import PortValues
+
+
+class CommitConfig(BaseModel):
+    message: str = Field(min_length=1)
+    #: Paths to stage (`.` stages everything, including deletions).
+    add: list[str] = Field(default_factory=lambda: ["."])
+    #: Commit even when nothing changed.
+    allow_empty: bool = False
+
+
+class CommitPushConfig(CommitConfig):
+    remote: str = "origin"
+
+
+class DiffConfig(BaseModel):
+    base: str = "HEAD"
+    #: Include the unified diff text in the output.
+    patch: bool = False
+
+
+async def _git(ctx: StepContext[Any], *args: str) -> tuple[int | None, str, str]:
+    result = await run_command("git", list(args), cwd=ctx.cwd, signal=ctx.signal)
+    return result.code, result.stdout, result.stderr
+
+
+async def _commit(ctx: StepContext[Any], cfg: CommitConfig) -> Emit:
+    code, _, err = await _git(ctx, "add", "-A", "--", *cfg.add)
+    if code != 0:
+        return Emit("fail", {"error": f"git add failed: {tail(err)}"})
+    staged, _, _ = await _git(ctx, "diff", "--cached", "--quiet")
+    if staged == 0 and not cfg.allow_empty:
+        return Emit(
+            "ok", {"committed": False, "sha": (await _git(ctx, "rev-parse", "HEAD"))[1].strip()}
+        )
+    args = ["commit", "-m", cfg.message]
+    if cfg.allow_empty:
+        args.append("--allow-empty")
+    code, out, err = await _git(ctx, *args)
+    if code != 0:
+        return Emit("fail", {"error": f"git commit failed: {tail(err or out)}"})
+    sha = (await _git(ctx, "rev-parse", "HEAD"))[1].strip()
+    return Emit("ok", {"committed": True, "sha": sha})
+
+
+async def _commit_run(input: PortValues, ctx: StepContext[CommitConfig]) -> Emit:
+    return await _commit(ctx, ctx.config)
+
+
+async def _commit_push_run(input: PortValues, ctx: StepContext[CommitPushConfig]) -> Emit:
+    made = await _commit(ctx, ctx.config)
+    if made.port != "ok":
+        return made
+    code, out, err = await _git(ctx, "push", "-u", ctx.config.remote, "HEAD")
+    if code != 0:
+        return Emit("fail", {"error": f"git push failed: {tail(err or out)}"})
+    return Emit("ok", {**made.value, "pushed": True})
+
+
+async def _diff_run(input: PortValues, ctx: StepContext[DiffConfig]) -> Emit:
+    code, out, err = await _git(ctx, "diff", "--numstat", ctx.config.base)
+    if code != 0:
+        return Emit("fail", {"error": f"git diff failed: {tail(err)}"})
+    files: list[dict[str, Any]] = []
+    for line in out.splitlines():
+        added, removed, path = line.split("\t", 2)
+        files.append(
+            {
+                "path": path,
+                "additions": 0 if added == "-" else int(added),
+                "deletions": 0 if removed == "-" else int(removed),
+            }
+        )
+    value: dict[str, Any] = {"files": files}
+    if ctx.config.patch:
+        value["patch"] = (await _git(ctx, "diff", ctx.config.base))[1]
+    return Emit("ok", value)
+
+
+_ANY = Ports(inputs=[PortSpec("in", "Any")], outputs=[PortSpec("out", "Any")])
+
+git_commit_module: ActionModule[CommitConfig] = define_action(
+    ActionModule(
+        id="git.commit",
+        config=CommitConfig,
+        ports=_ANY,
+        effects="side-effect",
+        cacheable=False,
+        idempotency_key=lambda _i, ctx: f"git.commit:{ctx.step_key}",
+        run=_commit_run,
+    )
+)
+git_commit_push_module: ActionModule[CommitPushConfig] = define_action(
+    ActionModule(
+        id="git.commit_push",
+        config=CommitPushConfig,
+        ports=_ANY,
+        effects="side-effect",
+        cacheable=False,
+        idempotency_key=lambda _i, ctx: f"git.commit_push:{ctx.step_key}",
+        run=_commit_push_run,
+    )
+)
+git_diff_module: ActionModule[DiffConfig] = define_action(
+    ActionModule(
+        id="git.diff",
+        config=DiffConfig,
+        ports=Ports(inputs=[PortSpec("in", "Any")], outputs=[PortSpec("out", "Diff")]),
+        effects="deterministic",
+        cacheable=False,
+        run=_diff_run,
+    )
+)

whiletrue/git/workspaces.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import asyncio
+import re
+import shutil
+from pathlib import Path
+from typing import Any
+
+from whiletrue.basics.process import run_command, tail
+from whiletrue.core import ItemState, Workspace, WorkspaceError
+
+
+def _safe(name: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_.-]+", "_", name) or "item"
+
+
+async def _git(cwd: str, *args: str) -> str:
+    result = await run_command("git", list(args), cwd=cwd)
+    if result.code != 0:
+        raise WorkspaceError(f"git {args[0]} failed: {tail(result.stderr or result.stdout)}")
+    return result.stdout
+
+
+class GitWorktree:
+    """One git worktree per item, on its own branch, under `.whiletrue/worktrees/`.
+
+    An existing worktree is reused, so a resumed run continues where the parked one left off.
+    A finished (`done`) item's worktree is removed; its branch stays.
+    """
+
+    async def create(self, config: dict[str, Any], item: dict[str, Any], cwd: str) -> Workspace:
+        item_id = str(item.get("id", "item"))
+        branch = str(config.get("branch") or f"wt/{item_id}")
+        base = str(config.get("base") or "HEAD")
+        root = Path(cwd) / str(config.get("dir") or ".whiletrue/worktrees")
+        path = root / _safe(item_id)
+        if not (path / ".git").exists():
+            root.mkdir(parents=True, exist_ok=True)
+            await _git(cwd, "worktree", "prune")
+            await _git(cwd, "worktree", "add", "-B", branch, str(path), base)
+
+        async def release(state: ItemState) -> None:
+            if state == "done":
+                await run_command("git", ["worktree", "remove", "--force", str(path)], cwd=cwd)
+
+        return Workspace(str(path), release)
+
+
+class DirCopy:
+    """A plain copy of the project directory per item (for projects that are not git repos)."""
+
+    async def create(self, config: dict[str, Any], item: dict[str, Any], cwd: str) -> Workspace:
+        root = Path(cwd) / str(config.get("dir") or ".whiletrue/copies")
+        path = root / _safe(str(item.get("id", "item")))
+        if not path.exists():
+            ignore = (
+                shutil.ignore_patterns(".whiletrue", ".git")
+                if config.get("skip_git")
+                else (shutil.ignore_patterns(".whiletrue"))
+            )
+            await asyncio.to_thread(shutil.copytree, cwd, path, ignore=ignore)
+
+        async def release(state: ItemState) -> None:
+            if state == "done":
+                await asyncio.to_thread(shutil.rmtree, path, ignore_errors=True)
+
+        return Workspace(str(path), release)
+
+
+class NoWorkspace:
+    """Items share the project directory."""
+
+    async def create(self, config: dict[str, Any], item: dict[str, Any], cwd: str) -> Workspace:
+        async def release(state: ItemState) -> None:
+            return None
+
+        return Workspace(cwd, release)

whiletrue/github/__init__.py

@@ -0,0 +1,30 @@
+"""GitHub integration: issues as items, PRs, review comments, merge, and wake conditions."""
+
+from whiletrue.github.client import (
+    GhCliClient,
+    GhComment,
+    GhIssue,
+    GhPullRequest,
+    GitHubClient,
+    GitHubError,
+    repo_from_remote,
+)
+from whiletrue.github.filebacked import FileBackedGitHub
+from whiletrue.github.memory import InMemoryGitHub
+from whiletrue.github.plugin import github_plugin
+from whiletrue.github.specs import blocked_by_in_body, parse_spec_refs
+
+__all__ = [
+    "FileBackedGitHub",
+    "GhCliClient",
+    "GhComment",
+    "GhIssue",
+    "GhPullRequest",
+    "GitHubClient",
+    "GitHubError",
+    "InMemoryGitHub",
+    "blocked_by_in_body",
+    "github_plugin",
+    "parse_spec_refs",
+    "repo_from_remote",
+]

whiletrue/github/client.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Literal, Protocol, cast
+
+from whiletrue.github.specs import blocked_by_in_body
+
+
+class GitHubError(Exception):
+    """A GitHub call failed."""
+
+
+@dataclass
+class GhIssue:
+    number: int
+    title: str
+    body: str
+    url: str
+    labels: list[str] = field(default_factory=lambda: [])
+    blocked_by: list[int] = field(default_factory=lambda: [])
+
+
+@dataclass
+class GhPullRequest:
+    number: int
+    url: str
+    branch: str
+    base: str
+    title: str
+    state: Literal["open", "closed", "merged"] = "open"
+    #: The overall review state: approved, changes_requested, or None (no decisive review yet).
+    review: Literal["approved", "changes_requested"] | None = None
+    #: Bodies of the reviews that requested changes, for a rejection note.
+    review_notes: list[str] = field(default_factory=lambda: [])
+
+
+@dataclass
+class GhComment:
+    #: Unique within its kind: a review (inline) comment id or an issue comment id.
+    id: str
+    kind: Literal["inline", "issue"]
+    author: str
+    body: str
+    created_at: int
+    url: str | None = None
+    #: For inline comments, the id of the first comment in the thread (its own id if first).
+    thread_root: str | None = None
+
+
+class GitHubClient(Protocol):
+    async def list_issues(
+        self, repo: str, *, milestone: str | None, state: str, labels: list[str]
+    ) -> list[GhIssue]: ...
+
+    async def find_pr(self, repo: str, head: str) -> GhPullRequest | None: ...
+
+    async def create_pr(
+        self, repo: str, *, head: str, base: str, title: str, body: str
+    ) -> GhPullRequest: ...
+
+    async def get_pr(self, repo: str, number: int) -> GhPullRequest: ...
+
+    async def list_comments(self, repo: str, number: int) -> list[GhComment]: ...
+
+    async def reply(self, repo: str, number: int, comment: GhComment, body: str) -> str: ...
+
+    async def merge_pr(self, repo: str, number: int, method: str) -> None: ...
+
+
+def _login(raw: Any) -> str:
+    """The `login` of a possibly-null `user` object."""
+    fields = cast(dict[str, Any], raw) if isinstance(raw, dict) else {}
+    user = fields.get("user")
+    return str(cast(dict[str, Any], user).get("login", "?")) if isinstance(user, dict) else "?"
+
+
+def _ms(stamp: str | None) -> int:
+    if not stamp:
+        return 0
+    return int(datetime.fromisoformat(stamp.replace("Z", "+00:00")).timestamp() * 1000)
+
+
+def repo_from_remote(url: str) -> str | None:
+    """`owner/repo` from a git remote URL (ssh or https)."""
+    match = re.search(r"github\.com[:/]([^/\s]+/[^/\s]+?)(?:\.git)?/?$", url.strip())
+    return match.group(1) if match else None
+
+
+class GhCliClient:
+    """Talks to GitHub through the `gh` CLI, which owns authentication."""
+
+    def __init__(self, command: str = "gh") -> None:
+        self._command = command
+
+    async def _run(self, *args: str, stdin: str | None = None) -> str:
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                self._command,
+                *args,
+                stdin=asyncio.subprocess.PIPE if stdin is not None else asyncio.subprocess.DEVNULL,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+        except OSError as error:
+            raise GitHubError(f"Cannot run {self._command}: {error}") from error
+        out, err = await proc.communicate(stdin.encode() if stdin is not None else None)
+        if proc.returncode != 0:
+            detail = err.decode(errors="replace").strip() or out.decode(errors="replace").strip()
+            raise GitHubError(f"`gh {' '.join(args[:3])}` failed: {detail[-400:]}")
+        return out.decode()
+
+    async def _one(self, path: str) -> Any:
+        """A GET that returns a single object (`--slurp` wraps it in a one-element list)."""
+        found: Any = await self._api(path)
+        if isinstance(found, list) and len(cast(list[Any], found)) > 0:
+            first: Any = cast(list[Any], found)[0]
+            return first
+        return found  # pyright: ignore[reportUnknownVariableType]
+
+    async def _api(
+        self, path: str, *, method: str = "GET", body: dict[str, Any] | None = None
+    ) -> Any:
+        args = ["api", path, "--method", method]
+        if method == "GET":
+            args += ["--paginate", "--slurp"]
+        text = (
+            await self._run(*args, "--input", "-", stdin=json.dumps(body))
+            if body
+            else (await self._run(*args))
+        )
+        data = json.loads(text) if text.strip() else None
+        if method == "GET" and isinstance(data, list):
+            # --slurp wraps each page in a list; flatten the pages.
+            flat: list[Any] = []
+            for page in cast(list[Any], data):
+                flat.extend(cast(list[Any], page) if isinstance(page, list) else [page])
+            return flat
+        return data
+
+    async def _milestone_number(self, repo: str, title: str) -> int:
+        for m in await self._api(f"repos/{repo}/milestones?state=all"):
+            if m["title"] == title or str(m["number"]) == title:
+                return int(m["number"])
+        raise GitHubError(f'No milestone "{title}" in {repo}')
+
+    async def list_issues(
+        self, repo: str, *, milestone: str | None, state: str, labels: list[str]
+    ) -> list[GhIssue]:
+        query = f"state={state}&per_page=100"
+        if milestone:
+            query += f"&milestone={await self._milestone_number(repo, milestone)}"
+        if labels:
+            query += "&labels=" + ",".join(labels)
+        issues: list[GhIssue] = []
+        for raw in await self._api(f"repos/{repo}/issues?{query}"):
+            if "pull_request" in raw:
+                continue
+            blocked = await self._blocked_by(repo, int(raw["number"]), raw.get("body") or "")
+            issues.append(
+                GhIssue(
+                    number=int(raw["number"]),
+                    title=raw["title"],
+                    body=raw.get("body") or "",
+                    url=raw["html_url"],
+                    labels=[lb["name"] for lb in raw.get("labels", [])],
+                    blocked_by=blocked,
+                )
+            )
+        return issues
+
+    async def _blocked_by(self, repo: str, number: int, body: str) -> list[int]:
+        try:
+            deps = await self._api(f"repos/{repo}/issues/{number}/dependencies/blocked_by")
+        except (GitHubError, ValueError):
+            return blocked_by_in_body(body)
+        return [int(d["number"]) for d in deps if d.get("state", "open") == "open"]
+
+    def _pr(self, raw: dict[str, Any]) -> GhPullRequest:
+        merged = bool(raw.get("merged") or raw.get("merged_at"))
+        return GhPullRequest(
+            number=int(raw["number"]),
+            url=raw["html_url"],
+            branch=raw["head"]["ref"],
+            base=raw["base"]["ref"],
+            title=raw.get("title", ""),
+            state="merged" if merged else raw.get("state", "open"),
+        )
+
+    async def find_pr(self, repo: str, head: str) -> GhPullRequest | None:
+        owner = repo.split("/", maxsplit=1)[0]
+        found = await self._api(f"repos/{repo}/pulls?state=all&head={owner}:{head}")
+        return self._pr(found[0]) if found else None
+
+    async def create_pr(
+        self, repo: str, *, head: str, base: str, title: str, body: str
+    ) -> GhPullRequest:
+        raw = await self._api(
+            f"repos/{repo}/pulls",
+            method="POST",
+            body={"head": head, "base": base, "title": title, "body": body},
+        )
+        return self._pr(raw)
+
+    async def get_pr(self, repo: str, number: int) -> GhPullRequest:
+        pr = self._pr(await self._one(f"repos/{repo}/pulls/{number}"))
+        latest: dict[str, tuple[int, str, str]] = {}
+        for review in await self._api(f"repos/{repo}/pulls/{number}/reviews"):
+            state = review.get("state", "")
+            if state in ("APPROVED", "CHANGES_REQUESTED", "DISMISSED"):
+                user = _login(review)
+                latest[user] = (int(review["id"]), state, review.get("body") or "")
+        states = {state for _, state, _ in latest.values()}
+        if "CHANGES_REQUESTED" in states:
+            pr.review = "changes_requested"
+            pr.review_notes = [b for _, s, b in latest.values() if s == "CHANGES_REQUESTED" and b]
+        elif "APPROVED" in states:
+            pr.review = "approved"
+        return pr
+
+    async def list_comments(self, repo: str, number: int) -> list[GhComment]:
+        comments: list[GhComment] = []
+        for raw in await self._api(f"repos/{repo}/pulls/{number}/comments"):
+            root = raw.get("in_reply_to_id") or raw["id"]
+            comments.append(
+                GhComment(
+                    id=f"inline:{raw['id']}",
+                    kind="inline",
+                    author=_login(raw),
+                    body=raw.get("body") or "",
+                    created_at=_ms(raw.get("created_at")),
+                    url=raw.get("html_url"),
+                    thread_root=str(root),
+                )
+            )
+        for raw in await self._api(f"repos/{repo}/issues/{number}/comments"):
+            comments.append(
+                GhComment(
+                    id=f"issue:{raw['id']}",
+                    kind="issue",
+                    author=_login(raw),
+                    body=raw.get("body") or "",
+                    created_at=_ms(raw.get("created_at")),
+                    url=raw.get("html_url"),
+                )
+            )
+        return comments
+
+    async def reply(self, repo: str, number: int, comment: GhComment, body: str) -> str:
+        if comment.kind == "inline":
+            root = comment.thread_root or comment.id.split(":", 1)[1]
+            raw = await self._api(
+                f"repos/{repo}/pulls/{number}/comments/{root}/replies",
+                method="POST",
+                body={"body": body},
+            )
+            return f"inline:{raw['id']}"
+        raw = await self._api(
+            f"repos/{repo}/issues/{number}/comments", method="POST", body={"body": body}
+        )
+        return f"issue:{raw['id']}"
+
+    async def merge_pr(self, repo: str, number: int, method: str) -> None:
+        await self._api(
+            f"repos/{repo}/pulls/{number}/merge", method="PUT", body={"merge_method": method}
+        )

whiletrue/github/filebacked.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+from whiletrue.github.client import GhComment, GhIssue, GhPullRequest
+from whiletrue.github.memory import InMemoryGitHub
+
+
+class FileBackedGitHub(InMemoryGitHub):
+    """An in-memory GitHub whose state lives in a JSON file.
+
+    For dry runs of a real pipeline without a repository: issues, PRs, comments, replies and
+    merges survive across processes, so crash/resume and review loops can be tried for real.
+    Edit the file (or call the helpers) to play the reviewer.
+    """
+
+    def __init__(self, path: str | Path) -> None:
+        super().__init__()
+        self._path = Path(path)
+        self._load()
+
+    def _load(self) -> None:
+        if not self._path.exists():
+            return
+        data: dict[str, Any] = json.loads(self._path.read_text(encoding="utf-8"))
+        self.issues = [GhIssue(**i) for i in data.get("issues", [])]
+        self.prs = {int(k): GhPullRequest(**v) for k, v in data.get("prs", {}).items()}
+        self.comments = {
+            int(k): [GhComment(**c) for c in v] for k, v in data.get("comments", {}).items()
+        }
+        self.replies = [tuple(r) for r in data.get("replies", [])]  # type: ignore[misc]
+        self.merged = [tuple(m) for m in data.get("merged", [])]  # type: ignore[misc]
+        self.created = list(data.get("created", []))
+        self._next_pr = int(data.get("next_pr", 1))
+        self._next_comment = int(data.get("next_comment", 1000))
+
+    def save(self) -> None:
+        data = {
+            "issues": [asdict(i) for i in self.issues],
+            "prs": {str(k): asdict(v) for k, v in self.prs.items()},
+            "comments": {str(k): [asdict(c) for c in v] for k, v in self.comments.items()},
+            "replies": [list(r) for r in self.replies],
+            "merged": [list(m) for m in self.merged],
+            "created": self.created,
+            "next_pr": self._next_pr,
+            "next_comment": self._next_comment,
+        }
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+    # Every call re-reads the file first (another process may have changed it) and saves after.
+
+    async def list_issues(self, *args: Any, **kwargs: Any) -> list[GhIssue]:
+        self._load()
+        return await super().list_issues(*args, **kwargs)
+
+    async def find_pr(self, *args: Any, **kwargs: Any) -> GhPullRequest | None:
+        self._load()
+        return await super().find_pr(*args, **kwargs)
+
+    async def create_pr(self, *args: Any, **kwargs: Any) -> GhPullRequest:
+        self._load()
+        pr = await super().create_pr(*args, **kwargs)
+        self.save()
+        return pr
+
+    async def get_pr(self, *args: Any, **kwargs: Any) -> GhPullRequest:
+        self._load()
+        return await super().get_pr(*args, **kwargs)
+
+    async def list_comments(self, *args: Any, **kwargs: Any) -> list[GhComment]:
+        self._load()
+        return await super().list_comments(*args, **kwargs)
+
+    async def reply(self, *args: Any, **kwargs: Any) -> str:
+        self._load()
+        ref = await super().reply(*args, **kwargs)
+        self.save()
+        return ref
+
+    async def merge_pr(self, *args: Any, **kwargs: Any) -> None:
+        self._load()
+        await super().merge_pr(*args, **kwargs)
+        self.save()

whiletrue/github/memory.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import time
+from dataclasses import replace
+
+from whiletrue.github.client import GhComment, GhIssue, GhPullRequest, GitHubError
+
+
+class InMemoryGitHub:
+    """A GitHub stand-in for tests and dry runs: a few issues, PRs and comment threads."""
+
+    def __init__(self) -> None:
+        self.issues: list[GhIssue] = []
+        self.prs: dict[int, GhPullRequest] = {}
+        self.comments: dict[int, list[GhComment]] = {}
+        self.replies: list[tuple[int, str, str]] = []
+        self.merged: list[tuple[int, str]] = []
+        self.created: list[int] = []
+        self._next_pr = 1
+        self._next_comment = 1000
+
+    # ---- helpers for tests --------------------------------------------------------------
+
+    def add_comment(
+        self,
+        number: int,
+        body: str,
+        *,
+        author: str = "alice",
+        kind: str = "inline",
+        root: str | None = None,
+    ) -> GhComment:
+        self._next_comment += 1
+        comment_id = str(self._next_comment)
+        comment = GhComment(
+            id=f"{kind}:{comment_id}",
+            kind="inline" if kind == "inline" else "issue",
+            author=author,
+            body=body,
+            created_at=int(time.time() * 1000),
+            url=f"https://example.test/pr/{number}#c{comment_id}",
+            thread_root=(root or comment_id) if kind == "inline" else None,
+        )
+        self.comments.setdefault(number, []).append(comment)
+        return comment
+
+    def review(self, number: int, state: str | None, notes: list[str] | None = None) -> None:
+        pr = self.prs[number]
+        pr.review = state  # type: ignore[assignment]
+        pr.review_notes = list(notes or [])
+
+    # ---- GitHubClient --------------------------------------------------------------------
+
+    async def list_issues(
+        self, repo: str, *, milestone: str | None, state: str, labels: list[str]
+    ) -> list[GhIssue]:
+        return [replace(i) for i in self.issues if not labels or set(labels) <= set(i.labels)]
+
+    async def find_pr(self, repo: str, head: str) -> GhPullRequest | None:
+        found = next((p for p in self.prs.values() if p.branch == head), None)
+        return replace(found) if found else None
+
+    async def create_pr(
+        self, repo: str, *, head: str, base: str, title: str, body: str
+    ) -> GhPullRequest:
+        number = self._next_pr
+        self._next_pr += 1
+        pr = GhPullRequest(number, f"https://example.test/{repo}/pull/{number}", head, base, title)
+        self.prs[number] = pr
+        self.created.append(number)
+        return replace(pr)
+
+    async def get_pr(self, repo: str, number: int) -> GhPullRequest:
+        if number not in self.prs:
+            raise GitHubError(f"No PR #{number}")
+        return replace(self.prs[number])
+
+    async def list_comments(self, repo: str, number: int) -> list[GhComment]:
+        return [replace(c) for c in self.comments.get(number, [])]
+
+    async def reply(self, repo: str, number: int, comment: GhComment, body: str) -> str:
+        self.replies.append((number, comment.id, body))
+        mine = self.add_comment(
+            number,
+            body,
+            author="whiletrue",
+            kind=comment.kind,
+            root=comment.thread_root,
+        )
+        return mine.id
+
+    async def merge_pr(self, repo: str, number: int, method: str) -> None:
+        if number not in self.prs:
+            raise GitHubError(f"No PR #{number}")
+        self.prs[number].state = "merged"
+        self.merged.append((number, method))