claude-dev-env 8.97.0 → 8.98.0

package/hooks/blocking/test_python_windows_invocation_gate.py

@@ -0,0 +1,181 @@
+"""Tests for python_windows_invocation_gate, which stops two Windows Python failures."""
+
+from __future__ import annotations
+
+import json
+from io import StringIO
+from unittest.mock import patch
+
+import pytest
+
+import python_windows_invocation_gate as gate
+
+
+def _stdout_from_main(payload: dict[str, object]) -> str:
+    """Return what main() wrote to stdout for one hook payload."""
+    captured_stdout = StringIO()
+    with (
+        patch("sys.stdin", StringIO(json.dumps(payload))),
+        patch("sys.stdout", captured_stdout),
+        patch.object(gate, "log_hook_block"),
+    ):
+        gate.main()
+    return captured_stdout.getvalue()
+
+
+@pytest.fixture
+def windows_host(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Make the gate read the host as Windows."""
+    monkeypatch.setattr(gate, "is_windows_host", lambda: True)
+
+
+@pytest.fixture
+def linux_host(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Make the gate read the host as Linux."""
+    monkeypatch.setattr(gate, "is_windows_host", lambda: False)
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "python -I script.py",
+        "python3 -I -c pass",
+        "py -3 -I script.py",
+        "python3.12.exe -I -m json.tool data.json",
+        "python -Iu script.py",
+        "python -Ic pass",
+        "python -I -X dev script.py",
+        "python -I -X utf8=0 script.py",
+        "cd repo && python -I script.py",
+        "git status; python -I script.py | tee out.txt",
+        "bash -c 'python -I script.py'",
+        "python --check-hash-based-pycs always -I script.py",
+    ],
+)
+def test_should_flag_isolated_python_without_utf8_mode(command: str) -> None:
+    assert gate.runs_isolated_python_without_utf8_mode(command) is True
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "python -I -X utf8 script.py",
+        "python -IX utf8 script.py",
+        "python -IXutf8 script.py",
+        "python -X utf8 -I script.py",
+        "python -I -X utf8=1 -c pass",
+        "py -3 -I -X utf8 script.py",
+        "python -I --check-hash-based-pycs always -X utf8 script.py",
+        "python script.py -I",
+        "python -c pass -I",
+        "python -m pytest -I",
+        "python script.py",
+        "pip install -I package",
+        'echo "python -I script.py"',
+    ],
+)
+def test_should_pass_python_with_utf8_mode_or_without_isolated_mode(
+    command: str,
+) -> None:
+    assert gate.runs_isolated_python_without_utf8_mode(command) is False
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        'python -X utf8 -c "import json; print(\\"select 1\\")"',
+        'python -c "print(\\"x\\")"',
+        'py -3 -c "print(\\"x\\")"',
+        'python3.exe -I -X utf8 -c "print(\\"x\\")"',
+        '& python -c "print(\\"x\\")"',
+        'Set-Location repo; python -c "print(\\"x\\")"',
+    ],
+)
+def test_should_flag_a_backslash_quote_inside_a_python_code_argument(
+    command: str,
+) -> None:
+    assert gate.has_backslash_quote_in_python_code_argument(command) is True
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "python -c \"print('x')\"",
+        "python -c 'print(\"x\")'",
+        'python script.py "a\\"b"',
+        'python -c "print(1)"; Write-Output "a\\"b"',
+        'Write-Output "python -c"',
+        'copy -c "a\\"b"',
+    ],
+)
+def test_should_pass_a_python_code_argument_without_a_backslash_quote(
+    command: str,
+) -> None:
+    assert gate.has_backslash_quote_in_python_code_argument(command) is False
+
+
+def test_should_deny_isolated_python_on_windows_and_name_the_utf8_flag(
+    windows_host: None,
+) -> None:
+    decision = json.loads(
+        _stdout_from_main(
+            {"tool_name": "Bash", "tool_input": {"command": "python -I s.py"}}
+        )
+    )
+    specific_output = decision["hookSpecificOutput"]
+    assert specific_output["permissionDecision"] == "deny"
+    assert "python -I -X utf8" in specific_output["permissionDecisionReason"]
+
+
+def test_should_stay_quiet_for_isolated_python_on_linux(linux_host: None) -> None:
+    assert (
+        _stdout_from_main(
+            {"tool_name": "Bash", "tool_input": {"command": "python -I s.py"}}
+        )
+        == ""
+    )
+
+
+def test_should_deny_a_powershell_backslash_quote_and_name_the_here_string(
+    linux_host: None,
+) -> None:
+    command = 'python -X utf8 -c "print(\\"select 1\\")"'
+    decision = json.loads(
+        _stdout_from_main(
+            {"tool_name": "PowerShell", "tool_input": {"command": command}}
+        )
+    )
+    specific_output = decision["hookSpecificOutput"]
+    assert specific_output["permissionDecision"] == "deny"
+    assert "here-string" in specific_output["permissionDecisionReason"]
+
+
+def test_should_pass_a_backslash_quote_under_bash(windows_host: None) -> None:
+    command = 'python -X utf8 -c "print(\\"select 1\\")"'
+    assert (
+        _stdout_from_main({"tool_name": "Bash", "tool_input": {"command": command}})
+        == ""
+    )
+
+
+def test_should_name_both_fixes_when_a_powershell_command_has_both_failures(
+    windows_host: None,
+) -> None:
+    command = 'python -I -c "print(\\"x\\")"'
+    decision = json.loads(
+        _stdout_from_main(
+            {"tool_name": "PowerShell", "tool_input": {"command": command}}
+        )
+    )
+    reason = decision["hookSpecificOutput"]["permissionDecisionReason"]
+    assert "python -I -X utf8" in reason
+    assert "here-string" in reason
+
+
+def test_should_stay_quiet_for_another_tool(windows_host: None) -> None:
+    assert (
+        _stdout_from_main(
+            {"tool_name": "Write", "tool_input": {"command": "python -I s.py"}}
+        )
+        == ""
+    )

