claude-dev-env 4.3.0 → 7.1.0

package/hooks/blocking/test_precommit_code_rules_gate_native_owner.py

@@ -1,233 +0,0 @@
-"""Production-path tests for native staged-gate ownership.
-
-The tests run the Agent Bash dispatcher and a native Git pre-commit hook against
-the same isolated repository. The agent path passes the commit through. The
-native path runs the staged gate and controls the commit.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Iterator
-from contextlib import contextmanager
-import json
-import shutil
-import stat
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-HOOKS_ROOT = Path(__file__).resolve().parent.parent
-BLOCKING_ROOT = HOOKS_ROOT / "blocking"
-GIT_HOOKS_ROOT = HOOKS_ROOT / "git-hooks"
-PRE_COMMIT_SOURCE_PATH = GIT_HOOKS_ROOT / "pre_commit.py"
-GATE_UTILS_SOURCE_PATH = GIT_HOOKS_ROOT / "gate_utils.py"
-GIT_HOOKS_CONSTANTS_SOURCE_PATH = GIT_HOOKS_ROOT / "git_hooks_constants"
-DISPATCHER_SOURCE_PATH = BLOCKING_ROOT / "bash_pre_tool_use_dispatcher.py"
-GIT_COMMAND_TIMEOUT_SECONDS = 60
-CLEAN_MODULE_SOURCE = "def add_one(number: int) -> int:\n    return number + 1\n"
-
-
-def run_git(
-    repository_root: Path,
-    *git_arguments: str,
-    check: bool = True,
-) -> subprocess.CompletedProcess[str]:
-    """Run one isolated Git command and return its captured process record."""
-    return subprocess.run(
-        ["git", *git_arguments],
-        cwd=str(repository_root),
-        check=check,
-        capture_output=True,
-        text=True,
-        timeout=GIT_COMMAND_TIMEOUT_SECONDS,
-    )
-
-
-def initialize_repository(repository_root: Path) -> None:
-    """Create a repository with one committed base file and no active hook."""
-    run_git(repository_root, "init")
-    run_git(repository_root, "config", "user.name", "Hook Test")
-    run_git(repository_root, "config", "user.email", "hook-test@example.invalid")
-    run_git(repository_root, "config", "core.hooksPath", "absent_fixture_hooks")
-    (repository_root / "README.md").write_text("base\n", encoding="utf-8")
-    run_git(repository_root, "add", "README.md")
-    run_git(repository_root, "commit", "-m", "base")
-
-
-def write_gate_script(gate_path: Path, marker_path: Path, exit_code: int) -> None:
-    """Write a staged-gate fixture that records arguments and exits."""
-    gate_path.write_text(
-        "import pathlib\n"
-        "import sys\n"
-        f"pathlib.Path({str(marker_path)!r}).write_text("
-        "'\\n'.join(sys.argv[1:]), encoding='utf-8')\n"
-        f"sys.exit({exit_code})\n",
-        encoding="utf-8",
-    )
-
-
-def install_native_pre_commit(hooks_path: Path) -> None:
-    """Install the native pre-commit module and its self-contained imports."""
-    hooks_path.mkdir()
-    shutil.copyfile(PRE_COMMIT_SOURCE_PATH, hooks_path / "pre_commit.py")
-    shutil.copyfile(GATE_UTILS_SOURCE_PATH, hooks_path / "gate_utils.py")
-    shutil.copytree(
-        GIT_HOOKS_CONSTANTS_SOURCE_PATH,
-        hooks_path / "git_hooks_constants",
-    )
-    pre_commit_path = hooks_path / "pre-commit"
-    pre_commit_path.write_text(
-        "#!/usr/bin/env python3\n"
-        "import sys\n"
-        "from pathlib import Path\n"
-        "shim_directory = Path(__file__).resolve().parent\n"
-        "sys.path.insert(0, str(shim_directory))\n"
-        "import pre_commit\n"
-        "sys.exit(pre_commit.main())\n",
-        encoding="utf-8",
-    )
-    pre_commit_path.chmod(pre_commit_path.stat().st_mode | stat.S_IXUSR)
-
-
-def configured_hooks_path(repository_root: Path) -> str | None:
-    """Return the repository-local hooks path when one is configured."""
-    completed_config = run_git(
-        repository_root,
-        "config",
-        "--local",
-        "--get",
-        "core.hooksPath",
-        check=False,
-    )
-    if completed_config.returncode != 0:
-        return None
-    return completed_config.stdout.strip()
-
-
-def restore_hooks_path(repository_root: Path, prior_hooks_path: str | None) -> None:
-    """Restore the repository-local hooks path captured before a benchmark."""
-    if prior_hooks_path is None:
-        run_git(
-            repository_root,
-            "config",
-            "--local",
-            "--unset-all",
-            "core.hooksPath",
-            check=False,
-        )
-        return
-    run_git(repository_root, "config", "--local", "core.hooksPath", prior_hooks_path)
-
-
-@contextmanager
-def temporary_hooks_path(repository_root: Path, benchmark_hooks_path: Path) -> Iterator[None]:
-    """Apply a benchmark hooks path and restore the prior local setting."""
-    prior_hooks_path = configured_hooks_path(repository_root)
-    run_git(repository_root, "config", "--local", "core.hooksPath", str(benchmark_hooks_path))
-    try:
-        yield
-    finally:
-        restore_hooks_path(repository_root, prior_hooks_path)
-
-
-def stage_module(repository_root: Path) -> None:
-    """Write and stage one Python module for the commit fixture."""
-    (repository_root / "widget.py").write_text(CLEAN_MODULE_SOURCE, encoding="utf-8")
-    run_git(repository_root, "add", "widget.py")
-
-
-def build_bash_payload(repository_root: Path) -> str:
-    """Build the Bash dispatcher payload for a commit in the fixture repository."""
-    commit_command = f'git -C "{repository_root}" commit -m add'
-    return json.dumps({"tool_name": "Bash", "tool_input": {"command": commit_command}})
-
-
-def run_agent_dispatcher(repository_root: Path) -> subprocess.CompletedProcess[str]:
-    """Run the production Bash dispatcher against the fixture commit command."""
-    return subprocess.run(
-        [sys.executable, str(DISPATCHER_SOURCE_PATH)],
-        cwd=str(repository_root),
-        input=build_bash_payload(repository_root),
-        capture_output=True,
-        text=True,
-        timeout=GIT_COMMAND_TIMEOUT_SECONDS,
-    )
-
-
-def run_native_commit(repository_root: Path) -> subprocess.CompletedProcess[str]:
-    """Run the real Git commit that invokes the configured native hook."""
-    return run_git(
-        repository_root,
-        "commit",
-        "-m",
-        "add widget",
-        check=False,
-    )
-
-
-def test_agent_dispatcher_passes_commit_through_without_running_gate(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """The Agent Bash path continues the commit without running the staged gate."""
-    initialize_repository(tmp_path)
-    stage_module(tmp_path)
-    gate_marker_path = tmp_path / "agent_gate_invocation.txt"
-    gate_path = tmp_path / "agent_gate.py"
-    write_gate_script(gate_path, gate_marker_path, exit_code=1)
-    monkeypatch.setenv("CODE_RULES_GATE_PATH", str(gate_path))
-
-    completed_dispatcher = run_agent_dispatcher(tmp_path)
-
-    assert completed_dispatcher.returncode == 0, completed_dispatcher.stderr
-    assert completed_dispatcher.stdout.strip() == ""
-    assert not gate_marker_path.exists()
-
-
-@pytest.mark.parametrize("gate_exit_code, expected_commit_exit_code", [(1, 1), (0, 0)])
-def test_installed_native_pre_commit_controls_staged_gate_decision(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-    gate_exit_code: int,
-    expected_commit_exit_code: int,
-) -> None:
-    """The native Git hook runs the staged gate and returns its commit decision."""
-    initialize_repository(tmp_path)
-    native_hooks_path = tmp_path / "native_hooks"
-    install_native_pre_commit(native_hooks_path)
-    stage_module(tmp_path)
-    gate_marker_path = tmp_path / "native_gate_invocation.txt"
-    gate_path = tmp_path / "native_gate.py"
-    write_gate_script(gate_path, gate_marker_path, gate_exit_code)
-    monkeypatch.setenv("CODE_RULES_GATE_PATH", str(gate_path))
-
-    with temporary_hooks_path(tmp_path, native_hooks_path):
-        completed_commit = run_native_commit(tmp_path)
-
-    assert completed_commit.returncode == expected_commit_exit_code
-    assert gate_marker_path.read_text(encoding="utf-8") == "--immediate"
-
-
-def test_temporary_hooks_path_restores_shared_worktree_config_on_timeout(
-    tmp_path: Path,
-) -> None:
-    initialize_repository(tmp_path)
-    supported_hooks_path = tmp_path / "supported_hooks"
-    supported_hooks_path.mkdir()
-    run_git(tmp_path, "config", "--local", "core.hooksPath", str(supported_hooks_path))
-    unrelated_worktree = tmp_path.parent / "unrelated_worktree"
-    run_git(tmp_path, "worktree", "add", "--detach", str(unrelated_worktree))
-    benchmark_hooks_path = tmp_path / "benchmark_hooks"
-    benchmark_hooks_path.mkdir()
-
-    try:
-        with pytest.raises(subprocess.TimeoutExpired):
-            with temporary_hooks_path(tmp_path, benchmark_hooks_path):
-                raise subprocess.TimeoutExpired("benchmark", 1)
-
-        assert configured_hooks_path(tmp_path) == str(supported_hooks_path)
-        assert configured_hooks_path(unrelated_worktree) == str(supported_hooks_path)
-    finally:
-        run_git(tmp_path, "worktree", "remove", "--force", str(unrelated_worktree))

package/hooks/blocking/test_question_to_user_enforcer.py

@@ -1,169 +0,0 @@
-"""Tests for question_to_user_enforcer hook response shape and detection logic."""
-
-import json
-import os
-import subprocess
-import sys
-
-HOOK_SCRIPT_PATH = os.path.join(
-    os.path.dirname(__file__), "question_to_user_enforcer.py"
-)
-_HOOKS_DIR = os.path.dirname(HOOK_SCRIPT_PATH)
-_HOOKS_ROOT = os.path.join(_HOOKS_DIR, "..")
-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 question_to_user_enforcer
-from hooks_constants.messages import USER_FACING_ASKUSERQUESTION_NOTICE
-from hooks_constants.text_stripping import strip_code_and_quotes
-
-CLEAN_DECLARATIVE_MESSAGE = "I applied the rename across both files. The tests pass."
-TRAILING_QUESTION_MESSAGE = (
-    "I applied the rename across both files. Should this also propagate to the docs?"
-)
-WANT_ME_TO_MESSAGE = "I finished the refactor.\n\nWant me to open the PR now?"
-SHOULD_I_STATEMENT_MESSAGE = (
-    "The diff is ready.\n\nShould I proceed with committing it."
-)
-FENCED_CODE_QUESTION_MESSAGE = (
-    "Here is the diagnostic snippet:\n\n"
-    "```python\n"
-    "print('does this work?')\n"
-    "```\n\n"
-    "The snippet confirms the behavior."
-)
-RHETORICAL_MIDDLE_MESSAGE = (
-    "Consider the failure mode.\n\n"
-    "What happens if the queue is empty? The handler short-circuits cleanly.\n\n"
-    "That covers the edge case."
-)
-QUESTION_WITH_TRAILING_DOUBLE_QUOTE_MESSAGE = (
-    'I renamed the flag.\n\nDid you mean "enable_fast_path?"'
-)
-QUESTION_WITH_TRAILING_SINGLE_QUOTE_MESSAGE = (
-    "I renamed the flag.\n\nDid you mean 'enable_fast_path?'"
-)
-QUESTION_WITH_TRAILING_PAREN_MESSAGE = (
-    "I finished the refactor.\n\nShould I also bump the version (minor or patch?)"
-)
-QUESTION_WITH_TRAILING_BRACKET_MESSAGE = (
-    "I finished the refactor.\n\nShould I also bump the version [minor or patch?]"
-)
-QUESTION_WITH_TRAILING_SPACE_MESSAGE = (
-    "I finished the refactor.\n\nShould I also bump the version? "
-)
-
-
-def run_hook_with_payload(payload: dict) -> subprocess.CompletedProcess:
-    hook_input_payload = json.dumps(payload)
-    return subprocess.run(
-        [sys.executable, HOOK_SCRIPT_PATH],
-        input=hook_input_payload,
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-
-
-def run_hook_with_message(assistant_message: str) -> subprocess.CompletedProcess:
-    return run_hook_with_payload({"last_assistant_message": assistant_message})
-
-
-def test_blocker_uses_shared_strip_code_and_quotes() -> None:
-    assert question_to_user_enforcer.strip_code_and_quotes is strip_code_and_quotes
-
-
-def test_clean_declarative_message_passes_through():
-    completed_process = run_hook_with_message(CLEAN_DECLARATIVE_MESSAGE)
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_final_paragraph_ending_with_question_mark_emits_block():
-    completed_process = run_hook_with_message(TRAILING_QUESTION_MESSAGE)
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"
-
-
-def test_want_me_to_preamble_in_final_paragraph_emits_block():
-    completed_process = run_hook_with_message(WANT_ME_TO_MESSAGE)
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"
-
-
-def test_should_i_preamble_without_question_mark_emits_block():
-    completed_process = run_hook_with_message(SHOULD_I_STATEMENT_MESSAGE)
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"
-
-
-def test_question_mark_inside_fenced_code_block_passes_through():
-    completed_process = run_hook_with_message(FENCED_CODE_QUESTION_MESSAGE)
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_stop_hook_active_flag_passes_through():
-    completed_process = run_hook_with_payload(
-        {
-            "last_assistant_message": TRAILING_QUESTION_MESSAGE,
-            "stop_hook_active": True,
-        }
-    )
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_rhetorical_middle_paragraph_with_declarative_final_passes_through():
-    completed_process = run_hook_with_message(RHETORICAL_MIDDLE_MESSAGE)
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_block_response_json_shape():
-    completed_process = run_hook_with_message(TRAILING_QUESTION_MESSAGE)
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"
-    assert "AskUserQuestion" in parsed_response["reason"]
-    assert parsed_response["systemMessage"] == USER_FACING_ASKUSERQUESTION_NOTICE
-    assert parsed_response["suppressOutput"] is True
-
-
-def test_question_followed_by_double_quote_emits_block():
-    completed_process = run_hook_with_message(QUESTION_WITH_TRAILING_DOUBLE_QUOTE_MESSAGE)
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"
-
-
-def test_question_followed_by_single_quote_emits_block():
-    completed_process = run_hook_with_message(QUESTION_WITH_TRAILING_SINGLE_QUOTE_MESSAGE)
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"
-
-
-def test_question_followed_by_closing_paren_emits_block():
-    completed_process = run_hook_with_message(QUESTION_WITH_TRAILING_PAREN_MESSAGE)
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"
-
-
-def test_question_followed_by_closing_bracket_emits_block():
-    completed_process = run_hook_with_message(QUESTION_WITH_TRAILING_BRACKET_MESSAGE)
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"
-
-
-def test_question_followed_by_trailing_space_emits_block():
-    completed_process = run_hook_with_message(QUESTION_WITH_TRAILING_SPACE_MESSAGE)
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"

package/hooks/blocking/test_send_user_file_open_locally_blocker.py

@@ -1,118 +0,0 @@
-"""Unit tests for the send-user-file-open-locally PreToolUse hook."""
-
-import importlib.util
-import io
-import json
-import pathlib
-import sys
-from unittest import mock
-
-_HOOK_DIR = pathlib.Path(__file__).parent
-if str(_HOOK_DIR) not in sys.path:
-    sys.path.insert(0, str(_HOOK_DIR))
-
-hook_spec = importlib.util.spec_from_file_location(
-    "send_user_file_open_locally_blocker",
-    _HOOK_DIR / "send_user_file_open_locally_blocker.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)
-
-_should_block = hook_module._should_block
-
-from hooks_constants.send_user_file_open_locally_blocker_constants import (
-    CORRECTIVE_MESSAGE,
-    PROACTIVE_STATUS,
-    TOOL_NAME,
-)
-
-
-def test_blocks_normal_status() -> None:
-    assert _should_block("normal") is True
-
-
-def test_blocks_empty_status() -> None:
-    assert _should_block("") is True
-
-
-def test_blocks_unknown_status() -> None:
-    assert _should_block("whatever") is True
-
-
-def test_allows_proactive_status() -> None:
-    assert _should_block(PROACTIVE_STATUS) is False
-
-
-def test_corrective_message_points_to_native_windows_app() -> None:
-    assert "native Windows app" in CORRECTIVE_MESSAGE
-    assert "Invoke-Item -LiteralPath" in CORRECTIVE_MESSAGE
-    assert "Show-Asset.ps1" not in CORRECTIVE_MESSAGE
-    assert "Cursor.exe" in CORRECTIVE_MESSAGE
-    assert "EPIPE" in CORRECTIVE_MESSAGE
-
-
-def test_corrective_message_names_proactive_escape_hatch() -> None:
-    assert PROACTIVE_STATUS in CORRECTIVE_MESSAGE
-
-
-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_normal_attach() -> None:
-    hook_input = {
-        "tool_name": TOOL_NAME,
-        "tool_input": {"files": ["report.html"], "status": "normal"},
-    }
-    output_text = _run_main_with_io(json.dumps(hook_input))
-    output = json.loads(output_text)
-    assert output["hookSpecificOutput"]["permissionDecision"] == "deny"
-    assert "native Windows app" in output["hookSpecificOutput"]["permissionDecisionReason"]
-
-
-def test_main_allows_proactive_attach() -> None:
-    hook_input = {
-        "tool_name": TOOL_NAME,
-        "tool_input": {"files": ["report.html"], "status": "proactive"},
-    }
-    assert _run_main_with_io(json.dumps(hook_input)) == ""
-
-
-def test_main_blocks_when_status_missing() -> None:
-    hook_input = {
-        "tool_name": TOOL_NAME,
-        "tool_input": {"files": ["report.html"]},
-    }
-    output_text = _run_main_with_io(json.dumps(hook_input))
-    output = json.loads(output_text)
-    assert output["hookSpecificOutput"]["permissionDecision"] == "deny"
-
-
-def test_main_blocks_when_tool_input_is_null() -> None:
-    hook_input = {
-        "tool_name": TOOL_NAME,
-        "tool_input": None,
-    }
-    output_text = _run_main_with_io(json.dumps(hook_input))
-    output = json.loads(output_text)
-    assert output["hookSpecificOutput"]["permissionDecision"] == "deny"
-
-
-def test_main_passes_wrong_tool_name() -> None:
-    hook_input = {
-        "tool_name": "Write",
-        "tool_input": {"files": ["report.html"], "status": "normal"},
-    }
-    assert _run_main_with_io(json.dumps(hook_input)) == ""
-
-
-def test_main_passes_malformed_json() -> None:
-    assert _run_main_with_io("not valid json {{{") == ""