claude-dev-env 2.19.0 → 2.21.0

package/hooks/workflow/auto_formatter.py

@@ -1,11 +1,16 @@
 #!/usr/bin/env python3
 
+"""Format eligible newly written source files without blocking the write."""
+
+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
 
@@ -14,6 +19,37 @@ NOTIFICATION_UTILS_DIRECTORY = os.path.join(
 )
 sys.path.insert(0, NOTIFICATION_UTILS_DIRECTORY)
 
+PYTHON_EXTENSIONS = frozenset({".py"})
+JS_EXTENSIONS = frozenset({".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs"})
+JSON_EXTENSIONS = frozenset({".json"})
+PLUGIN_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+HOOKS_DIR = os.path.join(PLUGIN_ROOT, "hooks") + os.sep
+PYTHON_FORMAT_TIMEOUT_SECONDS = 12
+JS_FORMAT_TIMEOUT_SECONDS = 30
+GIT_LS_FILES_TIMEOUT_SECONDS = 5
+WRITE_TOOL_NAME = "Write"
+PYTHON_FORMATTER_NAME = "python"
+PRETTIER_FORMATTER_NAME = "prettier"
+NPX_EXECUTABLE = "npx.cmd" if os.name == "nt" else "npx"
+FORMATTER_DIAGNOSTIC_TEMPLATE = "auto-formatter: %s: %s\n"
+FORMATTER_DIAGNOSTIC_SEPARATOR = "\n"
+FORMATTER_TIMEOUT_DIAGNOSTIC_TEMPLATE = "auto-formatter: %s timed out after %d seconds\n"
+PRETTIER_CONFIG_NAMES = frozenset(
+    {
+        ".prettierrc",
+        ".prettierrc.json",
+        ".prettierrc.yml",
+        ".prettierrc.yaml",
+        ".prettierrc.js",
+        ".prettierrc.cjs",
+        ".prettierrc.mjs",
+        ".prettierrc.toml",
+        "prettier.config.js",
+        "prettier.config.cjs",
+        "prettier.config.mjs",
+    }
+)
+
 
 def load_notification_utils() -> ModuleType | None:
     try:
@@ -41,40 +77,18 @@ def send_format_notification(file_path: str, formatter_name: str) -> None:
         pass
 
 
-PYTHON_EXTENSIONS = {".py"}
-JS_EXTENSIONS = {".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs"}
-JSON_EXTENSIONS = {".json"}
-PLUGIN_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-HOOKS_DIR = os.path.join(PLUGIN_ROOT, "hooks") + os.sep
-PYTHON_FORMAT_TIMEOUT_SECONDS = 12
-JS_FORMAT_TIMEOUT_SECONDS = 30
-GIT_LS_FILES_TIMEOUT_SECONDS = 5
-PRETTIER_CONFIG_NAMES = {
-    ".prettierrc",
-    ".prettierrc.json",
-    ".prettierrc.yml",
-    ".prettierrc.yaml",
-    ".prettierrc.js",
-    ".prettierrc.cjs",
-    ".prettierrc.mjs",
-    ".prettierrc.toml",
-    "prettier.config.js",
-    "prettier.config.cjs",
-    "prettier.config.mjs",
-}
-
-
 def has_prettier_config(file_path: str) -> bool:
     each_ancestor = Path(file_path).resolve().parent
     while True:
-        for config_name in PRETTIER_CONFIG_NAMES:
-            if (each_ancestor / config_name).exists():
-                return True
-        parent = each_ancestor.parent
-        if parent == each_ancestor:
-            break
-        each_ancestor = parent
-    return False
+        if any(
+            (each_ancestor / each_config_name).exists()
+            for each_config_name in PRETTIER_CONFIG_NAMES
+        ):
+            return True
+        parent_directory = each_ancestor.parent
+        if parent_directory == each_ancestor:
+            return False
+        each_ancestor = parent_directory
 
 
 def budgeted_python_format_seconds() -> int:
