claude-dev-env 1.74.0 → 1.76.0

package/hooks/blocking/code_rules_shared.py

@@ -4,7 +4,7 @@ import ast
 import difflib
 import os
 import sys
-from collections.abc import Iterator
+from collections.abc import Collection, Iterator
 from pathlib import Path
 
 _blocking_directory = str(Path(__file__).resolve().parent)
@@ -360,7 +360,7 @@ def changed_line_numbers(prior_content: str, post_edit_content: str) -> set[int]
 
 
 def _scope_violations_to_changed_lines(
-    all_violations_in_walk_order: list[tuple[range, str]],
+    all_violations_in_walk_order: list[tuple[Collection[int], str]],
     all_changed_lines: set[int] | None,
     defer_scope_to_caller: bool = False,
 ) -> list[str]:
@@ -381,9 +381,12 @@ def _scope_violations_to_changed_lines(
       block a single-file edit.
 
     Args:
-        all_violations_in_walk_order: ``(span_range, issue_message)`` pairs in
-            ``ast.walk`` traversal order, where ``span_range`` covers the
-            violation's source lines.
+        all_violations_in_walk_order: ``(line_collection, issue_message)`` pairs
+            in ``ast.walk`` traversal order, where ``line_collection`` holds the
+            violation's source lines. A whole-function violation passes a
+            contiguous ``range``; a two-function violation passes the union of
+            both functions' lines, so the lines between the two functions stay
+            out of scope and an edit to only that gap does not block.
         all_changed_lines: Post-edit line numbers the current edit touched, or
             None to treat every violation as in-scope.
         defer_scope_to_caller: When True, return every violation message in walk

package/hooks/blocking/code_rules_test_assertions.py

@@ -286,7 +286,7 @@ def _name_encodes_scenario(test_name: str) -> bool:
     return any(each_clause in test_name for each_clause in _SCENARIO_NAME_CLAUSES)
 
 
-def check_flag_gated_scenario_test_naming(content: str, file_path: str) -> list[str]:
+def check_flag_gated_scenario_test_naming(content: str, file_path: str) -> None:
     """Flag a scenario-named test that omits a flag its siblings establish.
 
     When two or more sibling tests in a file monkeypatch the same module-level
@@ -302,15 +302,16 @@ def check_flag_gated_scenario_test_naming(content: str, file_path: str) -> list[
         file_path: Path to the file, used for the test-file gate.
 
     Returns:
-        An empty list; advisories print to stderr so the write proceeds.
+        None; advisories print to stderr and this check never contributes to
+        the blocking issue list, so the write proceeds.
     """
     if not is_test_file(file_path):
-        return []
+        return
 
     try:
         syntax_tree = ast.parse(content)
     except SyntaxError:
-        return []
+        return
 
     test_functions = [
         each_node
@@ -333,7 +334,7 @@ def check_flag_gated_scenario_test_naming(content: str, file_path: str) -> list[
         if patch_count >= _MINIMUM_SIBLING_PATCH_COUNT
     }
     if not established_flags:
-        return []
+        return
 
     for each_test in test_functions:
         if not _name_encodes_scenario(each_test.name):
@@ -349,8 +350,6 @@ def check_flag_gated_scenario_test_naming(content: str, file_path: str) -> list[
                 file=sys.stderr,
             )
 
-    return []
-
 
 def _called_function_names(function_node: ast.FunctionDef | ast.AsyncFunctionDef) -> set[str]:
     """Return the bare names of every function the test body calls."""

package/hooks/blocking/code_verifier_spawn_preflight_gate.py

@@ -5,7 +5,8 @@ The hook fires only on an ``Agent`` tool call whose ``subagent_type`` is
 ``code-verifier``. Before that verification spawn runs, the hook checks the
 branch for two committability problems against the resolved base ref: a real
 merge conflict (a non-mutating trial-merge of HEAD against the base ref) and a
-CODE_RULES violation on a line added in the uncommitted working tree. When
+CODE_RULES violation on a line added in the working tree since the merge base
+(committed on the branch or uncommitted). When
 either fires, the hook denies the spawn with a reason addressed to the spawning
 agent that names the conflicting files and the violating file:line, so that
 agent fixes them and re-spawns. Both checks fail OPEN on any infrastructure

package/hooks/blocking/duplicate_rmtree_helper_blocker.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""PreToolUse hook: block a local re-definition of the Windows-safe rmtree helper trio.
+
+The Windows-safe deletion helper trio — `_strip_read_only_and_retry`,
+`_force_remove_tree`/`force_rmtree`, and the `inspect.signature` onexc/onerror guard —
+is the sanctioned pattern for removing a directory tree that may hold ReadOnly files.
+Because the windows_rmtree_blocker corrective message ships the trio as a paste-ready
+snippet, agents paste a fresh local copy into each module that needs cleanup. Three
+near-matching copies already span one codebase (a parser service, a categorizer, and a
+test isolation helper), so a fix to one copy never reaches the others — the exact
+"duplicated logic drifts" failure CODE_RULES.md section 3 (Reuse before create) names.
+
+This hook scans Write/Edit content to a Python file for a `def` of any sanctioned
+helper name and blocks it with a corrective message pointing to a single shared
+force_rmtree utility. The canonical shared-helper home, the rmtree-blocker hook
+sources (whose corrective strings embed the snippet), and test files are exempt.
+
+This complements the same-directory `check_duplicate_function_body_across_files`
+gate, which compares a written function only against `.py` siblings in its own
+directory. That scope leaves a copy of this trio between two distant packages
+unguarded, which is how the copies above spread. Keying on the sanctioned helper
+names blocks the cross-directory copy the structural same-directory check cannot
+reach.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+_hooks_dir = str(Path(__file__).resolve().parent.parent)
+if _hooks_dir not in sys.path:
+    sys.path.insert(0, _hooks_dir)
+
+from hooks_constants.duplicate_rmtree_helper_blocker_constants import (  # noqa: E402
+    ALL_EXEMPT_PATH_FRAGMENTS,
+    ALL_EXEMPT_TEST_FILE_PREFIXES,
+    ALL_EXEMPT_TEST_FILE_SUFFIXES,
+    HELPER_DEFINITION_PATTERN,
+    PYTHON_FILE_EXTENSION,
+    TRIPLE_QUOTED_STRING_PATTERN,
+)
+from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin  # noqa: E402
+
+
+def payload_defines_sanctioned_helper(payload_text: str) -> bool:
+    """Return True when the text defines a sanctioned Windows-safe rmtree helper.
+
+    Args:
+        payload_text: The file content or new_string fragment under inspection.
+
+    Returns:
+        True when a line defines `_strip_read_only_and_retry`, `_force_remove_tree`,
+        or `force_rmtree`. Triple-quoted string bodies are masked before the
+        line-anchored pattern runs, so a `def` that begins its own line inside a
+        documentation snippet or multi-line string literal is left untouched. A
+        helper name inside a single-line quoted string carries a quote before `def`,
+        so the line-anchored pattern leaves it untouched as well.
+    """
+    if not payload_text:
+        return False
+    masked_text = TRIPLE_QUOTED_STRING_PATTERN.sub("", payload_text)
+    return bool(HELPER_DEFINITION_PATTERN.search(masked_text))
+
+
+def path_is_exempt(file_path: str) -> bool:
+    """Return True when a Python path may carry the helper definition.
+
+    Args:
+        file_path: The target path the Write/Edit writes to.
+
+    Returns:
+        True when the path's basename is the canonical shared-helper home, an
+        rmtree-blocker hook source, one of the existing in-repo definition sites
+        (session_env_cleanup.py, _md_to_html_blocker_test_support.py,
+        teardown_worktrees.py), or a test file. A definition there is intentional.
+        Basename equality (not substring containment) prevents a sibling whose name
+        merely contains an exempt fragment from bypassing the block.
+    """
+    normalized_path = file_path.replace("\\", "/")
+    file_name = normalized_path.rsplit("/", 1)[-1]
+    if any(file_name.startswith(each_prefix) for each_prefix in ALL_EXEMPT_TEST_FILE_PREFIXES):
+        return True
+    if any(file_name.endswith(each_suffix) for each_suffix in ALL_EXEMPT_TEST_FILE_SUFFIXES):
+        return True
+    return file_name in ALL_EXEMPT_PATH_FRAGMENTS
+
+
+def extract_payload_text(tool_name: str, tool_input: dict) -> tuple[str, str]:
+    """Return the (file_path, scanned_text) pair for a Write/Edit to a Python file.
+
+    Args:
+        tool_name: The PreToolUse tool name.
+        tool_input: The tool input dictionary.
+
+    Returns:
+        A pair of the target path and the text to scan. The text is empty for an
+        unrelated tool or a non-Python target, so the caller exits without blocking.
+    """
+    if tool_name not in {"Write", "Edit"}:
+        return "", ""
+    file_path = tool_input.get("file_path", "") or ""
+    if file_path and not file_path.endswith(PYTHON_FILE_EXTENSION):
+        return file_path, ""
+    scanned_text = tool_input.get("content", "") or tool_input.get("new_string", "") or ""
+    return file_path, scanned_text
+
+
+def main() -> None:
+    corrective_message = (
+        "BLOCKED [duplicate-rmtree-helper]: this Write/Edit defines a local copy of "
+        "the Windows-safe rmtree helper trio (_strip_read_only_and_retry, "
+        "_force_remove_tree / force_rmtree). The trio is already implemented once; a "
+        "second copy drifts from the original — a fix lands in one copy and the other "
+        "keeps the bug (CODE_RULES.md section 3, Reuse before create).\n\n"
+        "Import the shared force_rmtree helper rather than pasting the trio:\n\n"
+        "    from <shared_package>.windows_filesystem import force_rmtree\n"
+        "    force_rmtree(staging_directory)\n\n"
+        "When no shared helper module exists yet, create ONE — a windows-filesystem "
+        "utility module the consuming packages can import — define the trio there once, "
+        "and import it from every call site. Do not paste the trio from the "
+        "windows_rmtree_blocker corrective message into each module.\n\n"
+        "See ~/.claude/rules/windows-filesystem-safe.md for the sanctioned pattern."
+    )
+    hook_input = read_hook_input_dictionary_from_stdin()
+    if hook_input is None:
+        sys.exit(0)
+
+    raw_tool_name = hook_input.get("tool_name", "")
+    raw_tool_input = hook_input.get("tool_input", {})
+    tool_name = raw_tool_name if isinstance(raw_tool_name, str) else ""
+    tool_input = raw_tool_input if isinstance(raw_tool_input, dict) else {}
+
+    file_path, scanned_text = extract_payload_text(tool_name, tool_input)
+
+    if not scanned_text:
+        sys.exit(0)
+    if path_is_exempt(file_path):
+        sys.exit(0)
+    if not payload_defines_sanctioned_helper(scanned_text):
+        sys.exit(0)
+
+    deny_response = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": "deny",
+            "permissionDecisionReason": corrective_message,
+        }
+    }
+    print(json.dumps(deny_response))
+    sys.stdout.flush()
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/hooks/blocking/hedging_language_blocker.py

