claude-dev-env 8.92.2 → 8.93.0

package/hooks/advisory/owned_pr_review_loop.py

@@ -53,7 +53,10 @@ try:
         ALL_PRESET_REPOSITORY_DIGESTS,
         ALL_SHELL_COMMAND_INPUT_KEYS,
         ALL_SHELL_TOOL_NAMES,
+        ALL_PYTHON_SCRIPTLESS_OPTIONS,
         ALREADY_EXISTS_MARKER,
+        BACKSLASH,
+        DOUBLED_BACKSLASH,
         GH_API_POST_METHOD,
         GH_API_PULLS_ENDPOINT_PATTERN,
         GH_API_SUBCOMMAND,
@@ -68,14 +71,28 @@ try:
         MCP_TOOL_NAME_PREFIX,
         NAME_DIGEST_TEXT_ENCODING,
         PULL_REQUEST_URL_PATTERN,
+        PYTHON_OPTION_AND_VALUE_WORD_COUNT,
+        PYTHON_OPTION_PREFIX,
+        PYTHON_SHORT_OPTION_LENGTH,
         REVIEW_LOOP_CONTEXT_TEMPLATE,
         SHELL_ARGUMENT_SEPARATOR,
     )
     from hooks_constants.post_tool_use_context import (
         write_post_tool_use_context_to_stdout,
     )
+    from hooks_constants.pr_lifecycle_skill_gate_constants import PYTHON_OPTIONS_WITH_VALUE
     from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
