claude-dev-env 8.99.1 → 8.100.1

package/hooks/transcript_skill_scan.py

@@ -44,6 +44,17 @@ def _named_skill_inputs(
     all_entry_fields: dict[str, object],
     skill_names: Collection[str],
     accepts_plugin_prefix: bool = True,
+) -> Iterator[dict[str, object]]:
+    for each_block in _named_skill_blocks(all_entry_fields, skill_names, accepts_plugin_prefix):
+        skill_input = each_block["input"]
+        if isinstance(skill_input, dict):
+            yield skill_input
+
+
+def _named_skill_blocks(
+    all_entry_fields: dict[str, object],
+    skill_names: Collection[str],
+    accepts_plugin_prefix: bool = True,
 ) -> Iterator[dict[str, object]]:
     message = all_entry_fields.get("message")
     if all_entry_fields.get("type") != ASSISTANT_ENTRY_TYPE or not isinstance(message, dict):
@@ -61,7 +72,7 @@ def _named_skill_inputs(
             invoked_name == name or (accepts_plugin_prefix and invoked_name.endswith(":" + name))
             for name in skill_names
         ):
-            yield each_block["input"]
+            yield each_block
 
 
 def _invokes_skill(
@@ -183,11 +194,15 @@ def is_skill_loaded_since_last_prompt(
     ::
 
         prompt, Skill verify, tool result, skill body   -> True
+        prompt, Skill verify, tool result with is_error -> False
+        prompt, Skill verify, no tool result yet        -> False
         prompt, Skill verify, prompt                    -> False
         prompt carrying the /verify command marker      -> True
         prompt with the marker, compact boundary        -> False
 
-    A tool result and a meta entry, such as the skill body, leave the turn open.
+    A Skill call counts once its tool result comes back without an error, so a
+    refused load leaves the skill unloaded. A tool result and a meta entry, such
+    as the skill body, leave the turn open.
 
     Args:
         all_transcript_lines: JSON transcript entries, one per line.
@@ -195,13 +210,23 @@ def is_skill_loaded_since_last_prompt(
         slash_command_markers: Accepted user command tags.
     """
     loaded = False
+    all_pending_ids: set[object] = set()
     for each_line in all_transcript_lines:
         all_entry_fields = _parsed_entry(each_line)
         if all_entry_fields is None:
             continue
         if all_entry_fields.get("subtype") == COMPACT_BOUNDARY_SUBTYPE or _is_user_prompt(all_entry_fields):
             loaded = False
-        loaded = loaded or _invokes_skill(all_entry_fields, skill_names, slash_command_markers)
+            all_pending_ids = set()
+        command_text = _user_command_text(all_entry_fields)
+        if command_text is not None:
+            loaded = loaded or any(marker in command_text for marker in slash_command_markers)
+        all_pending_ids.update(
+            each_block["id"]
+            for each_block in _named_skill_blocks(all_entry_fields, skill_names)
+            if each_block.get("id") is not None
+        )
+        loaded = loaded or bool(all_pending_ids & _succeeded_result_ids(all_entry_fields))
     return loaded
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.99.1",
+    "version": "8.100.1",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

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()) == []