claude-dev-env 8.99.0 → 8.100.0

package/scripts/merge_review_receipt.py

@@ -13,8 +13,14 @@ clean once the rulings are posted and linked::
     python3 merge_review_receipt.py owner/name 12 def5678 2 --ruled-out 2 --rulings <url>
         -> CLEAN owner/name#12 def5678 (2 findings ruled out: <url>)
 
+A pass run before the pull request exists names ``open`` in place of the
+number, and records the head it reviewed::
+
+    python3 merge_review_receipt.py owner/name open def5678 0   -> CLEAN owner/name open def5678
+
 ``hooks/blocking/merge_review_gate.py`` allows a merge pinned to the head of
-the newest pass only when that pass is clean.
+the newest pass only when that pass is clean. It allows a pull request open
+whose head has a clean ``open`` pass, and a merge pinned to that same head.
 """
 
 from __future__ import annotations
@@ -30,12 +36,19 @@ hooks_directory = str(Path(__file__).resolve().parent.parent / "hooks")
 if hooks_directory not in sys.path:
     sys.path.insert(0, hooks_directory)
 
-from blocking.merge_review_gate import is_clean_receipt, receipt_path
+from blocking.merge_review_gate_parts.receipts import (
+    is_clean_receipt,
+    open_receipt_path,
+    receipt_path,
+)
 from hooks_constants.merge_review_gate_constants import (
+    OPEN_RECEIPT_HEAD_PATTERN,
+    OPEN_TARGET_WORD,
     RECEIPT_FINDINGS_KEY,
     RECEIPT_HEAD_KEY,
     RECEIPT_RULED_OUT_KEY,
     RECEIPT_RULINGS_KEY,
+    REPOSITORY_SLUG_PATTERN,
 )
 
 
@@ -64,9 +77,29 @@ def record_review(
     return _write_receipt(slug, number, receipt)
 
 
+def record_open_review(slug: str, head: str, finding_count: int) -> Path:
+    """Write the receipt for one review pass run before the pull request opens.
+
+    Args:
+        slug: Repository as ``owner/name``.
+        head: The commit the pass reviewed.
+        finding_count: How many findings the pass reported.
+
+    Returns:
+        The receipt path written.
+    """
+    owner, repo = slug.split("/", 1)
+    return _write_receipt_at(
+        open_receipt_path(owner, repo, head), _receipt_fields(head, finding_count, 0, "")
+    )
+
+
 def _write_receipt(slug: str, number: int, all_receipt_fields: dict[str, object]) -> Path:
     owner, repo = slug.split("/", 1)
-    path = receipt_path(owner, repo, number)
+    return _write_receipt_at(receipt_path(owner, repo, number), all_receipt_fields)
+
+
+def _write_receipt_at(path: Path, all_receipt_fields: dict[str, object]) -> Path:
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(json.dumps(all_receipt_fields) + "\n", encoding="utf-8")
     return path
@@ -94,7 +127,9 @@ def main(all_arguments: Sequence[str], stdout: TextIO = sys.stdout) -> int:
     """
     parser = argparse.ArgumentParser(prog="merge_review_receipt")
     parser.add_argument("slug", help="Repository as owner/name.")