@@ -18,6 +18,7 @@ if _hooks_dir not in sys.path:
 
 from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 from hooks_constants.messages import USER_FACING_NOTICE  # noqa: E402
+from hooks_constants.text_stripping import strip_code_and_quotes  # noqa: E402
 
 PLUGIN_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
@@ -58,19 +59,6 @@ ALL_HEDGING_PATTERNS = [
     re.compile(pattern, re.IGNORECASE) for pattern in HEDGING_WORDS + HEDGING_PHRASES
 ]
 
-CODE_BLOCK_PATTERN = re.compile(r"```[\s\S]*?```", re.MULTILINE)
-INLINE_CODE_PATTERN = re.compile(r"`[^`]+`")
-QUOTED_BLOCK_PATTERN = re.compile(r"^>.*$", re.MULTILINE)
-
-
-def strip_code_and_quotes(text: str) -> str:
-    """Remove code blocks, inline code, and blockquotes to avoid false positives."""
-    text = CODE_BLOCK_PATTERN.sub("", text)
-    text = INLINE_CODE_PATTERN.sub("", text)
-    text = QUOTED_BLOCK_PATTERN.sub("", text)
-    return text
-
-
 def find_hedging_words(text: str) -> list[str]:
     """Return all hedging words/phrases found in the text."""
     prose_text = strip_code_and_quotes(text)