package/hooks/blocking/test_verify_before_commit_gate.py

@@ -0,0 +1,334 @@
+"""Behavior tests for the verify-before-commit PreToolUse gate."""
+
+import json
+import subprocess
+import sys
+from io import BytesIO, StringIO, TextIOWrapper
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+HOOKS_DIRECTORY = Path(__file__).resolve().parent.parent
+if str(HOOKS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(HOOKS_DIRECTORY))
+
+from blocking import verify_before_commit_gate as gate
+from hooks_constants.verify_before_commit_gate_constants import DENY_REASON
+
+PROMPT_ENTRY = {"type": "user", "message": {"content": "Fix the parser and commit it."}}
+SLASH_PROMPT_ENTRY = {
+    "type": "user",
+    "message": {
+        "content": "<command-message>verify</command-message>\n<command-name>/verify</command-name>"
+    },
+}
+SKILL_BODY_ENTRY = {
+    "type": "user",
+    "isMeta": True,
+    "message": {
+        "content": [{"type": "text", "text": "Base directory for this skill: verify"}]
+    },
+}
+TOOL_RESULT_ENTRY = {
+    "type": "user",
+    "message": {
+        "content": [
+            {
+                "type": "tool_result",
+                "tool_use_id": "toolu_1",
+                "content": "Launching skill: verify",
+            }
+        ]
+    },
+}
+
+
+def _skill_entry(skill_name: str) -> dict[str, object]:
+    return {
+        "type": "assistant",
+        "message": {
+            "content": [
+                {"type": "tool_use", "name": "Skill", "input": {"skill": skill_name}}
+            ]
+        },
+    }
+
+
+def _git(repository: Path, *all_arguments: str) -> None:
+    subprocess.run(
+        ["git", "-C", str(repository), *all_arguments], check=True, capture_output=True
+    )
+
+
+@pytest.fixture
+def repository(tmp_path: Path) -> Path:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _git(repository_root, "init", "-q")
+    _git(repository_root, "config", "user.email", "gate@example.com")
+    _git(repository_root, "config", "user.name", "Gate Test")
+    (repository_root / ".agents" / "skills" / "verify").mkdir(parents=True)
+    (repository_root / ".agents" / "skills" / "verify" / "SKILL.md").write_text(
+        "verify\n", encoding="utf-8"
+    )
+    (repository_root / "app.py").write_text("VALUE = 1\n", encoding="utf-8")
+    (repository_root / "README.md").write_text("Readme\n", encoding="utf-8")
+    _git(repository_root, "add", "-A")
+    _git(repository_root, "commit", "-q", "-m", "base")
+    return repository_root
+
+
+def _transcript(tmp_path: Path, *all_entries: dict[str, object]) -> Path:
+    transcript_path = tmp_path / "session.jsonl"
+    transcript_path.write_text(
+        "".join(json.dumps(each_entry) + "\n" for each_entry in all_entries),
+        encoding="utf-8",
+    )
+    return transcript_path
+
+
+def _payload(
+    command: str, cwd: Path, transcript_path: Path, tool_name: str = "Bash"
+) -> dict[str, object]:
+    return {
+        "tool_name": tool_name,
+        "tool_input": {"command": command},
+        "cwd": str(cwd),
+        "transcript_path": str(transcript_path),
+    }
+
+
+def _unverified(tmp_path: Path) -> Path:
+    return _transcript(tmp_path, PROMPT_ENTRY)
+
+
+def _is_denied(payload: dict[str, object]) -> bool:
+    decision = gate.decision_for(payload)
+    if decision is None:
+        return False
+    assert decision["hookSpecificOutput"]["permissionDecision"] == "deny"
+    assert decision["hookSpecificOutput"]["permissionDecisionReason"] == DENY_REASON
+    return True
+
+
+def _run_main(payload: dict[str, object]) -> tuple[int, str]:
+    output = StringIO()
+    input_stream = TextIOWrapper(
+        BytesIO(json.dumps(payload).encode("utf-8")), encoding="utf-8"
+    )
+    with patch("sys.stdin", input_stream), patch("sys.stdout", output):
+        exit_code = gate.main()
+    return exit_code, output.getvalue()
+
+
+def test_staged_code_commit_without_verify_is_denied(
+    repository: Path, tmp_path: Path
+) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    _git(repository, "add", "app.py")
+    exit_code, output = _run_main(
+        _payload("git commit -m change", repository, _unverified(tmp_path))
+    )
+    assert exit_code == 0
+    decision = json.loads(output)["hookSpecificOutput"]
+    assert decision["permissionDecision"] == "deny"
+    assert "verify" in decision["permissionDecisionReason"]
+
+
+def test_same_command_git_add_of_code_is_denied_with_an_empty_index(
+    repository: Path, tmp_path: Path
+) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    assert _is_denied(
+        _payload(
+            "git add app.py && git commit -m change", repository, _unverified(tmp_path)
+        )
+    )
+
+
+def test_same_command_git_add_all_picks_up_a_new_code_file(
+    repository: Path, tmp_path: Path
+) -> None:
+    (repository / "new_module.py").write_text("NAME = 'new'\n", encoding="utf-8")
+    assert _is_denied(
+        _payload("git add -A; git commit -m add", repository, _unverified(tmp_path))
+    )
+
+
+def test_same_command_git_add_of_docs_passes_while_code_stays_unstaged(
+    repository: Path, tmp_path: Path
+) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    (repository / "README.md").write_text("Readme two\n", encoding="utf-8")
+    assert not _is_denied(
+        _payload(
+            "git add README.md; git commit -m docs", repository, _unverified(tmp_path)
+        )
+    )
+
+
+def test_commit_all_flag_counts_modified_code(repository: Path, tmp_path: Path) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    assert _is_denied(
+        _payload("git commit -am change", repository, _unverified(tmp_path))
+    )
+    assert _is_denied(
+        _payload("git commit --all -m change", repository, _unverified(tmp_path))
+    )
+
+
+def test_commit_all_flag_with_only_docs_modified_passes(
+    repository: Path, tmp_path: Path
+) -> None:
+    (repository / "README.md").write_text("Readme two\n", encoding="utf-8")
+    assert not _is_denied(
+        _payload("git commit -am docs", repository, _unverified(tmp_path))
+    )
+
+
+def test_docs_only_commit_passes(repository: Path, tmp_path: Path) -> None:
+    (repository / "README.md").write_text("Readme two\n", encoding="utf-8")
+    (repository / "docs").mkdir()
+    (repository / "docs" / "guide.md").write_text("Guide\n", encoding="utf-8")
+    _git(repository, "add", "-A")
+    assert not _is_denied(
+        _payload("git commit -m docs", repository, _unverified(tmp_path))
+    )
+
+
+def test_tests_only_commit_passes(repository: Path, tmp_path: Path) -> None:
+    (repository / "test_app.py").write_text(
+        "def test_value() -> None:\n    pass\n", encoding="utf-8"
+    )
+    (repository / "tests").mkdir()
+    (repository / "tests" / "helpers.py").write_text("HELPER = 1\n", encoding="utf-8")
+    (repository / "install.test.mjs").write_text("export {};\n", encoding="utf-8")
+    _git(repository, "add", "-A")
+    assert not _is_denied(
+        _payload("git commit -m tests", repository, _unverified(tmp_path))
+    )
+
+
+def test_docs_plus_code_commit_is_denied(repository: Path, tmp_path: Path) -> None:
+    (repository / "README.md").write_text("Readme two\n", encoding="utf-8")
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    _git(repository, "add", "-A")
+    assert _is_denied(
+        _payload("git commit -m mixed", repository, _unverified(tmp_path))
+    )
+
+
+def test_verify_skill_call_after_the_last_prompt_passes(
+    repository: Path, tmp_path: Path
+) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    _git(repository, "add", "app.py")
+    for each_name in ("verify", "plugin:verify"):
+        transcript_path = _transcript(
+            tmp_path,
+            PROMPT_ENTRY,
+            _skill_entry(each_name),
+            TOOL_RESULT_ENTRY,
+            SKILL_BODY_ENTRY,
+        )
+        assert not _is_denied(
+            _payload("git commit -m change", repository, transcript_path)
+        )
+
+
+def test_verify_slash_command_in_the_last_prompt_passes(
+    repository: Path, tmp_path: Path
+) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    _git(repository, "add", "app.py")
+    transcript_path = _transcript(
+        tmp_path, PROMPT_ENTRY, SLASH_PROMPT_ENTRY, SKILL_BODY_ENTRY
+    )
+    exit_code, output = _run_main(
+        _payload("git commit -m change", repository, transcript_path)
+    )
+    assert (exit_code, output) == (0, "")
+
+
+def test_verify_loaded_in_a_previous_turn_does_not_count(
+    repository: Path, tmp_path: Path
+) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    _git(repository, "add", "app.py")
+    transcript_path = _transcript(
+        tmp_path, PROMPT_ENTRY, _skill_entry("verify"), SKILL_BODY_ENTRY, PROMPT_ENTRY
+    )
+    assert _is_denied(_payload("git commit -m change", repository, transcript_path))
+
+
+def test_another_skill_does_not_count(repository: Path, tmp_path: Path) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    _git(repository, "add", "app.py")
+    transcript_path = _transcript(tmp_path, PROMPT_ENTRY, _skill_entry("verify-rdp"))
+    assert _is_denied(_payload("git commit -m change", repository, transcript_path))
+
+
+def test_repository_without_a_verify_skill_passes(
+    repository: Path, tmp_path: Path
+) -> None:
+    _git(repository, "rm", "-q", "-r", ".agents")
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    _git(repository, "add", "-A")
+    assert not _is_denied(
+        _payload("git commit -m change", repository, _unverified(tmp_path))
+    )
+
+
+def test_claude_skills_verify_directory_activates_the_gate(
+    repository: Path, tmp_path: Path
+) -> None:
+    _git(repository, "rm", "-q", "-r", ".agents")
+    (repository / ".claude" / "skills" / "verify").mkdir(parents=True)
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    assert _is_denied(
+        _payload(
+            "git add app.py; git commit -m change", repository, _unverified(tmp_path)
+        )
+    )
+
+
+def test_powershell_and_git_directory_option_reach_the_repository(
+    repository: Path, tmp_path: Path
+) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    command = (
+        f'git -C "{repository}" add app.py; git -C "{repository}" commit -m change'
+    )
+    assert _is_denied(
+        _payload(command, tmp_path, _unverified(tmp_path), tool_name="PowerShell")
+    )
+
+
+def test_commands_other_than_commit_pass(repository: Path, tmp_path: Path) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    _git(repository, "add", "app.py")
+    for each_command in ("git status", "git push origin HEAD", "echo git commit"):
+        assert not _is_denied(_payload(each_command, repository, _unverified(tmp_path)))
+    assert (
+        gate.decision_for(
+            {"tool_name": "Write", "tool_input": {"command": "git commit"}}
+        )
+        is None
+    )
+
+
+def test_unreadable_transcript_passes(repository: Path, tmp_path: Path) -> None:
+    (repository / "app.py").write_text("VALUE = 2\n", encoding="utf-8")
+    _git(repository, "add", "app.py")
+    assert not _is_denied(
+        _payload("git commit -m change", repository, tmp_path / "missing.jsonl")
+    )
+
+
+def test_directory_outside_a_repository_passes(tmp_path: Path) -> None:
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    assert not _is_denied(
+        _payload("git commit -m change", outside, _unverified(tmp_path))
+    )