-    from hooks_constants.shell_command_segments import command_tokens, split_into_segments
+    from hooks_constants.pull_request_proof_constants import (
+        ALL_PYTHON_PROGRAM_NAMES,
+        PULL_REQUEST_SCRIPT_CREATE_WORD,
+        PULL_REQUEST_SCRIPT_NAME,
+    )
+    from hooks_constants.pytest_invocation import unquoted_token
+    from hooks_constants.shell_command_segments import (
+        command_tokens,
+        split_into_segments,
+        token_basename,
+    )
     from hooks_constants.shell_command_wrappers import (
         all_wrapped_command_texts,
         segment_program_and_arguments,
@@ -127,8 +144,34 @@ def _is_gh_api_pulls_post(all_arguments: list[str]) -> bool:
     return sends_body
 
 
+def _python_script_index(all_arguments: list[str]) -> int | None:
+    index = 0
+    while index < len(all_arguments) and all_arguments[index].startswith(PYTHON_OPTION_PREFIX):
+        if all_arguments[index][:PYTHON_SHORT_OPTION_LENGTH] in ALL_PYTHON_SCRIPTLESS_OPTIONS:
+            return None
+        is_option_with_value = all_arguments[index] in PYTHON_OPTIONS_WITH_VALUE
+        index += PYTHON_OPTION_AND_VALUE_WORD_COUNT if is_option_with_value else 1
+    return index if index < len(all_arguments) else None
+
+
+def _is_pull_request_script_create(program_name: str, all_arguments: list[str]) -> bool:
+    all_script_arguments = all_arguments
+    if program_name != PULL_REQUEST_SCRIPT_NAME:
+        script_index = (
+            _python_script_index(all_arguments) if program_name in ALL_PYTHON_PROGRAM_NAMES else None
+        )
+        if script_index is None:
+            return False
+        if token_basename(unquoted_token(all_arguments[script_index])) != PULL_REQUEST_SCRIPT_NAME:
+            return False
+        all_script_arguments = all_arguments[script_index + 1 :]
+    return all_script_arguments[:1] == [PULL_REQUEST_SCRIPT_CREATE_WORD]
+
+
 def _segment_opens_pull_request(all_segment_tokens: list[str]) -> bool:
     program_name, all_arguments = segment_program_and_arguments(all_segment_tokens)
+    if _is_pull_request_script_create(program_name, all_arguments):
+        return True
     return program_name == GH_PROGRAM_NAME and (
         _is_gh_pr_create(all_arguments) or _is_gh_api_pulls_post(all_arguments)
     )
@@ -137,11 +180,18 @@ def _segment_opens_pull_request(all_segment_tokens: list[str]) -> bool:
 def command_creates_pull_request(command: str) -> bool:
     """Return True when any segment of the shell command opens a pull request.
 
-    Three shapes count::
+    Four shapes count::
 
         gh pr create --fill
         gh pr new --fill
         gh api repos/acme/widgets/pulls --input pr.json
+        python ~/.agents/skills/pull-request/scripts/pull_request.py create --repo acme/widgets
+
+    The publisher counts when ``python``, ``python3``, or ``py`` runs a
+    script named ``pull_request.py`` with ``create``, or the script runs
+    alone. Interpreter options such as ``-X utf8`` before the script are
+    skipped, and an unquoted Windows path such as
+    ``C:\\tools\\pull_request.py`` keeps its separators.
 
     A ``gh api`` call counts only when it targets the pulls collection. An
     explicit method (``-X POST``, ``-XPOST``, ``--method=POST``) decides
@@ -157,7 +207,11 @@ def command_creates_pull_request(command: str) -> bool:
     return any(
         _segment_opens_pull_request(each_segment)
         for each_command_text in all_wrapped_command_texts(command)
-        for each_segment in split_into_segments(command_tokens(each_command_text))
+        for each_command_tokens in (
+            command_tokens(each_command_text),
+            command_tokens(each_command_text.replace(BACKSLASH, DOUBLED_BACKSLASH)),
+        )
+        for each_segment in split_into_segments(each_command_tokens)
     )
 
 

package/hooks/advisory/test_owned_pr_review_loop.py

@@ -85,6 +85,13 @@ def _context_of(stdout: str) -> str:
         "gh api --method=POST repos/acme/widgets/pulls",
         "gh api -XPOST repos/acme/widgets/pulls",
         "gh api repos/acme/widgets/pulls -Ftitle=t -fhead=x",
+        'python "C:/Users/me/.agents/skills/pull-request/scripts/pull_request.py" create --repo acme/widgets',
+        "python3 ~/.agents/skills/pull-request/scripts/pull_request.py create --title t",
+        "py pull_request.py create --fill",
+        "git push && python pull_request.py create --repo acme/widgets 2>&1 | tail -5",
+        "python -X utf8 ~/.agents/skills/pull-request/scripts/pull_request.py create --fill",
+        "python -I -W ignore pull_request.py create",
+        "python C:\\Users\\me\\.agents\\skills\\pull-request\\scripts\\pull_request.py create",
     ],
 )
 def test_should_detect_gh_pr_create(command: str) -> None:
@@ -103,6 +110,12 @@ def test_should_detect_gh_pr_create(command: str) -> None:
         "gh api repos/acme/widgets/issues --input issue.json",
         "gh api --method GET repos/acme/widgets/pulls -f state=open",
         "gh api -X GET repos/acme/widgets/pulls -f state=open",
+        "python pull_request.py edit --repo acme/widgets --number 42",
+        "python other_script.py create",
+        "python pull_request.py",
+        "python -m pull_request.py create",
+        "python -c pull_request.py create",
+        "python C:\\Users\\me\\scripts\\my_pull_request.py create",
     ],
 )
 def test_should_not_detect_other_commands(command: str) -> None:
@@ -325,6 +338,16 @@ def test_main_should_emit_the_loop_after_a_gh_api_pulls_post() -> None:
     assert "jl-cmd-projects/claude-dev-env#42" in _context_of(stdout)
 
 
+def test_main_should_emit_the_loop_after_the_pull_request_publisher_creates() -> None:
+    publisher_command = (
+        'python "C:/Users/me/.agents/skills/pull-request/scripts/pull_request.py" create'
+        " --repo jl-cmd-projects/claude-dev-env --base main --head fix/x --title t"
+        " --body-file body.md 2>&1 | tail -5"
+    )
+    stdout = _run_hook(_shell_payload(publisher_command, f"{OWNED_PR_URL}\n"))
+    assert "jl-cmd-projects/claude-dev-env#42" in _context_of(stdout)
+
+
 def test_main_should_emit_the_loop_for_a_codex_shell_call() -> None:
     stdout = _run_hook(
         _shell_payload(

package/hooks/blocking/reply_length_gate.py

@@ -77,9 +77,11 @@ later pass, so this gate denies it and the model resends a shorter one.
 
 from __future__ import annotations
 
+import itertools
 import json
 import os
 import re
+import shlex
 import sys
 from pathlib import Path
 
@@ -87,6 +89,7 @@ hooks_root_directory = str(Path(__file__).resolve().parent.parent)
 if hooks_root_directory not in sys.path:
     sys.path.insert(0, hooks_root_directory)
 
+from gh_post_body_texts import extract_mcp_body_texts
 from json_file_reader import read_json_object
 from visual_reply_rules import (
     VisualReplyRules,
@@ -106,6 +109,17 @@ from hooks_constants.hook_specific_output_keys import (
     HOOK_SPECIFIC_OUTPUT_KEY,
 )
 from hooks_constants.reply_length_gate_constants import (
+    ALL_CHECKED_MCP_TOOL_NAMES,
+    BASH_TOOL_NAME,
+    COMMAND_KEY,
+    COMMENT_RETRY_INSTRUCTION,
+    DETAILS_BLOCK_PATTERN,
+    ALL_GH_BODY_FLAGS,
+    ALL_GH_COMMENT_ACTIONS,
+    ALL_GH_COMMENT_GROUPS,
+    GH_BODY_FLAG_PREFIX,
+    GH_PROGRAM_NAME,
+    SHELL_OPERATOR_CHARACTERS,
     ALL_CHECKED_TOOL_NAMES,
     ALL_DECISION_CARD_LENGTH_KEYS,
     ALL_DECISION_CARD_PROSE_KEYS,
@@ -482,6 +496,81 @@ def tool_violation(
     return None if violation is None else (violation, reply_text)
 
 
+def github_comment_texts(tool_name: object, all_tool_input: dict[str, object]) -> list[str]:
+    """Return the GitHub comment texts one call would post, or an empty list.
+
+    ::
+
+        mcp__github__add_issue_comment {"body": "Done."}  -> ["Done."]
+        Bash 'gh pr comment 12 --body "Done."'            -> ["Done."]
+        Bash 'git push && gh pr comment 12 --body "Done."' -> ["Done."]
+        Bash 'gh pr create --body "Long body"'            -> []
+    """
+    if tool_name in ALL_CHECKED_MCP_TOOL_NAMES:
+        return extract_mcp_body_texts(all_tool_input)
+    command = all_tool_input.get(COMMAND_KEY)
+    if tool_name != BASH_TOOL_NAME or not isinstance(command, str):
+        return []
+    try:
+        command_lexer = shlex.shlex(command, posix=True, punctuation_chars=True)
+        command_lexer.whitespace_split = True
+        all_command_tokens = list(command_lexer)
+    except ValueError:
+        return []
+    return gh_comment_bodies(all_command_tokens)
+
+
+def gh_comment_bodies(all_command_tokens: list[str]) -> list[str]:
+    """Return the ``--body`` values of each ``gh pr|issue comment|review`` call in the tokens.
+
+    ::
+
+        git push && gh -R o/r pr comment 12 --body "Done."  -> ["Done."]
+        gh pr create --body "Long body"                     -> []
+    """
+    all_bodies: list[str] = []
+    for each_command_tokens in gh_command_token_runs(all_command_tokens):
+        all_pairs = list(itertools.pairwise(each_command_tokens))
+        if not any(
+            each_group in ALL_GH_COMMENT_GROUPS and each_action in ALL_GH_COMMENT_ACTIONS
+            for each_group, each_action in all_pairs
+        ):
+            continue
+        all_bodies.extend(
+            each_token[len(GH_BODY_FLAG_PREFIX):]
+            for each_token in each_command_tokens
+            if each_token.startswith(GH_BODY_FLAG_PREFIX)
+        )
+        all_bodies.extend(each_value for each_flag, each_value in all_pairs if each_flag in ALL_GH_BODY_FLAGS)
+    return all_bodies
+
+
+def is_command_token(token: str) -> bool:
+    """Return True when the token is part of a command, False for ``&&``, ``||``, ``;`` or ``|``."""
+    return not set(token) <= SHELL_OPERATOR_CHARACTERS
+
+
+def gh_command_token_runs(all_command_tokens: list[str]) -> list[list[str]]:
+    """Return the tokens after each ``gh`` token, up to the next shell operator."""
+    all_runs: list[list[str]] = []
+    for each_index, each_token in enumerate(all_command_tokens):
+        if each_token == GH_PROGRAM_NAME:
+            all_runs.append(list(itertools.takewhile(is_command_token, all_command_tokens[each_index + 1:])))
+    return all_runs
+
+
+def github_comment_violation(tool_name: object, all_tool_input: dict[str, object]) -> tuple[str, str] | None:
+    """Return the deny reason and text for an over-long GitHub comment, or None.
+
+    Fenced code blocks and collapsed ``<details>`` blocks carry no words.
+    """
+    for each_comment_text in github_comment_texts(tool_name, all_tool_input):
+        violation = length_violation(DETAILS_BLOCK_PATTERN.sub(" ", each_comment_text))
+        if violation is not None:
+            return violation + COMMENT_RETRY_INSTRUCTION, each_comment_text
+    return None
+
+
 def write_flowchart_advice(tool_name: object, all_tool_input: dict[str, object]) -> None:
     """Print the flowchart advice for an allowed widget call that is not a flowchart."""
     mode_rules = active_mode_rules()
@@ -502,7 +591,9 @@ def main() -> int:
     tool_input = hook_input.get(TOOL_INPUT_KEY)
     if not isinstance(tool_input, dict):
         return ALLOW_EXIT_CODE
-    checked = tool_violation(tool_name, tool_input, hook_input.get(TRANSCRIPT_PATH_KEY))
+    checked = github_comment_violation(tool_name, tool_input) or tool_violation(
+        tool_name, tool_input, hook_input.get(TRANSCRIPT_PATH_KEY)
+    )
     if checked is None:
         write_flowchart_advice(tool_name, tool_input)
         return ALLOW_EXIT_CODE

package/hooks/blocking/test_reply_length_gate.py

@@ -1022,3 +1022,46 @@ def test_should_leave_the_transcript_unread_when_the_text_cites_nothing(
 def test_should_split_prose_sentences_outside_fenced_blocks() -> None:
     reply_text = "First one. Second one?\n```\nskipped. code\n```\nThird"
     assert reply_length_gate.prose_sentences(reply_text) == ["First one.", "Second one?", "", "Third"]
+
+
+LONG_GITHUB_COMMENT = " ".join(
+    "Sentence number one of a long comment that keeps going." for _ in range(50)
+)
+SHORT_GITHUB_COMMENT = "Fixed the cap check. The test now covers it. Checks pass."
+
+
+def test_should_deny_long_github_comment(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, error_text = run_gate(
+        monkeypatch, capsys, "mcp__github__add_issue_comment", {"body": LONG_GITHUB_COMMENT}
+    )
+    assert exit_code == 2
+    assert "50 sentences, limit 3" in error_text
+
+
+def test_should_allow_short_github_comment_with_code_and_details(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    comment_text = (
+        SHORT_GITHUB_COMMENT
+        + "\n```\n" + LONG_GITHUB_COMMENT + "\n```\n"
+        + "<details><summary>Log</summary>\n" + LONG_GITHUB_COMMENT + "\n</details>"
+    )
+    exit_code, error_text = run_gate(
+        monkeypatch, capsys, "mcp__github__add_issue_comment", {"body": comment_text}
+    )
+    assert (exit_code, error_text) == (0, "")
+
+
+def test_should_read_gh_comment_body_and_skip_pr_create() -> None:
+    comment_command = f'gh pr comment 12 --body "{LONG_GITHUB_COMMENT}"'
+    create_command = f'gh pr create --body "Run gh pr comment 12 to reply. {LONG_GITHUB_COMMENT}"'
+    assert reply_length_gate.github_comment_texts("Bash", {"command": comment_command}) == [LONG_GITHUB_COMMENT]
+    assert reply_length_gate.github_comment_texts("Bash", {"command": create_command}) == []
+    multiline_command = 'gh pr comment 12 --body "' + LONG_GITHUB_COMMENT.replace(". ", ".\n") + '"'
+    assert len(reply_length_gate.github_comment_texts("Bash", {"command": multiline_command})) == 1
+    flagged_command = f'git push\ngh -R o/r pr comment 12 --body "note=x. {LONG_GITHUB_COMMENT}"'
+    assert reply_length_gate.github_comment_texts("Bash", {"command": flagged_command}) == [f"note=x. {LONG_GITHUB_COMMENT}"]
+    chained_command = f"git push && {comment_command}"
+    assert reply_length_gate.github_comment_texts("Bash", {"command": chained_command}) == [LONG_GITHUB_COMMENT]

package/hooks/features/bash-dispatchers.md

@@ -23,7 +23,7 @@ This family rewrites a Git Bash command when path conversion would change a revi
 - `blocking/cloud_graphql_gate.py` runs inside that dispatcher on `PreToolUse`, matcher `Bash`, timeout `60` seconds, for the Bash and PowerShell tools, when `CLAUDE_CODE_REMOTE` is `true`.
 - `blocking/bash_post_call_dispatcher.py` runs on `PostToolUse`, matcher `Bash|PowerShell`, timeout `60` seconds in `hooks.json`.
 - `advisory/pr_done_reminder.py` runs inside that dispatcher on `PostToolUse`, matcher `Bash|PowerShell`, timeout `60` seconds. `ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES` selects `Bash` and `PowerShell`.
-- `advisory/owned_pr_review_loop.py` runs on `PostToolUse`, matcher `Bash|PowerShell|exec_command|shell_command|mcp__.*__(create_pull_request|github_create_pull_request)`, timeout `10` seconds in `hooks.json`. It wakes on `gh pr create`, `gh pr new`, a POST to `gh api repos/<owner>/<repo>/pulls`, and an MCP pull request creation. The installer also registers it on Codex `PostToolUse` through `ALL_CODEX_NATIVE_POST_TOOL_USE_HOOK_SCRIPT_NAMES`.
+- `advisory/owned_pr_review_loop.py` runs on `PostToolUse`, matcher `Bash|PowerShell|exec_command|shell_command|mcp__.*__(create_pull_request|github_create_pull_request)`, timeout `10` seconds in `hooks.json`. It wakes on `gh pr create`, `gh pr new`, a POST to `gh api repos/<owner>/<repo>/pulls`, a `pull_request.py create` call to the pull request publisher, and an MCP pull request creation. The installer also registers it on Codex `PostToolUse` through `ALL_CODEX_NATIVE_POST_TOOL_USE_HOOK_SCRIPT_NAMES`.
 - `blocking/owned_pr_merge_stop_gate.py` runs on `Stop`, timeout `60` seconds in `hooks.json`. The installer also registers it on Codex `Stop` through `ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES`.
 
 ## Proving it

package/hooks/hooks.json

@@ -273,6 +273,16 @@
             "timeout": 15
           }
         ]
+      },
+      {
+        "matcher": "Bash|mcp__github__add_issue_comment|mcp__github__update_issue_comment|mcp__github__add_reply_to_pull_request_comment|mcp__github__add_comment_to_pending_review|mcp__github__pull_request_review_write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/reply_length_gate.py",
+            "timeout": 10
+          }
+        ]
       }
     ],
     "UserPromptSubmit": [

package/hooks/hooks_constants/owned_pr_review_loop_constants.py

@@ -39,6 +39,12 @@ __all__ = [
     "GH_SHORT_OPTION_LENGTH",
     "ALL_GH_API_SHORT_OPTIONS",
     "GH_OPTION_VALUE_SEPARATOR",
+    "PYTHON_OPTION_PREFIX",
+    "PYTHON_SHORT_OPTION_LENGTH",
+    "PYTHON_OPTION_AND_VALUE_WORD_COUNT",
+    "ALL_PYTHON_SCRIPTLESS_OPTIONS",
+    "BACKSLASH",
+    "DOUBLED_BACKSLASH",
     "MCP_TOOL_NAME_PREFIX",
     "ALL_MCP_CREATE_PULL_REQUEST_TOOL_SUFFIXES",
     "MCP_OWNER_INPUT_KEY",
@@ -85,6 +91,12 @@ GH_LONG_OPTION_PREFIX: str = "--"
 GH_SHORT_OPTION_LENGTH: int = 2
 ALL_GH_API_SHORT_OPTIONS: frozenset[str] = frozenset({"-f", "-F", "-X"})
 GH_OPTION_VALUE_SEPARATOR: str = "="
+PYTHON_OPTION_PREFIX: str = "-"
+PYTHON_SHORT_OPTION_LENGTH: int = 2
+PYTHON_OPTION_AND_VALUE_WORD_COUNT: int = 2
+ALL_PYTHON_SCRIPTLESS_OPTIONS: frozenset[str] = frozenset({"-m", "-c"})
+BACKSLASH: str = "\\"
+DOUBLED_BACKSLASH: str = "\\\\"
 
 MCP_TOOL_NAME_PREFIX: str = "mcp__"
 ALL_MCP_CREATE_PULL_REQUEST_TOOL_SUFFIXES: tuple[str, ...] = (

package/hooks/hooks_constants/reply_length_gate_constants.py

@@ -159,3 +159,25 @@ UNSEEN_CITATION_MESSAGE = (
 )
 
 ADDITIONAL_CONTEXT_KEY = "additionalContext"
+ALL_CHECKED_MCP_TOOL_NAMES = frozenset(
+    {
+        "mcp__github__add_issue_comment",
+        "mcp__github__update_issue_comment",
+        "mcp__github__add_reply_to_pull_request_comment",
+        "mcp__github__add_comment_to_pending_review",
+        "mcp__github__pull_request_review_write",
+    }
+)
+BASH_TOOL_NAME = "Bash"
+COMMAND_KEY = "command"
+SHELL_OPERATOR_CHARACTERS = frozenset("&|;")
+GH_PROGRAM_NAME = "gh"
+ALL_GH_COMMENT_GROUPS = frozenset({"pr", "issue"})
+ALL_GH_COMMENT_ACTIONS = frozenset({"comment", "review"})
+ALL_GH_BODY_FLAGS = frozenset({"--body", "-b"})
+GH_BODY_FLAG_PREFIX = "--body="
+DETAILS_BLOCK_PATTERN = re.compile(r"<details\b.*?</details>", re.IGNORECASE | re.DOTALL)
+COMMENT_RETRY_INSTRUCTION = (
+    " A comment on GitHub holds at most three short sentences."
+    " Put detail in the pull request body, a code block, or a collapsed <details> block, then post again."
+)

package/package.json

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