package/hooks/blocking/intent_only_ending_blocker.py

@@ -20,21 +20,7 @@ if _hooks_dir not in sys.path:
 
 from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 from hooks_constants.messages import USER_FACING_INTENT_ENDING_NOTICE  # noqa: E402
-
-
-def strip_code_and_quotes(text: str) -> str:
-    """Remove code blocks, inline code, and blockquotes to avoid false positives.
-
-    Args:
-        text: The raw assistant message to clean.
-    """
-    code_block_pattern = re.compile(r"```[\s\S]*?```", re.MULTILINE)
-    inline_code_pattern = re.compile(r"`[^`]+`")
-    quoted_block_pattern = re.compile(r"^>.*$", re.MULTILINE)
-    text = code_block_pattern.sub("", text)
-    text = inline_code_pattern.sub("", text)
-    text = quoted_block_pattern.sub("", text)
-    return text
+from hooks_constants.text_stripping import strip_code_and_quotes  # noqa: E402
 
 
 def extract_final_paragraph(text: str) -> str:

package/hooks/blocking/pre_tool_use_dispatcher.py

@@ -8,8 +8,8 @@ decision when any hook denied (carrying every denying reason) or exits zero to
 allow.
 
 The per-hook coverage matrix:
-- Write  -> Group A (10 hooks) + Group B (7 hooks) = 17 hooks
-- Edit   -> Group A (10 hooks) + Group B (7 hooks) = 17 hooks
+- Write  -> Group A (11 hooks) + Group B (7 hooks) = 18 hooks
+- Edit   -> Group A (11 hooks) + Group B (7 hooks) = 18 hooks
 - MultiEdit -> Group B only (7 hooks)
 """
 
@@ -40,6 +40,7 @@ from state_description_blocker import evaluate as evaluate_state_description  #
 from hooks_constants.pre_tool_use_dispatcher_constants import (  # noqa: E402
     ALL_HOSTED_HOOK_ENTRIES,
     ALLOW_DECISION,
+    BLOCKING_CRASH_DENY_REASON,
     BLOCKING_CRASH_EXIT_CODE,
     DENY_DECISION,
     EXIT_CODE_TWO_DENY_REASON,
@@ -360,9 +361,7 @@ def aggregate_hosted_hook_results(
                 parsed_output.deny_reason if parsed_output.deny_reason else EXIT_CODE_TWO_DENY_REASON
             )
         elif each_result.did_crash and each_result.is_blocking:
-            all_deny_reasons.append(
-                "[dispatcher] hook crash in blocking hook — write blocked for safety"
-            )
+            all_deny_reasons.append(BLOCKING_CRASH_DENY_REASON)
         elif each_result.exit_code == BLOCKING_CRASH_EXIT_CODE and each_result.is_blocking:
             all_deny_reasons.append(EXIT_CODE_TWO_DENY_REASON)
         if parsed_output.is_allow:

package/hooks/blocking/question_to_user_enforcer.py

@@ -21,17 +21,7 @@ if _hooks_dir not in sys.path:
 
 from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 from hooks_constants.messages import USER_FACING_ASKUSERQUESTION_NOTICE  # noqa: E402
-
-
-def strip_code_and_quotes(text: str) -> str:
-    """Remove code blocks, inline code, and blockquotes to avoid false positives."""
-    code_block_pattern = re.compile(r"```[\s\S]*?```", re.MULTILINE)
-    inline_code_pattern = re.compile(r"`[^`]+`")
-    quoted_block_pattern = re.compile(r"^>.*$", re.MULTILINE)
-    text = code_block_pattern.sub("", text)
-    text = inline_code_pattern.sub("", text)
-    text = quoted_block_pattern.sub("", text)
-    return text
+from hooks_constants.text_stripping import strip_code_and_quotes  # noqa: E402
 
 
 def extract_final_paragraph(text: str) -> str:

package/hooks/blocking/session_handoff_blocker.py

@@ -23,21 +23,7 @@ from hooks_constants.messages import USER_FACING_CONTEXT_REASSURANCE_NOTICE  # n
 from hooks_constants.session_handoff_blocker_constants import (  # noqa: E402
     FIRST_PERSON_SUBJECT_PATTERN,
 )
-
-
-def strip_code_and_quotes(text: str) -> str:
-    """Remove code blocks, inline code, and blockquotes to avoid false positives.
-
-    Args:
-        text: The raw assistant message to clean.
-    """
-    code_block_pattern = re.compile(r"```[\s\S]*?```", re.MULTILINE)
-    inline_code_pattern = re.compile(r"`[^`]+`")
-    quoted_block_pattern = re.compile(r"^>.*$", re.MULTILINE)
-    text = code_block_pattern.sub("", text)
-    text = inline_code_pattern.sub("", text)
-    text = quoted_block_pattern.sub("", text)
-    return text
+from hooks_constants.text_stripping import strip_code_and_quotes  # noqa: E402
 
 
 def split_into_sentences(text: str) -> list[str]: