Answer product-owner round 1: 1 🔴, 2 🟡 (0 misread); count a pull request the forge reports merged by any method, check the worktree and main checkout before acting, remove todo items before the merge

This commit is contained in:
2026-11-10 11:05:05 +01:00
parent 8cc9a89265
commit a49a59f7ff
5 changed files with 260 additions and 112 deletions
+1 -1
View File
@@ -2,7 +2,7 @@
## Unreleased
- `chunk-pr clean` removes a merged chunk's worktree and branch and fast-forwards the main checkout, which it leaves as it was, saying why, while that is dirty or on another branch.
- `chunk-pr clean` removes a merged chunk's worktree and local branch and fast-forwards the main checkout. It leaves a main checkout with uncommitted files, another branch or commits of its own as it was, and says why.
- `review-replay` now replays each round at the commit with the newest author time at or before the round's time, and takes the clone's base the same way by the time the chunk began. It took the first such commit in log order, so a commit authored early but merged late, such as a dependency bump, could win over the commits the round reviewed.
- The shared goal every project pursues, code health, now asks that code stay easy to read, change safely and debug, tomorrow and after seven years of development.
- `rank_todo.py` now lets an item that adds a test, a gate leg or a probe name the maintain goal it guards, by how much more confident the project becomes that the goal holds, 1 to 10. Each point is worth 0.5.
+113 -53
View File
@@ -1,4 +1,4 @@
"""Open the chunk's pull request as a draft, mark it ready, or merge it, with gh where origin is on GitHub and tea elsewhere; then clean up after it.
"""Open the chunk's pull request as a draft, mark it ready, or merge it, with gh where origin is on GitHub and tea elsewhere; once it has merged, remove the chunk's worktree and branch.
usage: chunk-pr open <title> [<body>]
chunk-pr ready
@@ -19,22 +19,26 @@ merge merges the pull request, and only while its head is still the commit ch
a merge commit, fast-forward only, a rebase followed by a merge commit, a rebase, a squash.
GitHub offers only the merge commit, the rebase and the squash. --gate-passed says the
merge gate passed on that commit; without it, chunk-pr refuses.
clean fetches origin and, once origin's default branch holds the commit checked out, removes
the chunk's worktree and its branch, then fast-forwards the main checkout to origin's
default branch. It leaves the main checkout as it was where that has uncommitted or
untracked files or another branch checked out, and fails saying so: a dirty checkout is
for its owner to look at. A worktree with uncommitted changes git keeps, branch and all.
clean acts once the forge reports the branch's pull request merged at the commit checked out,
by any merge method. It fetches origin, fast-forwards the main checkout to origin's
default branch, removes the chunk's worktree, then deletes the local branch; origin's
branch stays. Where the worktree has uncommitted or untracked files, it refuses and
touches nothing. Where the main checkout has uncommitted or untracked files, another
branch checked out, or commits origin's default branch lacks, it leaves that as it was,
still removes the worktree and the branch, and fails saying why.
It prints what it did, exit 0, or why it failed, exit 1.
"""
import dataclasses
import json
import os
import sys
import typing
from failure import Failure
from chunk_preflight.gathered import Forge
from chunk_preflight.choices import forge_of
from deploy_release.forge import gitea, open_pull, Run, runner
from deploy_release.forge import gitea, merged_pull, open_pull, Run, runner
USAGE = "usage: chunk-pr open <title> [<body>] | chunk-pr ready | chunk-pr merge --gate-passed | chunk-pr clean"
@@ -75,16 +79,30 @@ def step(argv: list[str], run: Run) -> str | Failure:
return Failure(USAGE)
def answers(run: Run, *commands: list[str]) -> list[str] | Failure:
"""What each git command printed, stripped, or the first Failure."""
answered = [run(["git", *args]) for args in commands]
failed = next((answer for answer in answered if isinstance(answer, Failure)), None)
return failed if failed is not None else [str(answer).strip() for answer in answered]
def checkout(run: Run) -> tuple[Forge, str, str] | Failure:
"""The forge, the branch checked out and its head commit."""
answers = [run(["git", *args]) for args in (["remote", "get-url", "origin"], ["symbolic-ref", "--short", "HEAD"], ["rev-parse", "HEAD"])]
failed = next((answer for answer in answers if isinstance(answer, Failure)), None)
if failed is not None:
return failed
origin, branch, head = (str(answer).strip() for answer in answers)
found = answers(run, ["remote", "get-url", "origin"], ["symbolic-ref", "--short", "HEAD"], ["rev-parse", "HEAD"])
if isinstance(found, Failure):
return found
origin, branch, head = found
return forge_of(origin), branch, head
def default_branch(run: Run) -> str | Failure:
"""origin's default branch, such as main."""
default = run(["git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD"])
if isinstance(default, Failure):
return Failure(f"origin records no default branch; set it with `git remote set-head origin --auto`: {default.reason}")
return default.strip().removeprefix("origin/")
def pull(run: Run) -> tuple[Forge, str, str] | Failure:
"""The forge, the number of the branch's open pull request at its head, and that head."""
found = checkout(run)
@@ -102,10 +120,9 @@ def opened(title: str, body: str, run: Run) -> str | Failure:
if isinstance(found, Failure):
return found
forge, branch, head = found
default = run(["git", "symbolic-ref", "--short", "refs/remotes/origin/HEAD"])
if isinstance(default, Failure):
return Failure(f"origin records no default branch; set it with `git remote set-head origin --auto`: {default.reason}")
base = default.strip().removeprefix("origin/")
base = default_branch(run)
if isinstance(base, Failure):
return base
if branch == base:
return Failure(f"{branch} is origin's default branch; open the pull request from the chunk's branch")
pushed = run(["git", "push", "--quiet", "--set-upstream", "origin", branch])
@@ -166,50 +183,93 @@ def merge_method(forge: Forge, run: Run) -> str | Failure:
return allowed if allowed is not None else Failure(f"the repository allows none of the merge methods chunk-pr knows: {', '.join(method for _, method in METHODS[forge])}")
def cleaned(run: Run) -> str | Failure:
@dataclasses.dataclass(frozen=True)
class Chunk:
"""A merged chunk's worktree and branch, the main checkout of their repository, and origin's default branch."""
worktree: str
branch: str
main: str
default: str
def cleaned(run: Run, at: typing.Callable[[str], Run] = runner) -> str | Failure:
"""Remove the worktree and branch of the merged chunk run is in, and fast-forward the main checkout; at(folder) runs commands in folder, here the main checkout."""
chunk = merged_chunk(run)
if isinstance(chunk, Failure):
return chunk
at_main = at(chunk.main)
left = kept_as_it_was(at_main, chunk.default)
files = unsaved(run)
if isinstance(files, Failure):
return files
if files:
also = f"\nIt would also have left {chunk.main} as it was: {left}" if left else ""
return Failure(f"left everything as it was: {chunk.worktree} has uncommitted or untracked files:\n{files}{also}")
return removed(chunk, at_main, left)
def merged_chunk(run: Run) -> Chunk | Failure:
"""The chunk run is in, once the forge reports its pull request merged at its head. It fetches origin, so the main checkout can fast-forward to the merge."""
found = checkout(run)
if isinstance(found, Failure):
return found
_, branch, head = found
answers = [run(["git", *args]) for args in (["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], ["worktree", "list", "--porcelain"], ["rev-parse", "--show-toplevel"])]
failed = next((answer for answer in answers if isinstance(answer, Failure)), None)
if failed is not None:
return failed
base, listed, worktree = (str(answer).strip() for answer in answers)
forge, branch, head = found
default = default_branch(run)
if isinstance(default, Failure):
return default
folders = worktree_and_main(run)
if isinstance(folders, Failure):
return folders
number = merged_pull(forge, branch, head, run)
if number is None:
return Failure(f"no merged pull request from {branch} at {head[:12]}, so its worktree and branch stay")
fetched = number if isinstance(number, Failure) else run(["git", "fetch", "--quiet", "origin"])
return fetched if isinstance(fetched, Failure) else Chunk(folders[0], branch, folders[1], default)
def worktree_and_main(run: Run) -> tuple[str, str] | Failure:
"""The worktree run is in, and the main checkout of its repository. Run in the main checkout itself, it fails."""
folders = answers(run, ["rev-parse", "--show-toplevel"], ["worktree", "list", "--porcelain"])
if isinstance(folders, Failure):
return folders
# git lists the main checkout first.
main = listed.splitlines()[0].removeprefix("worktree ")
if worktree == main:
return Failure(f"{main} is the main checkout; run clean in the chunk's worktree")
fetched = run(["git", "fetch", "--quiet", "origin"])
if isinstance(fetched, Failure):
return fetched
if isinstance(run(["git", "merge-base", "--is-ancestor", head, base]), Failure):
return Failure(f"{base} doesn't hold {head[:12]}: {branch} is not merged, so its worktree and branch stay")
at_main = runner(main)
left = kept_as_it_was(at_main, base.removeprefix("origin/"))
if left is None:
forwarded = at_main(["git", "merge", "--quiet", "--ff-only", base])
if isinstance(forwarded, Failure):
return forwarded
removed = at_main(["git", "worktree", "remove", worktree])
if isinstance(removed, Failure):
return removed
# Not -d: the check above already found the branch merged, and -d would compare it with the main checkout's HEAD or a stale upstream instead.
deleted = at_main(["git", "branch", "--quiet", "-D", branch])
if isinstance(deleted, Failure):
return deleted
done = f"Removed worktree {worktree} and branch {branch}"
if left is not None:
return Failure(f"{done}, but left {main} as it was: {left}")
return f"{done}, and fast-forwarded {main} to {base}."
worktree, main = folders[0], folders[1].splitlines()[0].removeprefix("worktree ")
return Failure(f"{main} is the main checkout; run clean in the chunk's worktree") if worktree == main else (worktree, main)
def unsaved(run: Run) -> str | Failure:
"""The uncommitted and untracked files of the checkout run is in, as git status lists them; empty where there are none."""
status = run(["git", "status", "--porcelain"])
return status if isinstance(status, Failure) else status.rstrip()
def kept_as_it_was(at_main: Run, default: str) -> str | None:
"""Why the main checkout must not move, or None where it may fast-forward."""
"""Why the main checkout must not move, or None where it may fast-forward to origin's default."""
branch = at_main(["git", "symbolic-ref", "--quiet", "--short", "HEAD"])
if isinstance(branch, Failure) or branch.strip() != default:
return f"it has {'no branch' if isinstance(branch, Failure) else branch.strip()} checked out, not {default}"
status = at_main(["git", "status", "--porcelain"])
if isinstance(status, Failure):
return status.reason
return f"it has uncommitted or untracked files:\n{status.rstrip()}" if status.strip() else None
files = unsaved(at_main)
if isinstance(files, Failure):
return files.reason
if files:
return f"it has uncommitted or untracked files:\n{files}"
if isinstance(at_main(["git", "merge-base", "--is-ancestor", "HEAD", f"origin/{default}"]), Failure):
return f"it holds commits origin/{default} lacks"
return None
def removed(chunk: Chunk, at_main: Run, left: str | None) -> str | Failure:
"""Fast-forward the main checkout unless left says why not, then remove the chunk's worktree and branch. Every command runs in the main checkout, since the worktree is gone after the removal."""
if left is None:
forwarded = at_main(["git", "merge", "--quiet", "--ff-only", f"origin/{chunk.default}"])
if isinstance(forwarded, Failure):
return forwarded
removal = at_main(["git", "worktree", "remove", chunk.worktree])
# Not -d: merged_chunk found the forge's pull request merged at the branch's head. -d would compare the branch with the main checkout's HEAD or its upstream instead, and after a rebase or squash merge neither need hold its commits.
deleted = removal if isinstance(removal, Failure) else at_main(["git", "branch", "--quiet", "-D", chunk.branch])
if isinstance(deleted, Failure):
return deleted
done = f"Removed worktree {chunk.worktree} and branch {chunk.branch}"
if left is not None:
return Failure(f"{done}, but left {chunk.main} as it was: {left}")
return f"{done}, and fast-forwarded {chunk.main} to origin/{chunk.default}."
+129 -51
View File
@@ -7,9 +7,10 @@ import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from chunk_pr.main import cleaned, step
from failure import Failure
from test_env import isolated_env
from chunk_pr.main import step
from deploy_release.forge import Run
TOOL = pathlib.Path(__file__).resolve().parents[1] / "chunk-pr"
GITHUB = "git@github.com:me/project.git"
@@ -174,21 +175,31 @@ class Merge(unittest.TestCase):
class Clean(unittest.TestCase):
"""A real origin whose default branch is main, its clone project, and the worktree project-item-7 on item-7, one commit ahead and pushed."""
"""A real bare repository origin whose default branch is main; the clone project of it; and the worktree project-item-7 on branch item-7, one commit ahead of main and pushed.
cleaned runs git for real, but the forge is faked: origin's URL reads as GitHub's, or Gitea's where self.url says so, and pull request #12 from item-7 is merged at self.merged_at where that is set."""
def setUp(self):
folder = tempfile.TemporaryDirectory()
self.addCleanup(folder.cleanup)
root = pathlib.Path(folder.name)
self.origin, self.project, self.worktree = root / "origin.git", root / "project", root / "project-item-7"
self.origin, self.project, self.worktree, self.forge_clone = root / "origin.git", root / "project", root / "project-item-7", root / "forge"
self.git(root, "init", "--quiet", "--bare", "--initial-branch=main", str(self.origin))
self.git(root, "clone", "--quiet", str(self.origin), str(self.project))
self.commit(self.project, "first")
self.git(self.project, "push", "--quiet", "origin", "main")
self.git(self.project, "remote", "set-head", "origin", "--auto")
self.git(self.project, "worktree", "add", "--quiet", "-b", "item-7", str(self.worktree), "origin/main")
(self.worktree / "chunk.txt").write_text("the chunk\n")
self.git(self.worktree, "add", "chunk.txt")
self.commit(self.worktree, "the chunk")
self.git(self.worktree, "push", "--quiet", "--set-upstream", "origin", "item-7")
self.head = self.git(self.worktree, "rev-parse", "HEAD")
self.before = self.git(self.project, "rev-parse", "HEAD")
self.url = GITHUB
self.merged_at: str | None = None
# The forge merges in a clone of its own, so the project's origin/main stays stale until clean fetches.
self.git(root, "clone", "--quiet", str(self.origin), str(self.forge_clone))
def git(self, folder: pathlib.Path, *args: str) -> str:
return subprocess.run(["git", "-c", "user.name=Test", "-c", "user.email=test@example.org", *args], cwd=folder, check=True, capture_output=True, encoding="utf-8", env=isolated_env()).stdout.strip()
@@ -196,68 +207,127 @@ class Clean(unittest.TestCase):
def commit(self, folder: pathlib.Path, message: str):
self.git(folder, "commit", "--quiet", "--allow-empty", "-m", message)
def merge_on_origin(self):
self.git(self.worktree, "push", "--quiet", "origin", "item-7:main")
def merge_commit_on_origin(self) -> str:
self.git(self.forge_clone, "fetch", "--quiet", "origin", "item-7")
self.git(self.forge_clone, "merge", "--quiet", "--no-ff", "-m", "Merge item-7", "FETCH_HEAD")
return self.publish()
def clean(self) -> subprocess.CompletedProcess:
return subprocess.run([str(TOOL), "clean"], cwd=self.worktree, capture_output=True, encoding="utf-8", env=isolated_env())
def rebase_on_origin(self) -> str:
"""Put the chunk's change on origin's main as another commit, as a rebase or a squash merge does."""
(self.forge_clone / "chunk.txt").write_text("the chunk\n")
self.git(self.forge_clone, "add", "chunk.txt")
self.commit(self.forge_clone, "the chunk, rebased")
return self.publish()
def publish(self) -> str:
self.git(self.forge_clone, "push", "--quiet", "origin", "main")
self.merged_at = self.head
return self.git(self.forge_clone, "rev-parse", "HEAD")
def at(self, folder: str) -> Run:
def run(command: list[str]) -> str | Failure:
if command == ["git", "remote", "get-url", "origin"]:
return f"{self.url}\n"
if command == ["gh", "pr", "list", "--head", "item-7", "--state", "merged", *GH_LIST[5:]] and self.url == GITHUB:
return f"12\t{self.merged_at}\tfalse\n" if self.merged_at else ""
if command == ["tea", "api", "repos/{owner}/{repo}/pulls?state=closed&limit=50"] and self.url == GITEA:
return json.dumps([{"number": 12, "merged": self.merged_at is not None, "head": {"ref": "item-7", "sha": self.merged_at or self.head, "repo": {"full_name": "me/project"}}, "base": {"repo": {"full_name": "me/project"}}}])
if command[0] != "git":
return Failure(f"the fake forge doesn't answer {command}")
done = subprocess.run(command, cwd=folder, capture_output=True, encoding="utf-8", env=isolated_env())
return Failure(f"{' '.join(command[:3])}: {done.stderr.strip()}") if done.returncode else done.stdout
return run
def clean(self, folder: pathlib.Path | None = None) -> str | Failure:
return cleaned(self.at(str(folder or self.worktree)), self.at)
def branches(self) -> list[str]:
return self.git(self.project, "branch", "--format=%(refname:short)").splitlines()
return sorted(self.git(self.project, "branch", "--format=%(refname:short)").splitlines())
def test_a_merged_chunk_loses_its_worktree_and_branch_and_the_checkout_fast_forwards(self):
self.merge_on_origin()
merged = self.git(self.worktree, "rev-parse", "HEAD")
done = self.clean()
self.assertEqual(done.returncode, 0, done.stderr)
self.assertFalse(self.worktree.exists())
def assert_kept(self):
"""Worktree, branch and main checkout are as setUp left them."""
self.assertTrue(self.worktree.exists())
self.assertEqual(self.branches(), ["item-7", "main"])
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), self.before)
def test_a_chunk_merged_with_a_merge_commit_loses_its_worktree_and_branch_and_the_checkout_fast_forwards(self):
for url in (GITHUB, GITEA):
with self.subTest(url):
if url == GITEA:
self.setUp()
self.url = url
merged = self.merge_commit_on_origin()
self.assertEqual(self.clean(), f"Removed worktree {self.worktree} and branch item-7, and fast-forwarded {self.project} to origin/main.")
self.assertFalse(self.worktree.exists())
self.assertEqual(self.branches(), ["main"])
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), merged)
def test_a_rebased_chunk_is_cleaned_though_main_lacks_its_commit(self):
# Without an upstream, git branch -d would compare item-7 with the main checkout's HEAD, which lacks its commit.
self.git(self.project, "branch", "--unset-upstream", "item-7")
merged = self.rebase_on_origin()
self.assertEqual(self.clean(), f"Removed worktree {self.worktree} and branch item-7, and fast-forwarded {self.project} to origin/main.")
self.assertEqual(self.branches(), ["main"])
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), merged)
self.assertIn("item-7", done.stdout)
def test_an_unmerged_chunk_keeps_everything(self):
done = self.clean()
self.assertEqual(done.returncode, 1)
self.assertIn("not merged", done.stderr)
self.assertTrue(self.worktree.exists())
self.assertEqual(sorted(self.branches()), ["item-7", "main"])
for url in (GITHUB, GITEA):
with self.subTest(url):
self.url = url
self.assertEqual(self.clean(), Failure(f"no merged pull request from item-7 at {self.head[:12]}, so its worktree and branch stay"))
self.assert_kept()
def test_a_dirty_checkout_is_left_as_it_was_and_reported(self):
self.merge_on_origin()
before = self.git(self.project, "rev-parse", "HEAD")
(self.project / "notes.txt").write_text("mine\n")
done = self.clean()
self.assertEqual(done.returncode, 1)
self.assertIn("uncommitted", done.stderr)
self.assertIn(str(self.project), done.stderr)
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), before)
self.assertEqual((self.project / "notes.txt").read_text(), "mine\n")
self.assertFalse(self.worktree.exists())
self.assertEqual(self.branches(), ["main"])
def test_a_pull_request_merged_at_another_head_keeps_everything(self):
self.merge_commit_on_origin()
self.merged_at = "0" * 40
self.assertIsInstance(self.clean(), Failure)
self.assert_kept()
def test_a_checkout_on_another_branch_is_left_as_it_was_and_reported(self):
self.merge_on_origin()
self.git(self.project, "switch", "--quiet", "-c", "elsewhere")
before = self.git(self.project, "rev-parse", "HEAD")
done = self.clean()
self.assertEqual(done.returncode, 1)
self.assertIn("elsewhere", done.stderr)
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), before)
self.assertFalse(self.worktree.exists())
def test_a_main_checkout_that_cannot_fast_forward_is_left_as_it_was_and_named(self):
cases = {
"dirty": ("it has uncommitted or untracked files:\n?? notes.txt", lambda: (self.project / "notes.txt").write_text("mine\n")),
"on another branch": ("it has elsewhere checked out, not main", lambda: self.git(self.project, "switch", "--quiet", "-c", "elsewhere")),
"ahead of origin": ("it holds commits origin/main lacks", lambda: self.commit(self.project, "mine")),
}
for case, (why, spoil) in cases.items():
with self.subTest(case):
self.setUp()
self.git(self.project, "branch", "--unset-upstream", "item-7")
self.merge_commit_on_origin()
spoil()
before = self.git(self.project, "rev-parse", "HEAD")
self.assertEqual(self.clean(), Failure(f"Removed worktree {self.worktree} and branch item-7, but left {self.project} as it was: {why}"))
self.assertEqual(self.git(self.project, "rev-parse", "HEAD"), before)
self.assertFalse(self.worktree.exists())
self.assertEqual(self.branches(), ["elsewhere", "main"] if case == "on another branch" else ["main"])
def test_a_worktree_with_uncommitted_changes_is_kept(self):
self.merge_on_origin()
def test_a_worktree_with_uncommitted_or_untracked_files_keeps_everything(self):
self.merge_commit_on_origin()
(self.worktree / "chunk.txt").write_text("changed\n")
(self.worktree / "draft.txt").write_text("unsaved\n")
done = self.clean()
self.assertEqual(done.returncode, 1)
self.assertTrue((self.worktree / "draft.txt").exists())
self.assertIn("item-7", self.branches())
self.assertEqual(self.clean(), Failure(f"left everything as it was: {self.worktree} has uncommitted or untracked files:\n M chunk.txt\n?? draft.txt"))
self.assert_kept()
self.assertEqual((self.worktree / "draft.txt").read_text(), "unsaved\n")
def test_a_dirty_worktree_also_reports_a_main_checkout_it_would_have_left(self):
self.merge_commit_on_origin()
(self.worktree / "draft.txt").write_text("unsaved\n")
(self.project / "notes.txt").write_text("mine\n")
self.assertEqual(self.clean(), Failure(f"left everything as it was: {self.worktree} has uncommitted or untracked files:\n?? draft.txt\nIt would also have left {self.project} as it was: it has uncommitted or untracked files:\n?? notes.txt"))
self.assert_kept()
def test_the_main_checkout_itself_is_refused(self):
done = subprocess.run([str(TOOL), "clean"], cwd=self.project, capture_output=True, encoding="utf-8", env=isolated_env())
self.assertEqual(done.returncode, 1)
self.assertIn("worktree", done.stderr)
self.assertTrue(self.worktree.exists())
self.merge_commit_on_origin()
self.assertEqual(self.clean(self.project), Failure(f"{self.project} is the main checkout; run clean in the chunk's worktree"))
self.assert_kept()
def test_without_a_default_branch_on_record_it_says_how_to_set_one(self):
self.merge_commit_on_origin()
self.git(self.project, "remote", "set-head", "origin", "--delete")
cleaned_up = self.clean()
self.assertIsInstance(cleaned_up, Failure)
self.assertTrue(cleaned_up.reason.startswith("origin records no default branch; set it with `git remote set-head origin --auto`: "), cleaned_up)
self.assert_kept()
class Launcher(unittest.TestCase):
@@ -267,6 +337,14 @@ class Launcher(unittest.TestCase):
self.assertEqual((wrong.returncode, wrong.stdout), (1, ""))
self.assertIn("usage", wrong.stderr)
def test_clean_runs_in_the_folder_it_is_started_in(self):
with tempfile.TemporaryDirectory() as folder:
for args in (["init", "--quiet"], ["remote", "add", "origin", GITHUB], ["-c", "user.name=Test", "-c", "user.email=test@example.org", "commit", "--quiet", "--allow-empty", "-m", "first"]):
subprocess.run(["git", *args], cwd=folder, check=True, env=isolated_env())
done = subprocess.run([str(TOOL), "clean"], cwd=folder, capture_output=True, encoding="utf-8", env=isolated_env())
self.assertEqual((done.returncode, done.stdout), (1, ""))
self.assertTrue(done.stderr.startswith("chunk-pr: origin records no default branch"), done.stderr)
if __name__ == "__main__":
unittest.main()
+14 -4
View File
@@ -48,18 +48,28 @@ def gitea(run: Run, endpoint: str, *fields: str) -> typing.Any | Failure:
def open_pull(forge: Forge, branch: str, head: str, run: Run) -> str | None | Failure:
"""The number of the open pull request from origin's own branch whose head is head; None where there is none."""
return pull_at(forge, branch, head, "open", run)
def merged_pull(forge: Forge, branch: str, head: str, run: Run) -> str | None | Failure:
"""The number of the merged pull request from origin's own branch whose head was head; None where there is none. A rebase or a squash merge counts: the pull request keeps the head it had."""
return pull_at(forge, branch, head, "merged", run)
def pull_at(forge: Forge, branch: str, head: str, state: typing.Literal["open", "merged"], run: Run) -> str | None | Failure:
if forge == "gh":
listed = run(["gh", "pr", "list", "--head", branch, "--json", "number,headRefOid,isCrossRepository", "--template", "{{range .}}{{.number}}\t{{.headRefOid}}\t{{.isCrossRepository}}\n{{end}}"])
# gh lists the open pull requests unless told another state.
listed = run(["gh", "pr", "list", "--head", branch, *(["--state", "merged"] if state == "merged" else []), "--json", "number,headRefOid,isCrossRepository", "--template", "{{range .}}{{.number}}\t{{.headRefOid}}\t{{.isCrossRepository}}\n{{end}}"])
if isinstance(listed, Failure):
return listed
rows = [line.split("\t") for line in listed.splitlines()]
return next((row[0] for row in rows if row[1:] == [head, "false"]), None)
# Gitea lists at most 50 a page; the pull request sought is among the newest.
pulls = gitea(run, "repos/{owner}/{repo}/pulls?state=open&limit=50")
# Gitea lists at most 50 a page; the pull request sought is among the newest. Gitea has no merged state: a merged pull request is a closed one marked merged.
pulls = gitea(run, f"repos/{{owner}}/{{repo}}/pulls?state={'open' if state == 'open' else 'closed'}&limit=50")
if isinstance(pulls, Failure):
return pulls
try:
return next((str(pull["number"]) for pull in pulls if pull["head"]["ref"] == branch and pull["head"]["sha"] == head and pull["head"]["repo"]["full_name"] == pull["base"]["repo"]["full_name"]), None)
return next((str(pull["number"]) for pull in pulls if pull["head"]["ref"] == branch and pull["head"]["sha"] == head and pull["head"]["repo"]["full_name"] == pull["base"]["repo"]["full_name"] and (state == "open" or pull["merged"] is True)), None)
except (KeyError, TypeError):
return Failure(f"tea api listed pull requests in a shape that can't be read: {str(pulls)[:200]}")
+3 -3
View File
@@ -193,9 +193,9 @@ Launch prose-reviewer with what the diff touched and every section this review c
1. Read the finished PR against the README goals and code health, unless the README voids it: does anything in it work against one? It breaks a maintain goal → do not merge; redesign the change or drop its item. It works against an achieve goal → do not merge; ask the human, stating the conflict.
2. Run the comprehension check (§3) where it runs; it runs once. When `origin/<default branch>` moves after that, return to §4, and keep the ruling and scoring run already recorded.
3. Aligned, every pass done and everything green → **merge** with `~/.claude/bin/chunk-pr merge --gate-passed`, which takes the first merge method the repository allows on its forge. A repo whose `AGENTS.md` names another method merges that way with the forge's CLI instead. A repo withholds this in its `AGENTS.md` → leave the PR ready and unmerged, and say which line withheld it.
4. Merged → remove the chunk's items from `todo.md` per `~/.claude/CLAUDE.md` → "Working loop".
5. Run `~/.claude/bin/chunk-pr clean` in the chunk's worktree. It removes the worktree and the branch and fast-forwards the main checkout; a failure it prints, such as a dirty main checkout, goes in the summary.
3. Remove the chunk's items from `todo.md` per `~/.claude/CLAUDE.md` → "Working loop" in the branch, commit and push that, and wait for the forge's checks (§4 step 4); the commit re-enters no pass.
4. Aligned, every pass done and everything green → **merge** with `~/.claude/bin/chunk-pr merge --gate-passed`, which takes the first merge method the repository allows on its forge. A repo whose `AGENTS.md` names another method merges that way with the forge's CLI instead. A repo withholds this in its `AGENTS.md` → leave the PR ready and unmerged, and say which line withheld it.
5. Merged → run `~/.claude/bin/chunk-pr clean` in the chunk's worktree, and put a failure it prints in the summary.
6. Stop. The next chunk gets a fresh session.
## 6. Wrap up