claude-dev-env 7.4.1 → 7.6.0

package/hooks/git-hooks/subprocess_window_access.py

@@ -0,0 +1,41 @@
+"""Reach the hidden-window helpers from the scripts this directory deploys.
+
+The installer copies this directory into a profile that holds no installed
+Python distribution, and this repository's own tests run the deployed scripts
+under ``python -S -E``, which hides every installed package from the child
+process. On both routes ``hooks_constants`` is reachable only through the
+deployed ``hooks`` directory, so this module puts that directory on
+``sys.path`` and re-exports the helpers a caller asks for::
+
+    from subprocess_window_access import hidden_window_creation_flags
+
+The directory goes on the end of ``sys.path``. ``PathFinder`` runs ahead of
+every editable-install finder, so a trailing entry still selects the deployed
+copy, and the head of ``sys.path`` stays exactly as the caller left it. A
+caller that prepended its own roots keeps them first.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_subprocess_window_hooks_directory = str(
+    Path(__file__).resolve().parents[2] / "hooks"
+)
+if _subprocess_window_hooks_directory not in sys.path:
+    sys.path.append(_subprocess_window_hooks_directory)
+
+from hooks_constants.subprocess_window import (
+    HiddenWindowStartupInfo,
+    detached_hidden_window_creation_flags,
+    hidden_window_creation_flags,
+    inherited_stream_startup_info,
+)
+
+__all__ = [
+    "HiddenWindowStartupInfo",
+    "detached_hidden_window_creation_flags",
+    "hidden_window_creation_flags",
+    "inherited_stream_startup_info",
+]

package/hooks/git-hooks/test_verification_start.py

@@ -15,6 +15,9 @@ from verification_notice import build_verification_notice
 from verification_notice_context import VerificationNoticeContext
 from verification_start import start_automatic_advisory
 
+WINDOWS_NO_WINDOW_FLAG = 0x08000000
+EXPECTED_HIDDEN_WINDOW_FLAGS = WINDOWS_NO_WINDOW_FLAG if sys.platform == "win32" else 0
+
 
 def build_context(
     repository_root: Path,
@@ -102,6 +105,7 @@ def _assert_launch_matches_runner(
     assert launch_options["stdin"] is subprocess.DEVNULL
     assert launch_options["stdout"] is subprocess.DEVNULL
     assert launch_options["stderr"] is subprocess.DEVNULL
+    assert launch_options["creationflags"] == EXPECTED_HIDDEN_WINDOW_FLAGS
     assert "--once" not in command
 
 

package/hooks/git-hooks/verification_notice_context.py

@@ -36,6 +36,8 @@ from git_hooks_constants.verification_notice_constants import (
 )
 from local_verification.manifest import ManifestRunFatal, load_manifest
 
+from subprocess_window_access import hidden_window_creation_flags
+
 
 @dataclass(frozen=True)
 class VerificationNoticeContext:
@@ -202,6 +204,7 @@ def _run_git_query(
             encoding=GIT_OUTPUT_ENCODING_NAME,
             errors=GIT_OUTPUT_DECODE_ERRORS_POLICY,
             timeout=GIT_COMMAND_TIMEOUT_SECONDS,
+            creationflags=hidden_window_creation_flags(),
         )
     except (OSError, subprocess.SubprocessError, UnicodeError):
         return None

package/hooks/git-hooks/verification_start.py

@@ -13,7 +13,6 @@ from git_hooks_constants.verification_notice_constants import (
     ALL_RUNNER_FIELDS,
     AUTOMATIC_ADVISORY_CLI_FILE_NAME,
     AUTOMATIC_ADVISORY_DIRECTORY_NAME,
-    CREATE_NO_WINDOW_ATTRIBUTE,
     EXECUTOR_DIRECTORY_NAME,
     GIT_DIRECTORY_NAME,
     JSON_ENCODING,
@@ -22,10 +21,15 @@ from git_hooks_constants.verification_notice_constants import (
     RUNNER_PYTHON_FIELD,
     RUNNER_SETTINGS_FIELD,
     TARGET_REPOSITORY_REMOTE,
-    WINDOWS_PLATFORM,
 )
 from verification_notice_context import VerificationNoticeContext
 
+_subprocess_window_hooks_directory = str(Path(__file__).resolve().parents[2] / "hooks")
+if _subprocess_window_hooks_directory not in sys.path:
+    sys.path.append(_subprocess_window_hooks_directory)
+
+from hooks_constants.subprocess_window import hidden_window_creation_flags
+
 
 def start_automatic_advisory(context: VerificationNoticeContext) -> None:
     """Start the detached advisory poller when native metadata is valid."""
@@ -66,7 +70,7 @@ def _launch_advisory(
         stdin=subprocess.DEVNULL,
         stdout=subprocess.DEVNULL,
         stderr=subprocess.DEVNULL,
-        creationflags=_windows_creation_flags(),
+        creationflags=hidden_window_creation_flags(),
     )
 
 
@@ -93,8 +97,3 @@ def load_runner_configuration(
         return None
     return python_path, settings_path
 
-
-def _windows_creation_flags() -> int:
-    if sys.platform != WINDOWS_PLATFORM:
-        return 0
-    return getattr(subprocess, CREATE_NO_WINDOW_ATTRIBUTE, 0)

package/hooks/hooks.json

@@ -12,6 +12,16 @@
           }
         ]
       },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/bash_pre_tool_use_dispatcher.py",
+            "timeout": 60
+          }
+        ]
+      },
       {
         "matcher": "EnterWorktree",
         "hooks": [

package/hooks/hooks_constants/bash_post_call_dispatcher_constants.py

@@ -5,6 +5,10 @@ finishes. Reuses ``BashHostedHookEntry`` and the Bash-only tool-name set from
 ``bash_pre_tool_use_dispatcher_constants`` -- the entry shape and the tool-name
 membership question are identical on the PostToolUse side, so this module adds
 no second copy of either.
+
+Also the one home for the harness PostToolUse output contract every hook on
+this roster shares: the exit-code prefix a failed call's response text opens
+with, and the three payload keys that carry a context note back to the agent.
 """
 
 from __future__ import annotations