-    parser.add_argument("number", type=int, help="Pull request number.")
+    parser.add_argument(
+        "number", help=f"Pull request number, or {OPEN_TARGET_WORD} before the pull request opens."
+    )
     parser.add_argument("head", help="The head commit the pass reviewed.")
     parser.add_argument("findings", type=int, help="Findings the pass reported.")
     parser.add_argument(
@@ -103,6 +138,23 @@ def main(all_arguments: Sequence[str], stdout: TextIO = sys.stdout) -> int:
     parser.add_argument("--rulings", default="", help="Link to the posted rulings.")
     parsed = parser.parse_args(all_arguments)
     rulings = parsed.rulings.strip()
+    if not REPOSITORY_SLUG_PATTERN.fullmatch(parsed.slug) or ".." in parsed.slug:
+        parser.error("slug must be owner/name")
+    if parsed.number == OPEN_TARGET_WORD:
+        if parsed.ruled_out or rulings:
+            parser.error(f"an {OPEN_TARGET_WORD} pass is clean only at zero findings")
+        if parsed.findings < 0:
+            parser.error("findings must be zero or more")
+        if not OPEN_RECEIPT_HEAD_PATTERN.fullmatch(parsed.head):
+            parser.error(f"an {OPEN_TARGET_WORD} pass needs the full 40 character commit")
+        record_open_review(parsed.slug, parsed.head, parsed.findings)
+        verdict = "CLEAN" if parsed.findings == 0 else "REVIEWED"
+        count_note = "" if parsed.findings == 0 else f" {parsed.findings} findings"
+        stdout.write(f"{verdict} {parsed.slug} {OPEN_TARGET_WORD} {parsed.head}{count_note}\n")
+        return 0 if parsed.findings == 0 else 1
+    if not parsed.number.isdigit():
+        parser.error(f"number must be a pull request number or {OPEN_TARGET_WORD}")
+    parsed.number = int(parsed.number)
     if parsed.ruled_out < 0 or parsed.ruled_out > parsed.findings:
         parser.error("--ruled-out must be between 0 and the finding count")
     if parsed.ruled_out and not rulings:

package/scripts/test_merge_review_receipt.py

@@ -122,3 +122,56 @@ def test_should_report_reviewed_when_the_rulings_link_points_at_another_pull_req
     )
     assert exit_code == 1
     assert verdict_stream.getvalue() == f"REVIEWED acme/tools#12 {HEAD} 2 findings\n"
+
+
+def test_should_record_a_clean_open_pass_under_heads(receipt_folder: Path) -> None:
+    verdict_stream = StringIO()
+    assert merge_review_receipt.main(["acme/tools", "open", HEAD, "0"], verdict_stream) == 0
+    assert verdict_stream.getvalue() == f"CLEAN acme/tools open {HEAD}\n"
+    receipt = json.loads((receipt_folder / "heads" / f"acme__tools__{HEAD}.json").read_text())
+    assert receipt == {"head": HEAD, "findings": 0}
+
+
+def test_record_open_review_writes_the_head_receipt_in_lowercase(receipt_folder: Path) -> None:
+    path = merge_review_receipt.record_open_review("Acme/Tools", HEAD.upper(), 2)
+    assert path == receipt_folder / "heads" / f"acme__tools__{HEAD}.json"
+    assert json.loads(path.read_text(encoding="utf-8")) == {"head": HEAD.upper(), "findings": 2}
+
+
+def test_should_exit_one_for_an_open_pass_with_findings() -> None:
+    verdict_stream = StringIO()
+    assert merge_review_receipt.main(["acme/tools", "open", HEAD, "2"], verdict_stream) == 1
+    assert verdict_stream.getvalue() == f"REVIEWED acme/tools open {HEAD} 2 findings\n"
+
+
+@pytest.mark.parametrize(
+    "all_arguments",
+    [
+        ["acme/tools", "open", HEAD, "-1"],
+        ["acme/tools", "open", HEAD, "2", "--ruled-out", "2", "--rulings", RULINGS_LINK],
+        ["acme/tools", "twelve", HEAD, "0"],
+    ],
+)
+def test_should_refuse_an_open_pass_it_cannot_record(
+    all_arguments: list[str], receipt_folder: Path
+) -> None:
+    with pytest.raises(SystemExit):
+        merge_review_receipt.main(all_arguments, StringIO())
+    assert list(receipt_folder.iterdir()) == []
+
+
+@pytest.mark.parametrize("head", ["abc", "abc1234", "../../escape", "zzzzzzz"])
+def test_should_refuse_an_open_pass_whose_head_is_not_a_commit(head: str, receipt_folder: Path) -> None:
+    with pytest.raises(SystemExit):
+        merge_review_receipt.main(["acme/tools", "open", head, "0"], StringIO())
+    assert list(receipt_folder.iterdir()) == []
+
+
+@pytest.mark.parametrize("slug", ["owner-repo", "a/b/../c", "a/.."])
+@pytest.mark.parametrize("number", ["open", "12"])
+def test_should_refuse_a_slug_that_is_not_owner_and_name(
+    slug: str, number: str, receipt_folder: Path
+) -> None:
+    with pytest.raises(SystemExit):
+        merge_review_receipt.main([slug, number, HEAD, "0"], StringIO())
+    assert list(receipt_folder.iterdir()) == []