claude-dev-env 8.35.2 → 8.35.3

package/hooks/validation/mypy_validator.py

@@ -13,7 +13,6 @@ Project root is discovered via CLAUDE_PROJECT_ROOT env var or git rev-parse.
 """
 
 import hashlib
-import importlib
 import json
 import os
 import platform
@@ -21,13 +20,9 @@ import stat
 import subprocess
 import sys
 from pathlib import Path
-from types import ModuleType
 
 _hooks_directory = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
-_notification_utils_directory = os.path.join(_hooks_directory, "notification")
-sys.path.insert(0, _notification_utils_directory)
-
 _validators_directory = os.path.join(_hooks_directory, "validators")
 if _validators_directory not in sys.path:
     sys.path.insert(0, _validators_directory)
@@ -59,14 +54,6 @@ from json_file_reader import read_json_object  # noqa: E402
 
 from hooks_constants.subprocess_window import hidden_window_creation_flags
 
-
-def load_notification_utils() -> ModuleType | None:
-    try:
-        return importlib.import_module("notification_utils")
-    except ImportError:
-        return None
-
-
 IS_WINDOWS = platform.system() == "Windows"
 
 GIT_COMMAND_TIMEOUT_SECONDS = 5
@@ -530,25 +517,6 @@ def format_error_summary(all_error_lines: list[str]) -> str:
     return error_summary
 
 
-def send_block_notification(error_summary: str) -> None:
-    notification_module = load_notification_utils()
-    if notification_module is None:
-        return
-
-    notification_title = "Mypy Type Errors"
-    notification_body = f"Write blocked: {error_summary[:200]}"
-
-    try:
-        if notification_module.is_wsl():
-            notification_module.notify_wsl(notification_title, notification_body)
-        elif platform.system() == "Linux":
-            notification_module.notify_linux()
-        elif platform.system() == "Windows":
-            notification_module.notify_windows(notification_title, notification_body)
-    except (AttributeError, OSError):
-        pass
-
-
 def build_block_response(error_summary: str) -> dict[str, str | dict[str, str]]:
     return {
         "decision": "block",
@@ -615,7 +583,6 @@ def main() -> None:
         sys.exit(0)
 
     error_summary = format_error_summary(all_error_lines)
-    send_block_notification(error_summary)
     block_response = build_block_response(error_summary)
     log_hook_block(
         calling_hook_name="mypy_validator.py",

package/hooks/validation/test_mypy_validator_toast.py

@@ -0,0 +1,77 @@
+"""The mypy_validator hook reports a block through its reply and nothing else.
+
+An install from before the package dropped ``hooks/notification`` keeps
+``notification_utils.py`` on disk. This test puts a recording stand-in for
+that module on the import path and checks a blocked write never reads it.
+"""
+
+import importlib.util
+import io
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+HOOK_PATH = Path(__file__).resolve().parent / "mypy_validator.py"
+TYPE_ERROR_MODULE_SOURCE = 'value: int = "not an integer"\n'
+
+
+def _load_validator() -> ModuleType:
+    spec = importlib.util.spec_from_file_location("mypy_validator_toast_under_test", HOOK_PATH)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _build_recording_notification_module(all_touched_names: list[str]) -> ModuleType:
+    class RecordingNotificationModule(ModuleType):
+        def __getattr__(self, attribute_name: str) -> object:
+            if not attribute_name.startswith("__"):
+                all_touched_names.append(attribute_name)
+            return lambda *_arguments, **_options: False
+
+    return RecordingNotificationModule("notification_utils")
+
+
+def test_type_error_block_opens_no_desktop_toast(
+    tmp_path_factory: pytest.TempPathFactory,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """A blocked write reports through the hook reply and leaves the desktop alone.
+
+    ::
+
+        mypy typed_module.py  ->  error: Incompatible types
+        ok:   {"decision": "block"} on stdout, notification_utils untouched
+        flag: notify_windows() opens a toast window at the bottom of the screen
+    """
+    validator = _load_validator()
+    project_root = tmp_path_factory.mktemp("blocked_project")
+    target_file = project_root / "typed_module.py"
+    target_file.write_text(TYPE_ERROR_MODULE_SOURCE, encoding="utf-8")
+    all_touched_names: list[str] = []
+    monkeypatch.setitem(
+        sys.modules,
+        "notification_utils",
+        _build_recording_notification_module(all_touched_names),
+    )
+    monkeypatch.setattr(validator, "discover_project_root", lambda _target: project_root)
+    monkeypatch.setattr(
+        validator,
+        "run_mypy",
+        lambda _target, _root: (1, f"{target_file}:1: error: Incompatible types\n"),
+    )
+    monkeypatch.setattr(validator, "log_hook_block", lambda **_details: None)
+    monkeypatch.setattr(
+        sys, "stdin", io.StringIO(json.dumps({"tool_input": {"file_path": str(target_file)}}))
+    )
+
+    with pytest.raises(SystemExit):
+        validator.main()
+
+    assert json.loads(capsys.readouterr().out)["decision"] == "block"
+    assert all_touched_names == []

package/hooks/workflow/auto_formatter.py

@@ -4,15 +4,12 @@
 
 from __future__ import annotations
 
-import importlib
 import json
 import os
-import platform
 import subprocess
 import sys
 from collections.abc import Mapping
 from pathlib import Path
-from types import ModuleType
 
 _subprocess_window_hooks_directory = str(Path(__file__).resolve().parents[2] / "hooks")
 if _subprocess_window_hooks_directory not in sys.path:
@@ -20,11 +17,6 @@ if _subprocess_window_hooks_directory not in sys.path:
 
 from hooks_constants.subprocess_window import hidden_window_creation_flags
 
-NOTIFICATION_UTILS_DIRECTORY = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "notification"
-)
-sys.path.insert(0, NOTIFICATION_UTILS_DIRECTORY)
-
 PYTHON_EXTENSIONS = frozenset({".py"})
 JS_EXTENSIONS = frozenset({".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs"})
 JSON_EXTENSIONS = frozenset({".json"})
@@ -57,32 +49,6 @@ PRETTIER_CONFIG_NAMES = frozenset(
 )
 
 
-def load_notification_utils() -> ModuleType | None:
-    try:
-        return importlib.import_module("notification_utils")
-    except ImportError:
-        return None
-
-
-def send_format_notification(file_path: str, formatter_name: str) -> None:
-    notification_module = load_notification_utils()
-    if notification_module is None:
-        return
-
-    notification_title = "Auto-Formatter"
-    notification_body = f"{formatter_name} formatted: {Path(file_path).name}"
-
-    try:
-        if notification_module.is_wsl():
-            notification_module.notify_wsl(notification_title, notification_body)
-        elif platform.system() == "Linux":
-            notification_module.notify_linux()
-        elif platform.system() == "Windows":
-            notification_module.notify_windows(notification_title, notification_body)
-    except (AttributeError, OSError):
-        pass
-
-
 def has_prettier_config(file_path: str) -> bool:
     each_ancestor = Path(file_path).resolve().parent
     while True:
@@ -249,16 +215,9 @@ def _run_python_format_commands(file_path: str) -> None:
         if did_timeout:
             return
         if completed_process is not None and completed_process.returncode == 0:
-            send_format_notification(file_path, formatter_name_for_command(each_command))
             return
 
 
-def formatter_name_for_command(command: list[str]) -> str:
-    if command[0] == sys.executable:
-        return command[2]
-    return command[0]
-
-
 def _run_prettier(file_path: str) -> None:
     prettier_command = [
         NPX_EXECUTABLE,
@@ -267,11 +226,7 @@ def _run_prettier(file_path: str) -> None:
         "--write",
         os.path.realpath(file_path),
     ]
-    completed_process, _did_timeout = _run_command(
-        prettier_command, file_path, JS_FORMAT_TIMEOUT_SECONDS
-    )
-    if completed_process is not None and completed_process.returncode == 0:
-        send_format_notification(file_path, PRETTIER_FORMATTER_NAME)
+    _run_command(prettier_command, file_path, JS_FORMAT_TIMEOUT_SECONDS)
 
 
 def run_eligible_formatter(file_path: str) -> None:

package/hooks/workflow/test_auto_formatter_toast.py

@@ -0,0 +1,67 @@
+"""The auto_formatter hook leaves the desktop alone after a format.
+
+An install from before the package dropped ``hooks/notification`` keeps
+``notification_utils.py`` on disk. These tests put a recording stand-in for
+that module on the import path and check the hook never reads it.
+"""
+
+import importlib.util
+import subprocess
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+HOOK_SCRIPT_PATH = Path(__file__).resolve().parent / "auto_formatter.py"
+
+
+def _load_auto_formatter_module() -> ModuleType:
+    module_spec = importlib.util.spec_from_file_location(
+        "auto_formatter_toast_under_test", HOOK_SCRIPT_PATH
+    )
+    assert module_spec is not None and module_spec.loader is not None
+    auto_formatter_module = importlib.util.module_from_spec(module_spec)
+    module_spec.loader.exec_module(auto_formatter_module)
+    return auto_formatter_module
+
+
+def _build_recording_notification_module(all_touched_names: list[str]) -> ModuleType:
+    class RecordingNotificationModule(ModuleType):
+        def __getattr__(self, attribute_name: str) -> object:
+            if not attribute_name.startswith("__"):
+                all_touched_names.append(attribute_name)
+            return lambda *_arguments, **_options: False
+
+    return RecordingNotificationModule("notification_utils")
+
+
+def test_successful_format_opens_no_desktop_toast(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A stale notification_utils on the import path stays untouched after a format.
+
+    ::
+
+        ~/.claude/hooks/notification/notification_utils.py   left behind by an old install
+        ruff format module.py  ->  exit 0
+        ok:   nothing reads notification_utils
+        flag: notify_windows() opens a toast window at the bottom of the screen
+    """
+    auto_formatter_module = _load_auto_formatter_module()
+    all_touched_names: list[str] = []
+    monkeypatch.setitem(
+        sys.modules,
+        "notification_utils",
+        _build_recording_notification_module(all_touched_names),
+    )
+
+    def report_formatter_success(
+        command: list[str], _file_path: str, _timeout_seconds: int
+    ) -> tuple[subprocess.CompletedProcess[str], bool]:
+        return subprocess.CompletedProcess(command, 0, "", ""), False
+
+    monkeypatch.setattr(auto_formatter_module, "_run_command", report_formatter_success)
+
+    auto_formatter_module.run_eligible_formatter("formatted_module.py")
+    auto_formatter_module._run_prettier("formatted_module.js")
+
+    assert all_touched_names == []

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.35.2",
+    "version": "8.35.3",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {