claude-dev-env 1.57.2 → 1.59.0

package/hooks/blocking/test_hook_prose_detector_consistency.py

@@ -0,0 +1,265 @@
+"""Unit tests for hook_prose_detector_consistency PreToolUse hook."""
+
+import importlib.util
+import io
+import json
+import pathlib
+import sys
+from unittest import mock
+
+_HOOK_DIR = pathlib.Path(__file__).parent
+_HOOKS_ROOT = _HOOK_DIR.parent
+for _each_root in (str(_HOOK_DIR), str(_HOOKS_ROOT)):
+    if _each_root not in sys.path:
+        sys.path.insert(0, _each_root)
+
+hook_spec = importlib.util.spec_from_file_location(
+    "hook_prose_detector_consistency",
+    _HOOK_DIR / "hook_prose_detector_consistency.py",
+)
+assert hook_spec is not None
+assert hook_spec.loader is not None
+hook_module = importlib.util.module_from_spec(hook_spec)
+hook_spec.loader.exec_module(hook_module)
+
+content_has_violation = hook_module.content_has_violation
+claims_output_key_trigger = hook_module.claims_output_key_trigger
+detects_only_path_shape = hook_module.detects_only_path_shape
+is_constants_module = hook_module.is_constants_module
+is_hook_python_module = hook_module.is_hook_python_module
+is_own_detector_family = hook_module.is_own_detector_family
+written_content = hook_module.written_content
+
+_BLOCKER_MODULE_PATH = "/repo/hooks/blocking/some_blocker.py"
+_CONSTANTS_MODULE_PATH = "/repo/hooks/hooks_constants/some_blocker_constants.py"
+
+_OWN_HOOK_PATH = "/repo/packages/x/hooks/blocking/hook_prose_detector_consistency.py"
+_OWN_CONSTANTS_PATH = (
+    "/repo/packages/x/hooks/hooks_constants/hook_prose_detector_consistency_constants.py"
+)
+_OWN_TEST_PATH = "/repo/packages/x/hooks/blocking/test_hook_prose_detector_consistency.py"
+
+
+_OVERSTATED_MESSAGE_MODULE = (
+    'path_context = re.compile(r"(?:[\\\\/]\\s*([A-Za-z][\\w]*?_[ijk])")\n'
+    "CORRECTIVE_MESSAGE = (\n"
+    '    "A bare per-iteration index token (for example `cand_i`) appears as a path "\n'
+    '    "or output-key segment inside a looping block."\n'
+    ")\n"
+)
+
+_FIXED_MESSAGE_MODULE = (
+    'path_context = re.compile(r"(?:[\\\\/]\\s*([A-Za-z][\\w]*?_[ijk])")\n'
+    "CORRECTIVE_MESSAGE = (\n"
+    '    "A bare per-iteration index token (for example `cand_i`) appears as a "\n'
+    '    "per-iteration path segment inside a looping block."\n'
+    ")\n"
+)
+
+
+def test_overstated_path_shape_module_is_flagged() -> None:
+    assert content_has_violation(_OVERSTATED_MESSAGE_MODULE, _BLOCKER_MODULE_PATH) is True
+
+
+def test_fixed_path_shape_module_passes() -> None:
+    assert content_has_violation(_FIXED_MESSAGE_MODULE, _BLOCKER_MODULE_PATH) is False
+
+
+def test_output_key_claim_without_path_detector_in_blocker_passes() -> None:
+    no_path_detector = (
+        'pattern = re.compile(r"[A-Za-z]+")\n'
+        'CORRECTIVE_MESSAGE = "blocks an output-key segment"\n'
+    )
+    assert content_has_violation(no_path_detector, _BLOCKER_MODULE_PATH) is False
+
+
+def test_output_key_claim_alone_in_constants_module_is_flagged() -> None:
+    constants_only = 'CORRECTIVE_MESSAGE = "appears as a path or output-key segment"\n'
+    assert content_has_violation(constants_only, _CONSTANTS_MODULE_PATH) is True
+
+
+def test_constants_module_without_output_key_claim_passes() -> None:
+    clean_constants = 'CORRECTIVE_MESSAGE = "appears as a per-iteration path segment"\n'
+    assert content_has_violation(clean_constants, _CONSTANTS_MODULE_PATH) is False
+
+
+def test_path_detector_without_output_key_claim_passes() -> None:
+    path_only = 'path_context = re.compile(r"(?:[\\\\/]\\s*([A-Za-z][\\w]*?_[ijk])")\n'
+    assert content_has_violation(path_only, _BLOCKER_MODULE_PATH) is False
+
+
+def test_space_separated_output_key_phrase_is_flagged() -> None:
+    space_variant = (
+        'path_context = re.compile(r"(?:[\\\\/]\\s*(token))")\n'
+        'message = "appears as a path or output key segment"\n'
+    )
+    assert content_has_violation(space_variant, _BLOCKER_MODULE_PATH) is True
+
+
+def test_own_hook_module_is_exempt_from_self_lockout() -> None:
+    own_hook_content = pathlib.Path(hook_module.__file__).read_text(encoding="utf-8")
+    assert content_has_violation(own_hook_content, _OWN_HOOK_PATH) is False
+
+
+def test_own_constants_module_is_exempt_from_self_lockout() -> None:
+    own_constants_path = (
+        _HOOKS_ROOT
+        / "hooks_constants"
+        / "hook_prose_detector_consistency_constants.py"
+    )
+    own_constants_content = own_constants_path.read_text(encoding="utf-8")
+    assert content_has_violation(own_constants_content, _OWN_CONSTANTS_PATH) is False
+
+
+def test_own_test_module_is_exempt_from_self_lockout() -> None:
+    own_test_content = pathlib.Path(__file__).read_text(encoding="utf-8")
+    assert content_has_violation(own_test_content, _OWN_TEST_PATH) is False
+
+
+def test_slot_blocker_constants_companion_passes_at_its_real_path() -> None:
+    slot_constants_path = (
+        _HOOKS_ROOT
+        / "hooks_constants"
+        / "workflow_substitution_slot_blocker_constants.py"
+    )
+    slot_constants_content = slot_constants_path.read_text(encoding="utf-8")
+    assert content_has_violation(slot_constants_content, str(slot_constants_path)) is False
+
+
+def test_is_own_detector_family_recognizes_hook_module() -> None:
+    assert is_own_detector_family(_OWN_HOOK_PATH) is True
+
+
+def test_is_own_detector_family_recognizes_constants_companion() -> None:
+    assert is_own_detector_family(_OWN_CONSTANTS_PATH) is True
+
+
+def test_is_own_detector_family_recognizes_test_module() -> None:
+    assert is_own_detector_family(_OWN_TEST_PATH) is True
+
+
+def test_is_own_detector_family_rejects_unrelated_blocker() -> None:
+    assert is_own_detector_family(_BLOCKER_MODULE_PATH) is False
+
+
+def test_unrelated_constants_module_still_flagged_after_exemption() -> None:
+    constants_only = 'CORRECTIVE_MESSAGE = "appears as a path or output-key segment"\n'
+    assert content_has_violation(constants_only, _CONSTANTS_MODULE_PATH) is True
+
+
+def test_is_constants_module_accepts_constants_suffix() -> None:
+    assert is_constants_module(_CONSTANTS_MODULE_PATH) is True
+
+
+def test_is_constants_module_rejects_blocker_module() -> None:
+    assert is_constants_module(_BLOCKER_MODULE_PATH) is False
+
+
+def test_claims_output_key_trigger_matches_hyphen_form() -> None:
+    assert claims_output_key_trigger("a path or output-key segment here") is True
+
+
+def test_claims_output_key_trigger_ignores_unrelated_output_word() -> None:
+    assert claims_output_key_trigger("the output is written to disk") is False
+
+
+def test_detects_only_path_shape_finds_separator_class() -> None:
+    assert detects_only_path_shape('re.compile(r"[\\\\/]token")') is True
+
+
+def test_detects_only_path_shape_finds_backslash_only_class() -> None:
+    assert detects_only_path_shape(r'pat = re.compile(r"[\\]token")') is True
+
+
+def test_detects_only_path_shape_false_without_separator_class() -> None:
+    assert detects_only_path_shape('re.compile(r"[A-Za-z]+")') is False
+
+
+def test_is_hook_python_module_accepts_hooks_path() -> None:
+    assert is_hook_python_module("/repo/packages/x/hooks/blocking/some_blocker.py") is True
+
+
+def test_is_hook_python_module_rejects_non_hook_path() -> None:
+    assert is_hook_python_module("/repo/src/blocking/some_blocker.py") is False
+
+
+def test_is_hook_python_module_rejects_non_python_file() -> None:
+    assert is_hook_python_module("/repo/hooks/blocking/notes.md") is False
+
+
+def test_written_content_reads_edit_new_string() -> None:
+    edit_input = {"new_string": "edited body"}
+    assert written_content("Edit", edit_input) == "edited body"
+
+
+def _run_main_with_io(input_text: str) -> str:
+    with mock.patch("sys.stdin", io.StringIO(input_text)):
+        with mock.patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
+            try:
+                hook_module.main()
+            except SystemExit:
+                pass
+            return mock_stdout.getvalue()
+
+
+def test_main_blocks_overstated_hook_module_write() -> None:
+    hook_input = {
+        "tool_name": "Write",
+        "tool_input": {
+            "file_path": "/repo/hooks/hooks_constants/some_blocker_constants.py",
+            "content": _OVERSTATED_MESSAGE_MODULE,
+        },
+    }
+    output_text = _run_main_with_io(json.dumps(hook_input))
+    payload = json.loads(output_text)
+    assert payload["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_main_blocks_overstated_hook_module_edit() -> None:
+    hook_input = {
+        "tool_name": "Edit",
+        "tool_input": {
+            "file_path": "/repo/hooks/hooks_constants/some_blocker_constants.py",
+            "new_string": _OVERSTATED_MESSAGE_MODULE,
+        },
+    }
+    output_text = _run_main_with_io(json.dumps(hook_input))
+    payload = json.loads(output_text)
+    assert payload["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_main_passes_fixed_hook_module_write() -> None:
+    hook_input = {
+        "tool_name": "Write",
+        "tool_input": {
+            "file_path": "/repo/hooks/hooks_constants/some_blocker_constants.py",
+            "content": _FIXED_MESSAGE_MODULE,
+        },
+    }
+    assert _run_main_with_io(json.dumps(hook_input)) == ""
+
+
+def test_main_passes_non_hook_path() -> None:
+    hook_input = {
+        "tool_name": "Write",
+        "tool_input": {
+            "file_path": "/repo/src/some_blocker.py",
+            "content": _OVERSTATED_MESSAGE_MODULE,
+        },
+    }
+    assert _run_main_with_io(json.dumps(hook_input)) == ""
+
+
+def test_main_passes_wrong_tool_name() -> None:
+    hook_input = {
+        "tool_name": "Bash",
+        "tool_input": {
+            "file_path": "/repo/hooks/blocking/x.py",
+            "command": "echo output-key segment",
+        },
+    }
+    assert _run_main_with_io(json.dumps(hook_input)) == ""
+
+
+def test_main_passes_malformed_json() -> None:
+    assert _run_main_with_io("not valid json {{{") == ""

package/hooks/blocking/test_intent_only_ending_blocker.py

@@ -0,0 +1,175 @@
+"""Tests for intent_only_ending_blocker hook response shape."""
+
+import importlib.util
+import json
+import os
+import subprocess
+import sys
+
+HOOK_SCRIPT_PATH = os.path.join(os.path.dirname(__file__), "intent_only_ending_blocker.py")
+_HOOKS_DIR = os.path.dirname(HOOK_SCRIPT_PATH)
+_HOOKS_ROOT = os.path.join(_HOOKS_DIR, "..")
+_HOOK_CONFIG_DIR = os.path.join(_HOOKS_ROOT, "hooks_constants")
+if _HOOKS_DIR not in sys.path:
+    sys.path.insert(0, _HOOKS_DIR)
+if _HOOKS_ROOT not in sys.path:
+    sys.path.insert(0, _HOOKS_ROOT)
+import intent_only_ending_blocker
+from hooks_constants.messages import USER_FACING_INTENT_ENDING_NOTICE
+
+INTENT_ENDING_MESSAGE = "I'll now run the test suite and fix any failures that come up."
+NEXT_STEPS_MESSAGE = "Next steps:"
+COMPLETED_WORK_MESSAGE = "Done - all tests pass. The fix is in place."
+BENIGN_PAST_TENSE_MESSAGE = "I implemented the parser and verified it against the fixtures."
+CLEAN_MESSAGE = "The function returns the parsed payload to its caller."
+COMMITMENT_PHRASING_MESSAGE = "I'll commit to keeping the API stable across the next release."
+NAMING_COMMITMENT_MESSAGE = "Let me commit to a clear naming convention for these helpers."
+GIT_COMMIT_INTENT_MESSAGE = "I'll commit the changes once the tests pass."
+DEFERRED_TO_USER_CI_RUNS_MESSAGE = (
+    "Let me know if this looks right. The CI will run automatically on push."
+)
+DEFERRED_TO_USER_EITHER_WAY_MESSAGE = (
+    "Let me know which option you want. I can check either way."
+)
+USER_DIRECTED_NEXT_STEPS_MESSAGE = (
+    "All done. The PR is merged.\n\nNext steps: you should deploy when ready."
+)
+EMPTY_MESSAGE = ""
+
+
+def run_hook_with_message(assistant_message: str) -> subprocess.CompletedProcess:
+    hook_input_payload = json.dumps({"last_assistant_message": assistant_message})
+    return subprocess.run(
+        [sys.executable, HOOK_SCRIPT_PATH],
+        input=hook_input_payload,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def run_hook_with_payload(hook_input_payload: dict) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [sys.executable, HOOK_SCRIPT_PATH],
+        input=json.dumps(hook_input_payload),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def test_user_facing_notice_matches_config_messages_module():
+    config_messages_path = os.path.join(_HOOK_CONFIG_DIR, "messages.py")
+    specification = importlib.util.spec_from_file_location("messages", config_messages_path)
+    module = importlib.util.module_from_spec(specification)
+    specification.loader.exec_module(module)
+
+    assert module.USER_FACING_INTENT_ENDING_NOTICE == USER_FACING_INTENT_ENDING_NOTICE
+    assert (
+        intent_only_ending_blocker.USER_FACING_INTENT_ENDING_NOTICE
+        == module.USER_FACING_INTENT_ENDING_NOTICE
+    )
+
+
+def test_intent_ending_message_emits_block_with_short_user_notice():
+    completed_process = run_hook_with_message(INTENT_ENDING_MESSAGE)
+
+    assert completed_process.returncode == 0
+    parsed_response = json.loads(completed_process.stdout)
+
+    assert parsed_response["decision"] == "block"
+    assert parsed_response["systemMessage"] == USER_FACING_INTENT_ENDING_NOTICE
+    assert parsed_response["suppressOutput"] is True
+    assert "long-horizon-autonomy" in parsed_response["reason"]
+
+
+def test_next_steps_lead_in_emits_block():
+    completed_process = run_hook_with_message(NEXT_STEPS_MESSAGE)
+
+    assert completed_process.returncode == 0
+    parsed_response = json.loads(completed_process.stdout)
+
+    assert parsed_response["decision"] == "block"
+    assert parsed_response["systemMessage"] == USER_FACING_INTENT_ENDING_NOTICE
+
+
+def test_completed_work_summary_passes_through_with_no_output():
+    completed_process = run_hook_with_message(COMPLETED_WORK_MESSAGE)
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_past_tense_summary_passes_through_with_no_output():
+    completed_process = run_hook_with_message(BENIGN_PAST_TENSE_MESSAGE)
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_commitment_phrasing_passes_through_with_no_output():
+    completed_process = run_hook_with_message(COMMITMENT_PHRASING_MESSAGE)
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_naming_commitment_passes_through_with_no_output():
+    completed_process = run_hook_with_message(NAMING_COMMITMENT_MESSAGE)
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_git_commit_intent_emits_block():
+    completed_process = run_hook_with_message(GIT_COMMIT_INTENT_MESSAGE)
+
+    assert completed_process.returncode == 0
+    parsed_response = json.loads(completed_process.stdout)
+
+    assert parsed_response["decision"] == "block"
+    assert parsed_response["systemMessage"] == USER_FACING_INTENT_ENDING_NOTICE
+
+
+def test_benign_opener_with_unrelated_work_verb_passes_through_with_no_output():
+    completed_process = run_hook_with_message(DEFERRED_TO_USER_CI_RUNS_MESSAGE)
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_deferral_to_user_with_later_verb_passes_through_with_no_output():
+    completed_process = run_hook_with_message(DEFERRED_TO_USER_EITHER_WAY_MESSAGE)
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_user_directed_next_steps_passes_through_with_no_output():
+    completed_process = run_hook_with_message(USER_DIRECTED_NEXT_STEPS_MESSAGE)
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_clean_message_passes_through_with_no_output():
+    completed_process = run_hook_with_message(CLEAN_MESSAGE)
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_empty_message_passes_through_with_no_output():
+    completed_process = run_hook_with_message(EMPTY_MESSAGE)
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_stop_hook_active_short_circuits_with_no_output():
+    completed_process = run_hook_with_payload(
+        {"last_assistant_message": INTENT_ENDING_MESSAGE, "stop_hook_active": True}
+    )
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""