@@ -89,9 +103,7 @@ def budgeted_python_format_seconds() -> int:
     bound: when commands are missing or time out the loops can spend more than
     this budget.
     """
-    fix_phase_seconds = PYTHON_FORMAT_TIMEOUT_SECONDS
-    format_phase_seconds = PYTHON_FORMAT_TIMEOUT_SECONDS
-    return fix_phase_seconds + format_phase_seconds
+    return PYTHON_FORMAT_TIMEOUT_SECONDS * 2
 
 
 def is_untracked_in_git(file_path: str) -> bool:
@@ -100,82 +112,202 @@ def is_untracked_in_git(file_path: str) -> bool:
     try:
         git_check = subprocess.run(
             ["git", "ls-files", "--error-unmatch", file_path],
-            check=False, capture_output=True,
+            check=False,
+            capture_output=True,
             text=True,
             cwd=containing_directory,
             timeout=GIT_LS_FILES_TIMEOUT_SECONDS,
+            env=_build_git_command_environment(),
         )
         return git_check.returncode != 0
     except (FileNotFoundError, subprocess.TimeoutExpired):
         return False
 
 
-def main() -> None:
+def _build_git_command_environment() -> dict[str, str]:
+    return {
+        each_name: each_value
+        for each_name, each_value in os.environ.items()
+        if not each_name.upper().startswith("GIT_")
+    }
+
+
+def _is_path_under_directory(candidate_path: str, directory_path: str) -> bool:
+    try:
+        return os.path.commonpath((candidate_path, directory_path)) == directory_path
+    except ValueError:
+        return False
+
+
+def is_protected_path(file_path: str) -> bool:
+    lexical_hooks_directory = os.path.normcase(os.path.abspath(HOOKS_DIR))
+    lexical_candidate_path = os.path.normcase(os.path.abspath(file_path))
+    resolved_hooks_directory = os.path.normcase(os.path.realpath(HOOKS_DIR))
+    resolved_candidate_path = os.path.normcase(os.path.realpath(file_path))
+    return _is_path_under_directory(
+        lexical_candidate_path, lexical_hooks_directory
+    ) or _is_path_under_directory(resolved_candidate_path, resolved_hooks_directory)
+
+
+def formatter_name_for_path(file_path: str) -> str | None:
+    suffix = Path(file_path).suffix.lower()
+    if suffix in PYTHON_EXTENSIONS:
+        return PYTHON_FORMATTER_NAME
+    if suffix in JS_EXTENSIONS or suffix in JSON_EXTENSIONS:
+        if has_prettier_config(file_path):
+            return PRETTIER_FORMATTER_NAME
+    return None
+
+
+def is_formatter_eligible(tool_name: str, file_path: str) -> bool:
+    if tool_name != WRITE_TOOL_NAME or not file_path:
+        return False
+    if is_protected_path(file_path) or not is_untracked_in_git(file_path):
+        return False
+    return formatter_name_for_path(file_path) is not None
+
+
+def _write_command_diagnostic(file_path: str, command: list[str], diagnostic_text: str) -> None:
+    normalized_diagnostic = diagnostic_text.strip()
+    if not normalized_diagnostic:
+        return
+    command_text = " ".join(command)
+    sys.stderr.write(
+        FORMATTER_DIAGNOSTIC_TEMPLATE % (file_path, f"{command_text}: {normalized_diagnostic}")
+    )
+
+
+def _combine_command_diagnostics(
+    completed_process: subprocess.CompletedProcess[str],
+) -> str:
+    all_diagnostics = [
+        each_stream.strip()
+        for each_stream in (completed_process.stdout, completed_process.stderr)
+        if each_stream
+    ]
+    return FORMATTER_DIAGNOSTIC_SEPARATOR.join(all_diagnostics)
+
+
+def _run_command(
+    command: list[str], file_path: str, timeout_seconds: int
+) -> tuple[subprocess.CompletedProcess[str] | None, bool]:
     try:
-        hook_input = json.load(sys.stdin)
+        completed_process = subprocess.run(
+            command,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=timeout_seconds,
+        )
+    except FileNotFoundError:
+        return None, False
+    except subprocess.TimeoutExpired:
+        sys.stderr.write(FORMATTER_TIMEOUT_DIAGNOSTIC_TEMPLATE % (file_path, timeout_seconds))
+        return None, True
+
+    if completed_process.returncode != 0:
+        _write_command_diagnostic(
+            file_path,
+            command,
+            _combine_command_diagnostics(completed_process),
+        )
+    return completed_process, False
+
+
+def _run_python_fix_commands(file_path: str) -> None:
+    all_fix_commands = [
+        ["ruff", "check", "--fix", file_path],
+        [sys.executable, "-m", "ruff", "check", "--fix", file_path],
+    ]
+    for each_command in all_fix_commands:
+        completed_process, did_timeout = _run_command(
+            each_command, file_path, PYTHON_FORMAT_TIMEOUT_SECONDS
+        )
+        if did_timeout or completed_process is not None:
+            return
+
+
+def _run_python_format_commands(file_path: str) -> None:
+    all_format_commands = [
+        ["ruff", "format", file_path],
+        [sys.executable, "-m", "ruff", "format", file_path],
+        ["black", file_path],
+        [sys.executable, "-m", "black", file_path],
+    ]
+    for each_command in all_format_commands:
+        completed_process, did_timeout = _run_command(
+            each_command, file_path, PYTHON_FORMAT_TIMEOUT_SECONDS
+        )
+        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,
+        "--yes",
+        "prettier",
+        "--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)
+
+
+def run_eligible_formatter(file_path: str) -> None:
+    formatter_name = formatter_name_for_path(file_path)
+    if formatter_name == PYTHON_FORMATTER_NAME:
+        _run_python_fix_commands(file_path)
+        _run_python_format_commands(file_path)
+        return
+    if formatter_name == PRETTIER_FORMATTER_NAME:
+        _run_prettier(file_path)
+
+
+def _read_hook_input() -> dict[str, object] | None:
+    try:
+        parsed_input = json.load(sys.stdin)
     except (json.JSONDecodeError, ValueError):
-        sys.exit(0)
+        return None
+    if not isinstance(parsed_input, dict):
+        return None
+    return parsed_input
 
-    tool_name = hook_input.get("tool_name", "")
-    file_path = hook_input.get("tool_input", {}).get("file_path", "")
-    if not file_path:
-        sys.exit(0)
 
-    if tool_name == "Edit":
-        sys.exit(0)
+def _read_string_field(field_source: Mapping[str, object], field_name: str) -> str:
+    field_value = field_source.get(field_name)
+    return field_value if isinstance(field_value, str) else ""
 
-    if tool_name == "Write" and not is_untracked_in_git(file_path):
-        sys.exit(0)
 
-    if file_path.startswith(HOOKS_DIR):
-        sys.exit(0)
+def _read_hook_file_path(hook_input: Mapping[str, object]) -> str:
+    tool_input = hook_input.get("tool_input")
+    if not isinstance(tool_input, dict):
+        return ""
+    return _read_string_field(tool_input, "file_path")
 
-    suffix = Path(file_path).suffix.lower()
 
-    if suffix in PYTHON_EXTENSIONS:
-        for each_fix_command in [
-            ["ruff", "check", "--fix", file_path],
-            [sys.executable, "-m", "ruff", "check", "--fix", file_path],
-        ]:
-            try:
-                subprocess.run(each_fix_command, capture_output=True, text=True, timeout=PYTHON_FORMAT_TIMEOUT_SECONDS, check=False)
-                break
-            except FileNotFoundError:
-                continue
-            except subprocess.TimeoutExpired:
-                break
-        for each_formatter_command in [
-            ["ruff", "format", file_path],
-            [sys.executable, "-m", "ruff", "format", file_path],
-            ["black", file_path],
-            [sys.executable, "-m", "black", file_path],
-        ]:
-            try:
-                format_run = subprocess.run(each_formatter_command, check=False, capture_output=True, text=True, timeout=PYTHON_FORMAT_TIMEOUT_SECONDS)
-                if format_run.returncode == 0:
-                    formatter_name = each_formatter_command[0] if each_formatter_command[0] != sys.executable else each_formatter_command[2]
-                    send_format_notification(file_path, formatter_name)
-                    break
-            except FileNotFoundError:
-                continue
-            except subprocess.TimeoutExpired:
-                break
-    elif suffix in JS_EXTENSIONS or suffix in JSON_EXTENSIONS:
-        if not has_prettier_config(file_path):
-            sys.exit(0)
-        try:
-            prettier_run = subprocess.run(
-                ["npx", "--yes", "prettier", "--write", file_path],
-                check=False, capture_output=True,
-                text=True,
-                timeout=JS_FORMAT_TIMEOUT_SECONDS,
-            )
-            if prettier_run.returncode == 0:
-                send_format_notification(file_path, "prettier")
-        except (FileNotFoundError, subprocess.TimeoutExpired):
-            pass
-
-    sys.exit(0)
+def main() -> None:
+    hook_input = _read_hook_input()
+    if hook_input is None:
+        return
+
+    tool_name = _read_string_field(hook_input, "tool_name")
+    file_path = _read_hook_file_path(hook_input)
+    if not is_formatter_eligible(tool_name, file_path):
+        return
+    run_eligible_formatter(file_path)
 
 
 if __name__ == "__main__":

package/hooks/workflow/investigation_tracker_reset.py

@@ -33,6 +33,8 @@ def main() -> None:
         hook_input = json.load(sys.stdin)
     except json.JSONDecodeError:
         sys.exit(0)
+    if not isinstance(hook_input, dict):
+        sys.exit(0)
 
     tool_name = hook_input.get("tool_name", "")
     if tool_name not in DELEGATION_TOOLS: