claude-dev-env 8.73.1 → 8.74.0

package/hooks/hooks_constants/test_windows_filesystem.py

@@ -0,0 +1,57 @@
+"""Tests for the shared Windows-safe force_rmtree helper."""
+
+from __future__ import annotations
+
+import os
+import stat
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from hooks_constants import windows_filesystem
+from hooks_constants.windows_filesystem import force_rmtree
+
+_original_unlink = os.unlink
+
+
+def _unlink_refusing_read_only_files(path, *, dir_fd=None):
+    file_mode = os.stat(path, dir_fd=dir_fd, follow_symlinks=False).st_mode
+    if not file_mode & stat.S_IWRITE:
+        raise PermissionError(f"read-only file refused: {path}")
+    _original_unlink(path, dir_fd=dir_fd)
+
+
+@pytest.fixture
+def tree_with_read_only_file(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    tree_root = tmp_path / "tree"
+    nested_directory = tree_root / "nested"
+    nested_directory.mkdir(parents=True)
+    read_only_file = nested_directory / "pack.idx"
+    read_only_file.write_text("packed", encoding="utf-8")
+    os.chmod(read_only_file, stat.S_IREAD)
+    monkeypatch.setattr(os, "unlink", _unlink_refusing_read_only_files)
+    with pytest.raises(PermissionError):
+        os.unlink(read_only_file)
+    return tree_root
+
+
+def test_removes_tree_holding_read_only_file(tree_with_read_only_file: Path) -> None:
+    force_rmtree(str(tree_with_read_only_file))
+    assert not tree_with_read_only_file.exists()
+
+
+def test_removes_read_only_file_through_onerror_callback(
+    tree_with_read_only_file: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(windows_filesystem, "_rmtree_supports_onexc", False)
+    force_rmtree(str(tree_with_read_only_file))
+    assert not tree_with_read_only_file.exists()
+
+
+def test_missing_tree_does_not_raise(tmp_path: Path) -> None:
+    missing_tree = tmp_path / "absent"
+    force_rmtree(str(missing_tree))
+    assert not missing_tree.exists()

package/hooks/hooks_constants/visual_reply_rules_constants.py

@@ -0,0 +1,63 @@
+"""Constants for the visual reply mode checks in the reply length gate."""
+
+import re
+from pathlib import Path
+
+RULES_FILE_PATH = (
+    Path(__file__).resolve().parent.parent.parent / "rules" / "visual-reply-rules.json"
+)
+RULES_FILE_ENCODING = "utf-8"
+RULES_LIST_KEY = "rules"
+RULE_KEY_FIELD = "key"
+RULE_LABEL_FIELD = "label"
+RULE_REMINDER_FIELD = "reminder"
+ALLOWED_CAPITALIZED_WORDS_KEY = "allowed_capitalized_words"
+LOWERCASE_ABBREVIATIONS_KEY = "lowercase_abbreviations"
+
+MODE_SWITCH_FILE_NAME = "visual-reply-mode.json"
+MODE_SWITCH_ENABLED_KEY = "enabled"
+
+NO_PICTURE_RULE_KEY = "no_picture"
+ABBREVIATIONS_RULE_KEY = "abbreviations"
+ONE_ITEM_RULE_KEY = "one_item"
+
+WIDGET_TOOL_NAME_SUFFIX = "__post_widget"
+ARTIFACT_TOOL_NAME = "Artifact"
+ALL_VISUAL_TOOL_NAME_SUFFIXES = (WIDGET_TOOL_NAME_SUFFIX, ARTIFACT_TOOL_NAME)
+ALL_REPLY_TOOL_NAME_SUFFIXES = ("__reply", "__post_message")
+MAXIMUM_REPLIES_PER_TURN = 1
+MAXIMUM_SENTENCES_WITHOUT_VISUAL = 1
+
+CAPITALIZED_ABBREVIATION_PATTERN = re.compile(
+    r"(?<![A-Za-z0-9])(?=[A-Z0-9]*[A-Z][A-Z0-9]*[A-Z])[A-Z0-9]{2,}s?(?![A-Za-z0-9])"
+)
+LOWERCASE_ABBREVIATION_TEMPLATE = r"(?<![A-Za-z0-9]){abbreviation}(?![A-Za-z0-9])"
+TRACKER_NUMBER_PATTERN = re.compile(
+    r"\b(?:issues?|items?|cards?|tickets?|tasks?)\s*#?\d+", re.IGNORECASE
+)
+WIDGET_ANCHOR_PATTERN = re.compile(r"<a\b[^>]*\bhref\s*=", re.IGNORECASE)
+
+TRANSCRIPT_ENCODING = "utf-8"
+ENTRY_TYPE_KEY = "type"
+USER_ENTRY_TYPE = "user"
+ASSISTANT_ENTRY_TYPE = "assistant"
+MESSAGE_KEY = "message"
+CONTENT_KEY = "content"
+BLOCK_TYPE_KEY = "type"
+BLOCK_NAME_KEY = "name"
+TEXT_BLOCK_TYPE = "text"
+TOOL_USE_BLOCK_TYPE = "tool_use"
+TOOL_RESULT_BLOCK_TYPE = "tool_result"
+BLOCK_ID_KEY = "id"
+TOOL_USE_ID_KEY = "tool_use_id"
+IS_ERROR_KEY = "is_error"
+IS_META_KEY = "isMeta"
+
+ABBREVIATION_MESSAGE = 'Abbreviation "{abbreviation}" in the text. {reminder}'
+TRACKER_NUMBER_MESSAGE = 'Tracker number "{reference}" in the text. {reminder}'
+NO_VISUAL_MESSAGE = "This reply has {sentence_count} sentences and no visual this turn. {reminder}"
+SECOND_REPLY_MESSAGE = "A reply already went out this turn. {reminder}"
+WIDGET_ANCHOR_MESSAGE = (
+    "A link sits inside the widget code, and a widget link does not open in the Claude app."
+    " Remove the anchor and put the page link in the reply text."
+)

package/hooks/hooks_constants/windows_filesystem.py

@@ -0,0 +1,51 @@
+"""Shared Windows-safe directory-tree removal for the hooks package.
+
+Windows refuses to delete a file that carries the ReadOnly attribute, which git
+sets on pack files and which a test sandbox can leave behind. ``force_rmtree``
+clears the attribute and retries each refused removal, so every hook and test
+that removes a tree imports this one helper.
+"""
+
+from __future__ import annotations
+
+import inspect
+import os
+import shutil
+import stat
+from collections.abc import Callable
+
+__all__ = ["force_rmtree"]
+
+_rmtree_supports_onexc = "onexc" in inspect.signature(shutil.rmtree).parameters
+
+
+def _strip_read_only_and_retry(
+    removal_function: Callable[[str], None],
+    target_path: str,
+    *_unused_exception_info: object,
+) -> None:
+    try:
+        os.chmod(target_path, stat.S_IWRITE)
+        removal_function(target_path)
+    except OSError:
+        pass
+
+
+def force_rmtree(target_path: str) -> None:
+    """Remove a directory tree, clearing the ReadOnly attribute on refused entries.
+
+    Python 3.12 renamed the rmtree error callback to ``onexc``; earlier versions
+    accept only ``onerror``. The helper passes whichever keyword the running
+    interpreter's ``shutil.rmtree`` accepts.
+
+    Args:
+        target_path: The directory tree to remove. A tree that cannot be
+            removed, including a missing one, is left as is without raising.
+    """
+    try:
+        if _rmtree_supports_onexc:
+            shutil.rmtree(target_path, onexc=_strip_read_only_and_retry)
+        else:
+            shutil.rmtree(target_path, onerror=_strip_read_only_and_retry)
+    except OSError:
+        pass

package/hooks/session/session_env_cleanup.py

@@ -18,48 +18,22 @@ from __future__ import annotations
 
 import json
 import os
-import shutil
-import stat
 import sys
 import time
 from pathlib import Path
-from typing import Callable
 
 _hooks_dir = str(Path(__file__).resolve().parent.parent)
 if _hooks_dir not in sys.path:
     sys.path.insert(0, _hooks_dir)
 
-from hooks_constants.session_env_cleanup_constants import (  # noqa: E402
-    ALL_RMTREE_ONEXC_PYTHON_VERSION_PARTS,
+from hooks_constants.session_env_cleanup_constants import (
     SESSION_ENV_DIRECTORY,
     SESSION_ID_PATTERN,
     SESSION_ID_PAYLOAD_KEY,
     STALE_AGE_SECONDS,
     WINDOWS_PLATFORM_TAG,
 )
-
-
-def _strip_read_only_and_retry(
-    removal_function: Callable[[str], None],
-    target_path: str,
-    *_unused_exception_info: object,
-) -> None:
-    try:
-        os.chmod(target_path, stat.S_IWRITE)
-        removal_function(target_path)
-    except OSError:
-        pass
-
-
-def _force_rmtree(target_path: str) -> None:
-    rmtree_onexc_python_version = ALL_RMTREE_ONEXC_PYTHON_VERSION_PARTS
-    try:
-        if sys.version_info >= rmtree_onexc_python_version:
-            shutil.rmtree(target_path, onexc=_strip_read_only_and_retry)
-        else:
-            shutil.rmtree(target_path, onerror=_strip_read_only_and_retry)
-    except OSError:
-        pass
+from hooks_constants.windows_filesystem import force_rmtree
 
 
 def prune_session_env(
@@ -71,7 +45,7 @@ def prune_session_env(
     if session_id:
         current_session_path = os.path.join(session_env_directory, session_id)
         if os.path.isdir(current_session_path):
-            _force_rmtree(current_session_path)
+            force_rmtree(current_session_path)
     if not os.path.isdir(session_env_directory):
         return
     stale_cutoff_seconds = time.time() - stale_age_seconds
@@ -87,7 +61,7 @@ def prune_session_env(
             continue
         if entry_mtime_seconds >= stale_cutoff_seconds:
             continue
-        _force_rmtree(entry_path)
+        force_rmtree(entry_path)
 
 
 def _read_session_id_from_stdin() -> str:

package/hooks/test_followup_ledger.py

@@ -12,6 +12,8 @@ if _hooks_directory not in sys.path:
 from followup_ledger import (
     FollowupFinding,
     all_recorded_findings,
+    deduplicate_ledger,
+    deduplicated_lines,
     followup_ledger_path,
     head_commit,
     record_followup_finding,
@@ -187,3 +189,59 @@ def test_head_commit_reads_a_detached_revision(tmp_path: Path) -> None:
 
 def test_head_commit_is_empty_outside_a_repository(tmp_path: Path) -> None:
     assert head_commit(tmp_path) == ""
+
+
+def test_deduplicated_lines_keeps_the_first_of_each_exact_line_in_order() -> None:
+    assert deduplicated_lines(["a", "b", "a", "c", "b"]) == ["a", "b", "c"]
+
+
+def test_record_followup_finding_removes_lines_a_union_merge_repeated(
+    tmp_path: Path,
+) -> None:
+    ledger_path = followup_ledger_path(tmp_path)
+    ledger_path.parent.mkdir(parents=True)
+    first_line = '{"rule_id": "r1", "file_path": "a.py", "message": "m1"}'
+    second_line = '{"rule_id": "r2", "file_path": "b.py", "message": "m2"}'
+    ledger_path.write_text(
+        f"{first_line}\n{second_line}\n{first_line}\n", encoding="utf-8"
+    )
+
+    record_followup_finding(tmp_path, FollowupFinding("r3", "c.py", "m3", "r3"))
+
+    all_ledger_lines = ledger_path.read_text(encoding="utf-8").splitlines()
+    assert all_ledger_lines[:2] == [first_line, second_line]
+    assert [json.loads(each_line)["rule_id"] for each_line in all_ledger_lines] == [
+        "r1",
+        "r2",
+        "r3",
+    ]
+
+
+def test_record_followup_finding_removes_a_repeat_of_an_already_recorded_finding(
+    tmp_path: Path,
+) -> None:
+    finding = FollowupFinding("r1", "a.py", "m1", "r1")
+    record_followup_finding(tmp_path, finding)
+    ledger_path = followup_ledger_path(tmp_path)
+    recorded_text = ledger_path.read_text(encoding="utf-8")
+    ledger_path.write_text(recorded_text * 2, encoding="utf-8")
+
+    record_followup_finding(tmp_path, finding)
+
+    assert ledger_path.read_text(encoding="utf-8") == recorded_text
+
+
+def test_deduplicate_ledger_reports_how_many_lines_it_removed(tmp_path: Path) -> None:
+    ledger_path = followup_ledger_path(tmp_path)
+    ledger_path.parent.mkdir(parents=True)
+    ledger_path.write_text("x\ny\nx\nx\n", encoding="utf-8")
+
+    removed_count = deduplicate_ledger(tmp_path)
+
+    assert removed_count == 2
+    assert ledger_path.read_text(encoding="utf-8") == "x\ny\n"
+
+
+def test_deduplicate_ledger_leaves_an_absent_ledger_absent(tmp_path: Path) -> None:
+    assert deduplicate_ledger(tmp_path) == 0
+    assert not followup_ledger_path(tmp_path).exists()

package/hooks/test_visual_reply_rules.py

@@ -0,0 +1,164 @@
+"""Behavior tests for the visual reply rule list."""
+
+import json
+import sys
+from pathlib import Path
+
+_hooks_directory = str(Path(__file__).resolve().parent)
+if _hooks_directory not in sys.path:
+    sys.path.insert(0, _hooks_directory)
+
+from visual_reply_rules import (
+    abbreviation_violation,
+    load_rules,
+    mode_enabled,
+    replies_sent_this_turn,
+    second_reply_violation,
+    visual_shown_this_turn,
+    visual_violation,
+    widget_anchor_violation,
+)
+
+SHIPPED_RULES = load_rules()
+
+
+def prompt_line(text: str) -> str:
+    return json.dumps({"type": "user", "message": {"content": text}})
+
+
+def tool_line(tool_name: str) -> str:
+    return json.dumps(
+        {"type": "assistant", "message": {"content": [{"type": "tool_use", "name": tool_name}]}}
+    )
+
+
+def test_shipped_rule_file_parses_with_a_label_and_reminder_per_rule() -> None:
+    rules = load_rules()
+    assert rules is not None
+    assert {each.key for each in rules.all_rules} >= {"one_item", "no_picture", "abbreviations"}
+    assert all(each.label and each.reminder for each in rules.all_rules)
+
+
+def test_load_rules_returns_none_when_a_needed_rule_is_missing(tmp_path: Path) -> None:
+    rules_path = tmp_path / "rules.json"
+    rules_path.write_text(
+        json.dumps({"rules": [{"key": "no_picture", "label": "No picture", "reminder": "Draw it."}]}),
+        encoding="utf-8",
+    )
+    assert load_rules(rules_path) is None
+
+
+def test_mode_is_off_without_a_switch_file(tmp_path: Path) -> None:
+    assert mode_enabled(tmp_path) is False
+
+
+def test_mode_is_on_when_the_switch_file_says_so(tmp_path: Path) -> None:
+    (tmp_path / "visual-reply-mode.json").write_text('{"enabled": true}', encoding="utf-8")
+    assert mode_enabled(tmp_path) is True
+
+
+def test_abbreviation_violation_names_the_abbreviation_and_allows_listed_words() -> None:
+    assert SHIPPED_RULES is not None
+    assert 'Abbreviation "UI"' in str(abbreviation_violation("The UI is done.", SHIPPED_RULES))
+    assert abbreviation_violation("OK, I merged it.", SHIPPED_RULES) is None
+
+
+def test_abbreviation_violation_flags_a_lowercase_abbreviation_and_a_tracker_number() -> None:
+    assert SHIPPED_RULES is not None
+    assert 'Abbreviation "e.g."' in str(abbreviation_violation("Logs, e.g. the error log.", SHIPPED_RULES))
+    assert 'Tracker number "card 12"' in str(abbreviation_violation("See card 12.", SHIPPED_RULES))
+
+
+def test_widget_anchor_violation_reads_only_widget_calls() -> None:
+    anchor_input = {"widget_code": '<a href="https://example.com">page</a>'}
+    assert widget_anchor_violation("mcp__hearthbot__post_widget", anchor_input) is not None
+    assert widget_anchor_violation("mcp__hearthbot__reply", anchor_input) is None
+
+
+def test_visual_shown_this_turn_counts_only_calls_after_the_last_prompt() -> None:
+    assert visual_shown_this_turn([prompt_line("status"), tool_line("Artifact")])
+    assert not visual_shown_this_turn(
+        [prompt_line("status"), tool_line("mcp__hearthbot__post_widget"), prompt_line("next")]
+    )
+
+
+def test_visual_violation_reads_the_transcript_file(tmp_path: Path) -> None:
+    assert SHIPPED_RULES is not None
+    transcript_path = tmp_path / "t.jsonl"
+    transcript_path.write_text(prompt_line("status"), encoding="utf-8")
+    assert visual_violation(2, str(transcript_path), SHIPPED_RULES) is not None
+    assert visual_violation(1, str(transcript_path), SHIPPED_RULES) is None
+    assert visual_violation(2, str(tmp_path / "missing.jsonl"), SHIPPED_RULES) is None
+
+
+def reply_use_line(tool_use_id: str) -> str:
+    return json.dumps(
+        {
+            "type": "assistant",
+            "message": {
+                "content": [{"type": "tool_use", "id": tool_use_id, "name": "mcp__thread__reply"}]
+            },
+        }
+    )
+
+
+def result_line(tool_use_id: str, is_error: bool) -> str:
+    return json.dumps(
+        {
+            "type": "user",
+            "message": {
+                "content": [{"type": "tool_result", "tool_use_id": tool_use_id, "is_error": is_error}]
+            },
+        }
+    )
+
+
+def test_replies_sent_this_turn_counts_delivered_replies_after_the_last_prompt() -> None:
+    all_lines = [
+        prompt_line("earlier"),
+        reply_use_line("a"),
+        result_line("a", False),
+        prompt_line("status"),
+        reply_use_line("b"),
+        result_line("b", True),
+        reply_use_line("c"),
+        result_line("c", False),
+        reply_use_line("d"),
+    ]
+    assert replies_sent_this_turn(all_lines) == 1
+
+
+def widget_use_line(tool_use_id: str) -> str:
+    return json.dumps(
+        {
+            "type": "assistant",
+            "message": {
+                "content": [
+                    {"type": "tool_use", "id": tool_use_id, "name": "mcp__hearthbot__post_widget"}
+                ]
+            },
+        }
+    )
+
+
+def test_visual_shown_this_turn_skips_a_widget_that_came_back_with_an_error() -> None:
+    assert not visual_shown_this_turn(
+        [prompt_line("status"), widget_use_line("w"), result_line("w", True)]
+    )
+    assert visual_shown_this_turn([prompt_line("status"), widget_use_line("w"), result_line("w", False)])
+    assert visual_shown_this_turn([prompt_line("status"), widget_use_line("w")])
+
+
+def test_second_reply_violation_denies_only_after_a_delivered_reply(tmp_path: Path) -> None:
+    transcript_path = tmp_path / "transcript.jsonl"
+    transcript_path.write_text(
+        "\n".join([prompt_line("status"), reply_use_line("a"), result_line("a", True)]),
+        encoding="utf-8",
+    )
+    assert second_reply_violation(str(transcript_path), SHIPPED_RULES) is None
+    transcript_path.write_text(
+        "\n".join([prompt_line("status"), reply_use_line("a"), result_line("a", False)]),
+        encoding="utf-8",
+    )
+    assert second_reply_violation(str(transcript_path), SHIPPED_RULES) is not None
+    assert second_reply_violation(str(tmp_path / "missing.jsonl"), SHIPPED_RULES) is None