@@ -17,8 +21,10 @@ from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
 
 __all__ = [
     "ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES",
+    "EXIT_CODE_ERROR_PREFIX",
     "POST_TOOL_USE_HOOK_EVENT_NAME",
     "HOOK_SPECIFIC_OUTPUT_KEY",
+    "HOOK_EVENT_NAME_KEY",
     "ADDITIONAL_CONTEXT_KEY",
     "ADDITIONAL_CONTEXT_JOIN_SEPARATOR",
 ]
@@ -26,9 +32,12 @@ __all__ = [
 ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = (
     BashHostedHookEntry("observability/test_failure_recorder.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("advisory/pr_done_reminder.py", ALL_BASH_AND_POWERSHELL_TOOL_NAMES),
+    BashHostedHookEntry("advisory/msys_path_conversion_advisor.py", ALL_BASH_ONLY_TOOL_NAMES),
 )
 
+EXIT_CODE_ERROR_PREFIX: str = "Error: Exit code "
 POST_TOOL_USE_HOOK_EVENT_NAME: str = "PostToolUse"
 HOOK_SPECIFIC_OUTPUT_KEY: str = "hookSpecificOutput"
+HOOK_EVENT_NAME_KEY: str = "hookEventName"
 ADDITIONAL_CONTEXT_KEY: str = "additionalContext"
 ADDITIONAL_CONTEXT_JOIN_SEPARATOR: str = "\n\n"

package/hooks/hooks_constants/bash_pre_tool_use_dispatcher_constants.py

@@ -54,4 +54,9 @@ class BashHostedHookEntry:
     applicable_tool_names: frozenset[str]
 
 
-ALL_BASH_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = ()
+ALL_BASH_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = (
+    BashHostedHookEntry(
+        script_relative_path="blocking/msys_rev_path_rewriter.py",
+        applicable_tool_names=ALL_BASH_ONLY_TOOL_NAMES,
+    ),
+)

package/hooks/hooks_constants/code_rules_enforcer_constants.py

@@ -132,12 +132,14 @@ ALL_TOKEN_ANCHORED_EXEMPT_COMMENT_BODIES: tuple[str, ...] = (
     "pragma:",
 )
 ALL_TOKEN_ANCHORED_DIRECTIVE_BOUNDARY_CHARACTERS: frozenset[str] = frozenset({":"})
+STEALTH_KEEP_COMMENT_MARKER: str = "STEALTH: Keep"
 ALL_FREE_FORM_EXEMPT_COMMENT_BODIES: tuple[str, ...] = (
     "type:",
     "TODO",
     "FIXME",
     "HACK",
     "XXX",
+    STEALTH_KEEP_COMMENT_MARKER,
 )
 CHAINED_INLINE_COMMENT_PATTERN = re.compile(r"#")
 ALL_JAVASCRIPT_EXEMPT_COMMENT_PREFIXES: tuple[str, ...] = (

package/hooks/hooks_constants/msys_path_conversion_advisor_constants.py

@@ -0,0 +1,48 @@
+"""Constants for the MSYS path-conversion context advisory.
+
+The advisory is a PostToolUse observer on Bash. It never blocks. When a git
+call fails because Git Bash rewrote a ``<rev>:<path>`` argument before git saw
+it, the advisory adds one loud note naming the two exports that turn the
+rewriting off.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "ALL_MANGLED_ARGUMENT_MARKERS",
+    "MANGLED_ARGUMENT_CLOSING_QUOTE",
+    "ALL_MSYS_MANGLING_CHARACTERS",
+    "ALL_MSYS_PATH_CONVERSION_VARIABLE_NAMES",
+    "ADVISORY_HEADER",
+    "MANGLED_ARGUMENT_LINE_TEMPLATE",
+    "MANGLING_EXPLANATION_LINE",
+    "FIX_LINE",
+    "SAME_COMMAND_LINE",
+    "ADVISORY_LINE_SEPARATOR",
+]
+
+AMBIGUOUS_ARGUMENT_MARKER: str = "fatal: ambiguous argument '"
+INVALID_OBJECT_NAME_MARKER: str = "fatal: invalid object name '"
+ALL_MANGLED_ARGUMENT_MARKERS: tuple[str, ...] = (
+    AMBIGUOUS_ARGUMENT_MARKER,
+    INVALID_OBJECT_NAME_MARKER,
+)
+MANGLED_ARGUMENT_CLOSING_QUOTE: str = "'"
+ALL_MSYS_MANGLING_CHARACTERS: frozenset[str] = frozenset({"\\", ";"})
+MSYS_PATH_CONVERSION_VARIABLE_NAME: str = "MSYS_NO_PATHCONV"
+MSYS_ARGUMENT_CONVERSION_EXCLUSION_VARIABLE_NAME: str = "MSYS2_ARG_CONV_EXCL"
+ALL_MSYS_PATH_CONVERSION_VARIABLE_NAMES: tuple[str, ...] = (
+    MSYS_PATH_CONVERSION_VARIABLE_NAME,
+    MSYS_ARGUMENT_CONVERSION_EXCLUSION_VARIABLE_NAME,
+)
+MSYS_EXPORT_FIX_LINE: str = "export MSYS_NO_PATHCONV=1 MSYS2_ARG_CONV_EXCL='*'"
+
+ADVISORY_HEADER: str = "=== MSYS PATH CONVERSION (context reminder, never a block) ==="
+MANGLED_ARGUMENT_LINE_TEMPLATE: str = "Git saw:     {argument}"
+MANGLING_EXPLANATION_LINE: str = (
+    "Git Bash rewrote a <rev>:<path> argument before git saw it, turning the "
+    "colon into a semicolon and the slashes into backslashes."
+)
+FIX_LINE: str = "Fix:         " + MSYS_EXPORT_FIX_LINE
+SAME_COMMAND_LINE: str = "Put that export and the git command in the same command."
+ADVISORY_LINE_SEPARATOR: str = "\n"

package/hooks/hooks_constants/msys_rev_path_rewriter_constants.py

@@ -0,0 +1,37 @@
+"""Constants for the MSYS ``<rev>:<path>`` argument-exclusion rewriter.
+
+Git Bash converts a git argument such as ``origin/main:.claude/settings.json``
+before git sees it. ``MSYS2_ARG_CONV_EXCL`` takes a semicolon-separated list of
+argument prefixes to leave alone, so naming one ``<rev>:`` prefix per detected
+token keeps every other argument in the command converting as before.
+"""
+
+from __future__ import annotations
+
+from hooks_constants.msys_path_conversion_advisor_constants import (
+    MSYS_ARGUMENT_CONVERSION_EXCLUSION_VARIABLE_NAME,
+)
+
+__all__ = [
+    "GIT_PROGRAM_NAME",
+    "REVISION_PATH_SEPARATOR",
+    "REVISION_PATH_SPLIT_COUNT",
+    "REVISION_SLASH_CHARACTER",
+    "ALL_CONVERTED_PATH_START_CHARACTERS",
+    "ALL_UNCONVERTED_PATH_START_PREFIXES",
+    "ALL_REVISION_FORBIDDEN_CHARACTERS",
+    "EXCLUSION_PREFIX_JOIN_SEPARATOR",
+    "EXCLUSION_EXPORT_TEMPLATE",
+]
+
+GIT_PROGRAM_NAME: str = "git"
+REVISION_PATH_SEPARATOR: str = ":"
+REVISION_PATH_SPLIT_COUNT: int = 1
+REVISION_SLASH_CHARACTER: str = "/"
+ALL_CONVERTED_PATH_START_CHARACTERS: tuple[str, ...] = ("/", ".")
+ALL_UNCONVERTED_PATH_START_PREFIXES: tuple[str, ...] = ("./", "../")
+ALL_REVISION_FORBIDDEN_CHARACTERS: tuple[str, ...] = ("'", '"')
+EXCLUSION_PREFIX_JOIN_SEPARATOR: str = ";"
+EXCLUSION_EXPORT_TEMPLATE: str = (
+    "export " + MSYS_ARGUMENT_CONVERSION_EXCLUSION_VARIABLE_NAME + "='{all_prefixes}'; "
+)

package/hooks/hooks_constants/post_tool_use_context.py

@@ -0,0 +1,34 @@
+"""Shared stdout emitter for PostToolUse hooks that add context."""
+
+from __future__ import annotations
+
+import json
+import sys
+
+from hooks_constants.bash_post_call_dispatcher_constants import (
+    ADDITIONAL_CONTEXT_KEY,
+    HOOK_EVENT_NAME_KEY,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+    POST_TOOL_USE_HOOK_EVENT_NAME,
+)
+
+
+def write_post_tool_use_context_to_stdout(context_text: str) -> None:
+    """Write one PostToolUse additionalContext payload to stdout.
+
+    A hosted hook writes its note here and the Bash PostToolUse dispatcher
+    reads it back, joins it with the other hooks' notes, and writes the joined
+    text here in turn. Both ends of that hop share this one payload shape
+    rather than each carrying a copy of it.
+
+    Args:
+        context_text: The advisory text the dispatcher forwards.
+    """
+    payload = {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            HOOK_EVENT_NAME_KEY: POST_TOOL_USE_HOOK_EVENT_NAME,
+            ADDITIONAL_CONTEXT_KEY: context_text,
+        }
+    }
+    sys.stdout.write(json.dumps(payload))
+    sys.stdout.flush()

package/hooks/hooks_constants/pr_done_reminder_constants.py

@@ -19,7 +19,6 @@ __all__ = [
     "ALL_GH_PR_VIEW_ARGUMENTS",
     "GH_PR_VIEW_TIMEOUT_SECONDS",
     "NO_PULL_REQUEST_MARKER",
-    "EXIT_CODE_ERROR_PREFIX",
     "DONE_LABEL_NAME",
     "MERGEABLE_CLEAN_VALUE",
     "MERGEABLE_CONFLICTING_VALUE",
@@ -59,7 +58,6 @@ ALL_GH_PR_VIEW_ARGUMENTS: tuple[str, ...] = (
 )
 GH_PR_VIEW_TIMEOUT_SECONDS: int = 20
 NO_PULL_REQUEST_MARKER: str = "no pull requests found"
-EXIT_CODE_ERROR_PREFIX: str = "Error: Exit code "
 
 DONE_LABEL_NAME: str = "done"
 

package/hooks/hooks_constants/pre_tool_use_allow_output.py

@@ -0,0 +1,48 @@
+"""Shared stdout emitter for PreToolUse hooks that allow a rewritten tool input."""
+
+from __future__ import annotations
+
+import json
+import sys
+
+from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
+    ALLOW_DECISION,
+    HOOK_EVENT_NAME,
+)
+
+__all__ = [
+    "HOOK_SPECIFIC_OUTPUT_KEY",
+    "HOOK_EVENT_NAME_KEY",
+    "PERMISSION_DECISION_KEY",
+    "UPDATED_INPUT_KEY",
+    "write_pre_tool_use_allow_to_stdout",
+]
+
+HOOK_SPECIFIC_OUTPUT_KEY: str = "hookSpecificOutput"
+HOOK_EVENT_NAME_KEY: str = "hookEventName"
+PERMISSION_DECISION_KEY: str = "permissionDecision"
+UPDATED_INPUT_KEY: str = "updatedInput"
+
+
+def write_pre_tool_use_allow_to_stdout(
+    all_updated_tool_input_fields: dict[str, object],
+) -> None:
+    """Write one PreToolUse allow payload carrying a rewritten tool input.
+
+    A rewriter writes its replacement input here and the Bash PreToolUse
+    dispatcher reads it back, carrying the updatedInput through to the harness.
+    Both ends of that hop share this one payload shape rather than each holding
+    a copy of it.
+
+    Args:
+        all_updated_tool_input_fields: The full tool_input the tool call should run with.
+    """
+    payload = {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            HOOK_EVENT_NAME_KEY: HOOK_EVENT_NAME,
+            PERMISSION_DECISION_KEY: ALLOW_DECISION,
+            UPDATED_INPUT_KEY: all_updated_tool_input_fields,
+        }
+    }
+    sys.stdout.write(json.dumps(payload))
+    sys.stdout.flush()

package/hooks/hooks_constants/subprocess_window.py

@@ -0,0 +1,141 @@
+"""Creation flags that keep a spawned child off the operator's screen on Windows.
+
+A hook or script often runs with no console of its own. When such a process
+starts a child on Windows, the operating system gives that child a brand new
+console, and the operator sees a black window flash open and shut while agents
+work. ``CREATE_NO_WINDOW`` tells Windows to skip that console. Every child this
+package spawns passes the flag, so the desktop stays quiet::
+
+    subprocess.run(
+        ["git", "status"],
+        creationflags=hidden_window_creation_flags(),
+    )
+
+On Windows that call returns ``0x08000000`` and no window appears. On Linux and
+macOS it returns ``0``, which is the value ``subprocess`` already uses when a
+caller passes no ``creationflags`` at all, so behaviour there is unchanged.
+``CREATE_NO_WINDOW`` is absent from a non-Windows Python build, so the lookup
+reads the attribute at call time and falls back to ``0``.
+
+``CREATE_NO_WINDOW`` gives the child a console of its own. A child that writes
+to a stream the caller redirected is unaffected, because the redirected handle
+travels with it. A child that inherits the caller's terminal instead loses that
+terminal, and the operator stops seeing its output. A few call sites hand their
+streams straight to the operator, and those pass
+``startupinfo=inherited_stream_startup_info()`` instead. That startup record
+keeps the inherited streams and hides the console window, so the operator still
+reads the output and still sees no window.
+
+``subprocess.STARTUPINFO`` is a Windows-only name. Typeshed declares it under a
+``sys.platform == "win32"`` guard, so a type check that runs on Linux, as this
+repository's continuous integration does, cannot see the name at all. The
+startup record is therefore described here as a structural ``Protocol`` naming
+the two fields this module sets, and the record itself is fetched through
+``getattr`` at call time. Both moves match what the module already does for the
+creation flags, and they keep the runtime ``sys.platform`` test in one place, so
+one function serves every platform.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from typing import Protocol
+
+from hooks_constants.subprocess_window_constants import (
+    CREATE_NEW_PROCESS_GROUP_ATTRIBUTE,
+    CREATE_NO_WINDOW_ATTRIBUTE,
+    HIDE_WINDOW_COMMAND_ATTRIBUTE,
+    NO_CREATION_FLAGS,
+    SHOW_WINDOW_FLAG_ATTRIBUTE,
+    STARTUP_INFO_ATTRIBUTE,
+    WINDOWS_PLATFORM,
+)
+
+__all__ = [
+    "HiddenWindowStartupInfo",
+    "detached_hidden_window_creation_flags",
+    "hidden_window_creation_flags",
+    "inherited_stream_startup_info",
+]
+
+
+class HiddenWindowStartupInfo(Protocol):
+    """The two ``subprocess.STARTUPINFO`` fields that hide a child's console."""
+
+    dwFlags: int
+    wShowWindow: int
+
+
+def _windows_flag(flag_attribute_name: str) -> int:
+    """Return one Windows creation flag, or zero on any other platform.
+
+    Args:
+        flag_attribute_name: The name of a ``subprocess`` creation-flag constant.
+
+    Returns:
+        The flag value on Windows, and zero elsewhere or when the running
+        Python build does not define that constant.
+    """
+    if sys.platform != WINDOWS_PLATFORM:
+        return NO_CREATION_FLAGS
+    return int(getattr(subprocess, flag_attribute_name, NO_CREATION_FLAGS))
+
+
+def hidden_window_creation_flags() -> int:
+    """Return the creation flags that start a child without a console window.
+
+    Pass the result as the ``creationflags`` argument of ``subprocess.run``,
+    ``subprocess.Popen``, ``subprocess.check_output``, or ``subprocess.call``::
+
+        subprocess.run(["git", "rev-parse", "HEAD"],
+                       creationflags=hidden_window_creation_flags())
+
+    Returns:
+        The hidden-console flag on Windows, and zero on every other platform.
+    """
+    return _windows_flag(CREATE_NO_WINDOW_ATTRIBUTE)
+
+
+def detached_hidden_window_creation_flags() -> int:
+    """Return the creation flags for a long-lived child that outlives its parent.
+
+    A detached poller needs its own process group so a console interrupt aimed
+    at the parent never reaches it, and it needs the hidden console for the same
+    reason every other child does::
+
+        subprocess.Popen(argv,
+                         creationflags=detached_hidden_window_creation_flags())
+
+    Returns:
+        A new process group combined with the hidden-console flag on Windows,
+        and zero on every other platform.
+    """
+    return _windows_flag(CREATE_NEW_PROCESS_GROUP_ATTRIBUTE) | hidden_window_creation_flags()
+
+
+def inherited_stream_startup_info() -> HiddenWindowStartupInfo | None:
+    """Return a startup record that hides the console of a stream-inheriting child.
+
+    Use this at a call site that lets the child write straight to the operator's
+    terminal, where ``hidden_window_creation_flags`` would take that terminal
+    away::
+
+        subprocess.run(["python", "-m", "pytest"],
+                       startupinfo=inherited_stream_startup_info())
+
+    Returns:
+        A Windows startup record asking for a hidden window, and ``None`` on
+        every other platform, which is the value ``subprocess`` already uses
+        when a caller passes no ``startupinfo`` at all.
+    """
+    if sys.platform != WINDOWS_PLATFORM:
+        return None
+    startup_information = getattr(subprocess, STARTUP_INFO_ATTRIBUTE)()
+    startup_information.dwFlags |= getattr(
+        subprocess, SHOW_WINDOW_FLAG_ATTRIBUTE, NO_CREATION_FLAGS
+    )
+    startup_information.wShowWindow = getattr(
+        subprocess, HIDE_WINDOW_COMMAND_ATTRIBUTE, NO_CREATION_FLAGS
+    )
+    return startup_information

package/hooks/hooks_constants/subprocess_window_constants.py

@@ -0,0 +1,9 @@
+"""Configuration constants for the shared hidden-console creation flags."""
+
+WINDOWS_PLATFORM: str = "win32"
+CREATE_NO_WINDOW_ATTRIBUTE: str = "CREATE_NO_WINDOW"
+CREATE_NEW_PROCESS_GROUP_ATTRIBUTE: str = "CREATE_NEW_PROCESS_GROUP"
+STARTUP_INFO_ATTRIBUTE: str = "STARTUPINFO"
+SHOW_WINDOW_FLAG_ATTRIBUTE: str = "STARTF_USESHOWWINDOW"
+HIDE_WINDOW_COMMAND_ATTRIBUTE: str = "SW_HIDE"
+NO_CREATION_FLAGS: int = 0

package/hooks/hooks_constants/test_bash_post_call_dispatcher_constants.py

@@ -7,22 +7,29 @@ from hooks_constants.bash_post_call_dispatcher_constants import (
 from hooks_constants.bash_pre_tool_use_dispatcher_constants import BASH_TOOL_NAME
 
 
-def test_roster_runs_the_recorder_then_the_pr_done_reminder() -> None:
+def test_roster_runs_the_recorder_then_the_pr_reminder_then_the_msys_advisor() -> None:
     all_script_paths = [
         each_entry.script_relative_path for each_entry in ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES
     ]
     assert all_script_paths == [
         "observability/test_failure_recorder.py",
         "advisory/pr_done_reminder.py",
+        "advisory/msys_path_conversion_advisor.py",
     ]
 
 
 def test_pr_done_reminder_also_serves_the_powershell_tool() -> None:
-    reminder_entry = ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES[-1]
+    reminder_entry = ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES[1]
     assert reminder_entry.script_relative_path == "advisory/pr_done_reminder.py"
     assert "PowerShell" in reminder_entry.applicable_tool_names
 
 
+def test_msys_advisor_serves_the_bash_tool_only() -> None:
+    advisor_entry = ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES[-1]
+    assert advisor_entry.script_relative_path == "advisory/msys_path_conversion_advisor.py"
+    assert advisor_entry.applicable_tool_names == frozenset({"Bash"})
+
+
 def test_context_forwarding_keys_match_the_hook_output_contract() -> None:
     assert constants.POST_TOOL_USE_HOOK_EVENT_NAME == "PostToolUse"
     assert constants.HOOK_SPECIFIC_OUTPUT_KEY == "hookSpecificOutput"

package/hooks/hooks_constants/test_bash_pre_tool_use_dispatcher_constants.py

@@ -7,7 +7,14 @@ ALL_CONSTANT_BINDINGS = run_path(
     str(Path(__file__).with_name("bash_pre_tool_use_dispatcher_constants.py"))
 )
 ALL_BASH_HOSTED_HOOK_ENTRIES = ALL_CONSTANT_BINDINGS["ALL_BASH_HOSTED_HOOK_ENTRIES"]
+ALL_BASH_ONLY_TOOL_NAMES = ALL_CONSTANT_BINDINGS["ALL_BASH_ONLY_TOOL_NAMES"]
+BashHostedHookEntry = ALL_CONSTANT_BINDINGS["BashHostedHookEntry"]
 
 
-def test_roster_has_no_blocking_hooks() -> None:
-    assert ALL_BASH_HOSTED_HOOK_ENTRIES == ()
+def test_roster_hosts_only_the_msys_rewriter_and_no_blocking_hook() -> None:
+    assert ALL_BASH_HOSTED_HOOK_ENTRIES == (
+        BashHostedHookEntry(
+            script_relative_path="blocking/msys_rev_path_rewriter.py",
+            applicable_tool_names=ALL_BASH_ONLY_TOOL_NAMES,
+        ),
+    )

package/hooks/hooks_constants/test_code_rules_enforcer_constants.py

@@ -17,6 +17,7 @@ if str(_HOOKS_ROOT) not in sys.path:
     sys.path.insert(0, str(_HOOKS_ROOT))
 
 from hooks_constants.code_rules_enforcer_constants import (
+    ALL_FREE_FORM_EXEMPT_COMMENT_BODIES,
     ALL_VALIDATION_PHASES,
     CONFIG_DIRECTORY_SEGMENT,
     CONSTANTS_MODULE_SUFFIX,
@@ -26,6 +27,7 @@ from hooks_constants.code_rules_enforcer_constants import (
     JSDOC_RETURNS_STRUCTURED_OBJECT_PROMISE_PATTERN,
     RETURN_CALL_OPENING_PARENTHESIS_PATTERN,
     SCHEMA_OPTIONS_PROPERTY_KEY_PATTERN,
+    STEALTH_KEEP_COMMENT_MARKER,
     UNKNOWN_VALIDATION_PHASE_MESSAGE_TEMPLATE,
     apply_edits,
     edits_for_tool,
@@ -106,6 +108,10 @@ def test_constants_module_suffix_and_config_directory_segment_are_defined() -> N
     assert CONFIG_DIRECTORY_SEGMENT == "config"
 
 
+def test_free_form_exempt_comment_bodies_include_stealth_keep_marker() -> None:
+    assert STEALTH_KEEP_COMMENT_MARKER in ALL_FREE_FORM_EXEMPT_COMMENT_BODIES
+
+
 def test_validation_phase_constants_are_reexported_and_render() -> None:
     assert ALL_VALIDATION_PHASES == {EDIT_LANE_PHASE, FULL_GATE_PHASE}
     rendered_message = UNKNOWN_VALIDATION_PHASE_MESSAGE_TEMPLATE.format(

package/hooks/hooks_constants/test_failure_recorder_constants.py

@@ -1,7 +1,7 @@
 """Constants for the failing-test-run PostToolUse recorder hook.
 
 Holds the cheap substring check the hook runs before any shell parsing, the
-harness's own exit-code error prefix, the chaining and redirection operator
+chaining and redirection operator
 tokens that keep the recognizer to one unchained command, the pytest program
 and Python interpreter basenames, and the flag-token marker the path
 extractor uses to skip an option rather than an existing test file argument.
@@ -20,7 +20,6 @@ import re
 BASH_TOOL_NAME = "Bash"
 
 ALL_PYTEST_MENTION_SUBSTRINGS: tuple[str, ...] = ("pytest", "py.test")
-EXIT_CODE_ERROR_PREFIX: str = "Error: Exit code "
 OPTION_TOKEN_PREFIX: str = "-"
 NODE_ID_FILE_PATH_SEPARATOR: str = "::"
 ALL_CHAINING_OPERATOR_SUBSTRINGS: tuple[str, ...] = ("&&", "||", ";", "|", "\n")

package/hooks/hooks_constants/test_post_tool_use_context.py

@@ -0,0 +1,22 @@
+"""Tests for the shared PostToolUse context emitter."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from hooks_constants.post_tool_use_context import write_post_tool_use_context_to_stdout
+
+
+def test_should_write_the_post_tool_use_payload_carrying_the_context_text(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    write_post_tool_use_context_to_stdout("=== PR DONE CHECKLIST ===")
+
+    assert json.loads(capsys.readouterr().out) == {
+        "hookSpecificOutput": {
+            "hookEventName": "PostToolUse",
+            "additionalContext": "=== PR DONE CHECKLIST ===",
+        }
+    }