claude-dev-env 4.1.0 → 4.2.0

package/.agents/skills/everything-search/SKILL.md

@@ -13,13 +13,23 @@ Search files instantly on Windows using the Everything command-line interface (e
 
 ## Hard limits
 
-Every search carries a scope: a project path or registry token, an `ext:` filter, a `dm:` date filter, a `size:` filter, or a name pattern. A bare whole-drive scan or a network-share sweep is out of bounds — narrow the search to what you need.
+Every search carries a scope: a project path or registry token, an `ext:` filter, a `dm:` date filter, a `size:` filter, or a name pattern. A bare whole-drive scan or a network-share sweep is out of bounds. Narrow the search to what you need.
 
 When `es.exe` fails or returns nothing, self-heal first: fall back to the `Glob` tool (name and path patterns) or `Grep` (file contents), and report the outage so the reader knows the index was unavailable. When self-healing also fails, ask the user through `AskUserQuestion` with a short analysis and next-step options.
 
 ## Registry tokens
 
-The `es_exe_path_rewriter` hook resolves scope tokens before the command runs. A `{project-name}` placeholder or a bare registry key from `~/.claude/project-paths.json` becomes its quoted absolute path in the command. The hook allows and rewrites — it never blocks — so a search scoped to a registered project names the project token and lets the hook fill in the path.
+Run project-name searches through this command:
+
+```text
+python "${CLAUDE_SKILL_DIR}/scripts/everything_search.py" <project-name> <search arguments>
+```
+
+The command reads `~/.claude/project-paths.json`. An exact project name or `{project-name}` argument becomes one absolute path. Unknown names, absolute paths, flags, and spaces stay as they are. The command then starts `es.exe` without a shell.
+
+Put the search scope first. The first argument names a project, path, file, extension, date, or size. An options-only request exits before `es.exe` starts. Use `-version` alone to read the installed Everything version.
+
+Path and operator searches run when the registry file is missing. Malformed registry content, an empty search, a missing `es.exe`, or a process start failure returns a nonzero exit. After a successful start, the command returns the `es.exe` exit status.
 
 ## Instructions
 
@@ -131,7 +141,7 @@ Run separate searches for each extension type:
 
 - Everything must be running (system tray) for es.exe to work
 - Run one extension per search for cleaner results
-- Use `dm:` for recent file searches instead of manual date filtering
+- Use `dm:` to filter recent files by the index timestamp
 - Combine with path to narrow scope
 - Results return instantly regardless of drive size
 
@@ -152,3 +162,8 @@ Everything indexes REAL paths only, not junctions or mapped drives.
 **Common drive mappings:**
 - `Z:\Projects\` -> `Y:\Work\Projects\`
 - When in Z:\, translate to Y:\ equivalent for Everything searches
+
+## Files
+
+- `scripts/everything_search.py` runs one Everything search without a shell.
+- `scripts/test_everything_search.py` verifies registry expansion and command failures.

package/.agents/skills/everything-search/scripts/everything_search.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+from collections.abc import Mapping, Sequence
+from pathlib import Path, PurePosixPath, PureWindowsPath
+from typing import TextIO
+
+from everything_search_command_constants.config.constants import (
+    CLAUDE_DIRECTORY_NAME,
+    EXECUTABLE_NAME,
+    EXECUTION_ERROR_EXIT_CODE,
+    INFORMATIONAL_ARGUMENT,
+    INVALID_INPUT_EXIT_CODE,
+    PROJECT_PATHS_FILE_NAME,
+    REGISTRY_META_KEY,
+    SEARCH_SCOPE_REQUIRED_MESSAGE,
+    UTF8_ENCODING,
+)
+
+
+class RegistryRunFatal(ValueError):
+    """Stop the run when the project-path registry is unreadable or invalid."""
+
+
+def load_registry(registry_path: Path) -> dict[str, str]:
+    """Read project names and absolute paths from a registry file.
+
+    Args:
+        registry_path: Registry file to read.
+
+    Returns:
+        The registered paths keyed by project name.
+
+    Raises:
+        RegistryRunFatal: The file is unreadable or its content is invalid.
+    """
+    if not registry_path.is_file():
+        return {}
+    try:
+        all_registry_entries = json.loads(
+            registry_path.read_text(encoding=UTF8_ENCODING)
+        )
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise RegistryRunFatal(f"Malformed registry: {error}") from error
+    return _validated_registry_entries(all_registry_entries)
+
+
+def _validated_registry_entries(all_registry_entries: object) -> dict[str, str]:
+    if not isinstance(all_registry_entries, dict):
+        raise RegistryRunFatal("Invalid registry: expected an object")
+    all_registered_paths_by_name: dict[str, str] = {}
+    for each_registry_name, each_registered_path in all_registry_entries.items():
+        if each_registry_name == REGISTRY_META_KEY:
+            continue
+        if not isinstance(each_registry_name, str) or not isinstance(
+            each_registered_path, str
+        ):
+            raise RegistryRunFatal("Invalid registry: names and paths must be strings")
+        if not _is_absolute_path(each_registered_path):
+            raise RegistryRunFatal("Invalid registry: paths must be absolute")
+        all_registered_paths_by_name[each_registry_name] = each_registered_path
+    return all_registered_paths_by_name
+
+
+def _is_absolute_path(search_argument: str) -> bool:
+    try:
+        return (
+            PureWindowsPath(search_argument).is_absolute()
+            or PurePosixPath(search_argument).is_absolute()
+        )
+    except ValueError:
+        return False
+
+
+def _registry_name(search_argument: str) -> str:
+    if search_argument.startswith("{") and search_argument.endswith("}"):
+        return search_argument[1:-1]
+    return search_argument
+
+
+def expand_search_arguments(
+    all_search_arguments: Sequence[str],
+    all_registered_paths_by_name: Mapping[str, str],
+) -> list[str]:
+    """Return the registered path for an exact project name or `{project-name}` token.
+
+    Unknown names, absolute paths, flags, and spaces stay as their own arguments.
+
+    Args:
+        all_search_arguments: Everything search arguments.
+        all_registered_paths_by_name: Absolute paths keyed by project name.
+
+    Returns:
+        Arguments with exact project names as their registered paths.
+    """
+    all_expanded_arguments: list[str] = []
+    for each_search_argument in all_search_arguments:
+        registry_name = _registry_name(each_search_argument)
+        if (
+            not _is_absolute_path(each_search_argument)
+            and registry_name in all_registered_paths_by_name
+        ):
+            all_expanded_arguments.append(all_registered_paths_by_name[registry_name])
+        else:
+            all_expanded_arguments.append(each_search_argument)
+    return all_expanded_arguments
+
+
+def _run_search(
+    executable_path: str,
+    all_search_arguments: Sequence[str],
+    search_stdout: TextIO,
+    search_stderr: TextIO,
+) -> int:
+    try:
+        search_run = subprocess.run(
+            [executable_path, *all_search_arguments],
+            capture_output=True,
+            check=False,
+            encoding=UTF8_ENCODING,
+            shell=False,
+            text=True,
+        )
+    except OSError as error:
+        search_stderr.write(f"{error}\n")
+        return EXECUTION_ERROR_EXIT_CODE
+    search_stdout.write(search_run.stdout)
+    search_stderr.write(search_run.stderr)
+    return search_run.returncode
+
+
+def _run_registered_search(
+    all_search_arguments: Sequence[str],
+    registry_path: Path,
+    executable_path: str | None,
+    search_stdout: TextIO,
+    search_stderr: TextIO,
+) -> int:
+    try:
+        all_registered_paths_by_name = load_registry(registry_path)
+    except RegistryRunFatal as error:
+        search_stderr.write(f"{error}\n")
+        return INVALID_INPUT_EXIT_CODE
+    selected_executable_path = executable_path or shutil.which(EXECUTABLE_NAME)
+    if selected_executable_path is None:
+        search_stderr.write(f"{EXECUTABLE_NAME} was not found.\n")
+        return EXECUTION_ERROR_EXIT_CODE
+    all_expanded_arguments = expand_search_arguments(
+        all_search_arguments, all_registered_paths_by_name
+    )
+    return _run_search(
+        selected_executable_path,
+        all_expanded_arguments,
+        search_stdout,
+        search_stderr,
+    )
+
+
+def _has_search_scope(all_search_arguments: Sequence[str]) -> bool:
+    first_argument = all_search_arguments[0]
+    return bool(first_argument.strip()) and not first_argument.startswith("-")
+
+
+def _is_informational_operation(all_search_arguments: Sequence[str]) -> bool:
+    return (
+        len(all_search_arguments) == 1
+        and all_search_arguments[0].casefold() == INFORMATIONAL_ARGUMENT
+    )
+
+
+def main(all_search_arguments: Sequence[str]) -> int:
+    """Expand project names and run one Everything search.
+
+    Args:
+        all_search_arguments: Arguments passed to Everything.
+
+    Returns:
+        The Everything process exit status or a command error status.
+    """
+    if not all_search_arguments:
+        sys.stderr.write("At least one search argument is required.\n")
+        return INVALID_INPUT_EXIT_CODE
+    if not _has_search_scope(all_search_arguments) and not _is_informational_operation(
+        all_search_arguments
+    ):
+        sys.stderr.write(SEARCH_SCOPE_REQUIRED_MESSAGE)
+        return INVALID_INPUT_EXIT_CODE
+    selected_registry_path = (
+        Path.home() / CLAUDE_DIRECTORY_NAME / PROJECT_PATHS_FILE_NAME
+    )
+    return _run_registered_search(
+        all_search_arguments,
+        selected_registry_path,
+        None,
+        sys.stdout,
+        sys.stderr,
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/.agents/skills/everything-search/scripts/everything_search_command_constants/__init__.py

@@ -0,0 +1 @@
+"""Constants for the Everything search command."""

package/.agents/skills/everything-search/scripts/everything_search_command_constants/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration for the Everything search command."""

package/.agents/skills/everything-search/scripts/everything_search_command_constants/config/constants.py

@@ -0,0 +1,11 @@
+"""Configuration constants for the Everything search command."""
+
+CLAUDE_DIRECTORY_NAME = ".claude"
+EXECUTABLE_NAME = "es.exe"
+EXECUTION_ERROR_EXIT_CODE = 1
+INFORMATIONAL_ARGUMENT = "-version"
+INVALID_INPUT_EXIT_CODE = 2
+PROJECT_PATHS_FILE_NAME = "project-paths.json"
+REGISTRY_META_KEY = "_meta"
+SEARCH_SCOPE_REQUIRED_MESSAGE = "The first search argument must define a path, project, name, extension, date, or size scope.\n"
+UTF8_ENCODING = "utf-8"

package/.agents/skills/everything-search/scripts/test_everything_search.py

@@ -0,0 +1,172 @@
+import importlib
+import io
+import json
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+if str(SCRIPTS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIRECTORY))
+
+search = importlib.import_module("everything_search")
+
+KNOWN_PATH = "Y:\\Projects\\my-repo"
+REGISTRY = {"my-repo": KNOWN_PATH}
+
+
+def test_expand_search_arguments_rewrites_bare_registry_token() -> None:
+    assert search.expand_search_arguments(["my-repo", "config.py"], REGISTRY) == [
+        KNOWN_PATH,
+        "config.py",
+    ]
+
+
+def test_expand_search_arguments_rewrites_exact_placeholder_token() -> None:
+    assert search.expand_search_arguments(["{my-repo}", "config.py"], REGISTRY) == [
+        KNOWN_PATH,
+        "config.py",
+    ]
+
+
+def test_expand_search_arguments_preserves_unknown_tokens_and_spaces() -> None:
+    all_arguments = ["unknown-name", "foo bar", "config.py"]
+    assert search.expand_search_arguments(all_arguments, REGISTRY) == all_arguments
+
+
+@pytest.mark.parametrize(
+    "absolute_path",
+    [
+        "C:/Users/example/file.py",
+        "\\\\server\\share\\folder",
+        "/mnt/c/Projects/repo",
+    ],
+)
+def test_expand_search_arguments_preserves_absolute_paths(absolute_path: str) -> None:
+    assert search.expand_search_arguments([absolute_path], REGISTRY) == [absolute_path]
+
+
+def test_expand_search_arguments_preserves_embedded_flag_tokens() -> None:
+    all_arguments = ["--flag={my-repo}", "--regex=^{my-repo}$"]
+    assert search.expand_search_arguments(all_arguments, REGISTRY) == all_arguments
+
+
+def test_load_registry_returns_empty_mapping_for_missing_file(tmp_path: Path) -> None:
+    assert search.load_registry(tmp_path / "missing.json") == {}
+
+
+@pytest.mark.parametrize(
+    "registry_bytes",
+    [
+        b"\xff",
+        b"{not valid",
+        json.dumps({"my-repo": 42}).encode(),
+        json.dumps({"my-repo": ""}).encode(),
+        json.dumps({"my-repo": "relative/path"}).encode(),
+    ],
+)
+def test_load_registry_reports_invalid_input(
+    tmp_path: Path, registry_bytes: bytes
+) -> None:
+    registry_path = tmp_path / "project-paths.json"
+    registry_path.write_bytes(registry_bytes)
+    with pytest.raises(search.RegistryRunFatal, match="(Malformed|Invalid)"):
+        search.load_registry(registry_path)
+
+
+def test_main_runs_direct_search_without_registry_or_shell() -> None:
+    completed_process = search.subprocess.CompletedProcess(
+        args=["es.exe", "foo bar"],
+        returncode=0,
+        stdout="found path\n",
+        stderr="",
+    )
+    captured_stdout = io.StringIO()
+    with (
+        patch.object(search, "load_registry", return_value={}),
+        patch.object(search.shutil, "which", return_value="es.exe"),
+        patch.object(
+            search.subprocess, "run", return_value=completed_process
+        ) as run_process,
+        patch.object(search.sys, "stdout", captured_stdout),
+    ):
+        exit_code = search.main(["foo bar"])
+    assert exit_code == 0
+    assert captured_stdout.getvalue() == "found path\n"
+    run_process.assert_called_once_with(
+        ["es.exe", "foo bar"],
+        capture_output=True,
+        check=False,
+        encoding="utf-8",
+        shell=False,
+        text=True,
+    )
+
+
+def test_main_passes_through_child_exit_status() -> None:
+    completed_process = search.subprocess.CompletedProcess(
+        args=["es.exe", "config.py"], returncode=7, stdout="", stderr="failed\n"
+    )
+    captured_stderr = io.StringIO()
+    with (
+        patch.object(search, "load_registry", return_value={}),
+        patch.object(search.shutil, "which", return_value="es.exe"),
+        patch.object(search.subprocess, "run", return_value=completed_process),
+        patch.object(search.sys, "stderr", captured_stderr),
+    ):
+        exit_code = search.main(["config.py"])
+    assert exit_code == 7
+    assert captured_stderr.getvalue() == "failed\n"
+
+
+def test_main_reports_missing_executable() -> None:
+    captured_stderr = io.StringIO()
+    with (
+        patch.object(search, "load_registry", return_value={}),
+        patch.object(search.shutil, "which", return_value=None),
+        patch.object(search.sys, "stderr", captured_stderr),
+    ):
+        exit_code = search.main(["config.py"])
+    assert exit_code != 0
+    assert "es.exe" in captured_stderr.getvalue()
+
+
+def test_main_reports_empty_search_arguments() -> None:
+    captured_stderr = io.StringIO()
+    with patch.object(search.sys, "stderr", captured_stderr):
+        exit_code = search.main([])
+    assert exit_code == search.INVALID_INPUT_EXIT_CODE
+    assert "search argument" in captured_stderr.getvalue()
+
+
+@pytest.mark.parametrize("all_arguments", [["-n", "50"], [""], ["   "]])
+def test_main_rejects_unscoped_search_without_launching_child(
+    all_arguments: list[str],
+) -> None:
+    captured_stderr = io.StringIO()
+    with (
+        patch.object(search.subprocess, "run") as run_process,
+        patch.object(search.sys, "stderr", captured_stderr),
+    ):
+        exit_code = search.main(all_arguments)
+    assert exit_code == search.INVALID_INPUT_EXIT_CODE
+    assert "first search argument" in captured_stderr.getvalue().lower()
+    run_process.assert_not_called()
+
+
+def test_main_allows_version_information_operation() -> None:
+    completed_process = search.subprocess.CompletedProcess(
+        args=["es.exe", "-version"], returncode=0, stdout="1.1.0.30\n", stderr=""
+    )
+    with (
+        patch.object(search, "load_registry", return_value={}),
+        patch.object(search.shutil, "which", return_value="es.exe"),
+        patch.object(
+            search.subprocess, "run", return_value=completed_process
+        ) as run_process,
+    ):
+        exit_code = search.main(["-version"])
+    assert exit_code == 0
+    run_process.assert_called_once()

package/bin/install.prune.test.mjs

@@ -1054,6 +1054,65 @@ test('a full reinstall drops a retired hook script and its settings entry in one
     }
 });
 
+test('a full reinstall removes the retired Everything path rewriter and keeps a foreign hook neighbor', () => {
+    const sandbox = createSandbox();
+    try {
+        runInstaller(sandbox.homeDirectory, []);
+        const retiredHookPath = join(
+            sandbox.claudeDirectory,
+            HOOKS_DIRECTORY_NAME,
+            'blocking',
+            'es_exe_path_rewriter.py',
+        );
+        writeFileWithParents(retiredHookPath, 'a hook an earlier install wrote\n');
+        appendManifestFiles(sandbox.manifestPath, [retiredHookPath]);
+
+        const foreignHookPath = join(
+            sandbox.claudeDirectory,
+            HOOKS_DIRECTORY_NAME,
+            'blocking',
+            'foreign_search_hook.py',
+        );
+        const foreignHookBytes = Buffer.from('a user hook the installer never wrote\n');
+        writeFileWithParents(foreignHookPath, foreignHookBytes);
+
+        runInstaller(sandbox.homeDirectory, []);
+
+        const freshManifest = readManifest(sandbox.manifestPath);
+        const installedDispatcherConstantsPath = join(
+            sandbox.claudeDirectory,
+            HOOKS_DIRECTORY_NAME,
+            'hooks_constants',
+            'bash_pre_tool_use_dispatcher_constants.py',
+        );
+        assert.equal(existsSync(retiredHookPath), false, 'the retired search hook leaves the installed hooks');
+        assert.equal(
+            freshManifest.files.includes(retiredHookPath),
+            false,
+            'the fresh manifest drops the retired search hook',
+        );
+        assert.equal(
+            freshManifest.files.includes(foreignHookPath),
+            false,
+            'the fresh manifest does not claim the foreign hook',
+        );
+        assert.deepEqual(
+            readFileSync(foreignHookPath),
+            foreignHookBytes,
+            'the foreign hook keeps its original bytes',
+        );
+        assert.equal(
+            readFileSync(installedDispatcherConstantsPath, 'utf8').includes(
+                'es_exe_path_rewriter.py',
+            ),
+            false,
+            'the installed dispatcher constants omit the retired search hook',
+        );
+    } finally {
+        rmSync(sandbox.homeDirectory, { recursive: true, force: true });
+    }
+});
+
 test('a full reinstall removes a retired hook entry under an event type the current config leaves out', () => {
     const sandbox = createSandbox();
     try {

package/hooks/hooks_constants/bash_pre_tool_use_dispatcher_constants.py

@@ -35,7 +35,9 @@ BASH_TOOL_NAME = "Bash"
 POWERSHELL_TOOL_NAME = "PowerShell"
 
 ALL_BASH_ONLY_TOOL_NAMES: frozenset[str] = frozenset({BASH_TOOL_NAME})
-ALL_BASH_AND_POWERSHELL_TOOL_NAMES: frozenset[str] = frozenset({BASH_TOOL_NAME, POWERSHELL_TOOL_NAME})
+ALL_BASH_AND_POWERSHELL_TOOL_NAMES: frozenset[str] = frozenset(
+    {BASH_TOOL_NAME, POWERSHELL_TOOL_NAME}
+)
 
 
 @dataclass(frozen=True)
@@ -53,7 +55,6 @@ class BashHostedHookEntry:
 
 
 ALL_BASH_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = (
-    BashHostedHookEntry("blocking/es_exe_path_rewriter.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/destructive_command_blocker.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/gh_body_arg_blocker.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/shell_substitution_blocker.py", ALL_BASH_ONLY_TOOL_NAMES),
@@ -62,14 +63,10 @@ ALL_BASH_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = (
         "blocking/cursor_cli_python_misfire_blocker.py",
         ALL_BASH_AND_POWERSHELL_TOOL_NAMES,
     ),
-    BashHostedHookEntry(
-        "blocking/unscoped_search_blocker.py", ALL_BASH_AND_POWERSHELL_TOOL_NAMES
-    ),
+    BashHostedHookEntry("blocking/unscoped_search_blocker.py", ALL_BASH_AND_POWERSHELL_TOOL_NAMES),
     BashHostedHookEntry("blocking/nas_ssh_binary_enforcer.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/volatile_path_in_post_blocker.py", ALL_BASH_ONLY_TOOL_NAMES),
-    BashHostedHookEntry(
-        "blocking/pii_prevention_blocker.py", ALL_BASH_AND_POWERSHELL_TOOL_NAMES
-    ),
+    BashHostedHookEntry("blocking/pii_prevention_blocker.py", ALL_BASH_AND_POWERSHELL_TOOL_NAMES),
     BashHostedHookEntry("blocking/conventional_pr_title_gate.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/block_main_commit.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/session_edit_stage_gate.py", ALL_BASH_ONLY_TOOL_NAMES),

package/hooks/hooks_constants/test_bash_pre_tool_use_dispatcher_constants.py

@@ -7,22 +7,18 @@ registration order the standalone chain used.
 
 from __future__ import annotations
 
-import sys
 from pathlib import Path
+from runpy import run_path
 
-_HOOKS_DIR = str(Path(__file__).resolve().parent.parent)
-if _HOOKS_DIR not in sys.path:
-    sys.path.insert(0, _HOOKS_DIR)
-
-from hooks_constants.bash_pre_tool_use_dispatcher_constants import (  # noqa: E402
-    ALL_BASH_AND_POWERSHELL_TOOL_NAMES,
-    ALL_BASH_HOSTED_HOOK_ENTRIES,
-    BASH_TOOL_NAME,
-    POWERSHELL_TOOL_NAME,
+ALL_CONSTANT_BINDINGS = run_path(
+    str(Path(__file__).with_name("bash_pre_tool_use_dispatcher_constants.py"))
 )
+ALL_BASH_AND_POWERSHELL_TOOL_NAMES = ALL_CONSTANT_BINDINGS["ALL_BASH_AND_POWERSHELL_TOOL_NAMES"]
+ALL_BASH_HOSTED_HOOK_ENTRIES = ALL_CONSTANT_BINDINGS["ALL_BASH_HOSTED_HOOK_ENTRIES"]
+BASH_TOOL_NAME = ALL_CONSTANT_BINDINGS["BASH_TOOL_NAME"]
+POWERSHELL_TOOL_NAME = ALL_CONSTANT_BINDINGS["POWERSHELL_TOOL_NAME"]
 
 _EXPECTED_BASH_ORDER = (
-    "blocking/es_exe_path_rewriter.py",
     "blocking/destructive_command_blocker.py",
     "blocking/gh_body_arg_blocker.py",
     "blocking/shell_substitution_blocker.py",
@@ -80,8 +76,6 @@ def test_powershell_hooks_carry_the_shared_tool_set() -> None:
             assert each_entry.applicable_tool_names == ALL_BASH_AND_POWERSHELL_TOOL_NAMES
 
 
-
-
 def test_every_roster_path_points_at_an_existing_hook() -> None:
     """Each roster path names a hook script present on disk, catching a typo."""
     hooks_root = Path(__file__).resolve().parent.parent

package/package.json

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

package/rules/filesystem-search.md

@@ -1,6 +1,6 @@
 # Filesystem Search
 
-**When this applies:** Any search for files by name, path, extension, size, or date — through `es.exe`, a shell `find`, a recursive `Get-ChildItem` / `gci` / `dir` / `ls -R`, or the harness Grep and Glob tools.
+**When this applies:** Any search for files by name, path, extension, size, or date. That includes `es.exe`, a shell `find`, a recursive `Get-ChildItem` / `gci` / `dir` / `ls -R`, or the harness Grep and Glob tools.
 
 ## The scope invariant
 
@@ -14,7 +14,7 @@ Three tools are equally sanctioned; pick by what you know:
 
 | You know | Use |
 |---|---|
-| The exact path | `Read` — no search at all |
+| The exact path | `Read`. Do not search. |
 | A name, extension, or date, on Windows | `es.exe` with a path scope |
 | A name or path pattern | The harness `Glob` tool |
 | Text inside files | The harness `Grep` tool |
@@ -39,13 +39,13 @@ When `es.exe` fails or returns nothing, fall back to `Glob` or `Grep` without pa
 | Git Bash drive root | `find /c -name '*.py'` |
 | Windows drive root | `find C:\ -name foo` / `Get-ChildItem C:\ -Recurse` |
 | Bare home | `find ~ -name README.md` / `find $HOME -type f` |
-| Network share root | `find //server/share -name x` — a path under the share (`//server/share/project/src`) is allowed |
+| Network share root | `find //server/share -name x`. A path under the share (`//server/share/project/src`) is allowed |
 
 ## Shell batching
 
 Issue one shell search at a time when the walk is large. Parallel full-tree searches contend for the shell and can lock the host. Harness `Grep` and `Glob` calls carry no such cost and run in parallel freely.
 
-## Enforcement
+## Search controls
 
 - `unscoped_search_blocker` (PreToolUse on Bash and PowerShell, hosted by `bash_pre_tool_use_dispatcher`) denies a walk from an unscoped root and returns the scoped alternative.
-- `es_exe_path_rewriter` (PreToolUse on Bash) substitutes `{project-name}` placeholders and bare registry keys in an `es.exe` command with their quoted absolute paths, read from `~/.claude/project-paths.json`. It allows and rewrites; it never blocks, and a machine with no registry file passes the command through unchanged. `scripts/setup_project_paths.py` writes the registry.
+- For Everything searches that use a project name, run `python "${CLAUDE_SKILL_DIR}/scripts/everything_search.py" <project-name> <search arguments>`. An exact project name becomes its path from `~/.claude/project-paths.json`. The command then starts `es.exe` without a shell. `scripts/setup_project_paths.py` writes the registry.

package/hooks/blocking/es_exe_path_rewriter.py

@@ -1,159 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: rewrite es.exe commands by substituting registry tokens with absolute paths.
-
-Reads tool_input.command from stdin JSON. When the command invokes the Everything
-command-line binary, substitutes {project-name} placeholder tokens and bare registry-key
-tokens with their quoted absolute paths from ~/.claude/project-paths.json before
-the Bash call runs. Never blocks or denies — on any error exits 0 with empty output.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import re
-import sys
-from pathlib import Path, PurePosixPath, PureWindowsPath
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.dynamic_stderr_handler import DynamicStderrHandler  # noqa: E402
-from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin  # noqa: E402
-from hooks_constants.path_rewriter_constants import (  # noqa: E402
-    BASH_TOOL_NAME,
-    HOOK_EVENT_NAME,
-    PERMISSION_ALLOW,
-    PLACEHOLDER_TOKEN_PATTERN,
-)
-from hooks_constants.project_paths_reader import load_registry  # noqa: E402
-
-_ES_EXE_TRIGGER_PATTERN = re.compile(
-    r"(?i)(?<![\w.])(?:Everything[/\\])?es\.exe(?![\w.])",
-)
-
-
-_logger = logging.getLogger("es_exe_path_rewriter")
-if not _logger.handlers:
-    _stderr_handler = DynamicStderrHandler()
-    _stderr_handler.setFormatter(logging.Formatter("%(name)s: %(message)s"))
-    _logger.addHandler(_stderr_handler)
-    _logger.setLevel(logging.INFO)
-    _logger.propagate = False
-
-
-def command_invokes_es_exe(command: str) -> bool:
-    """Return True when the command string contains an es.exe invocation."""
-    return bool(_ES_EXE_TRIGGER_PATTERN.search(command))
-
-
-def _token_is_absolute_path(token: str) -> bool:
-    stripped = token.strip("\"'")
-    try:
-        return (
-            PureWindowsPath(stripped).is_absolute()
-            or PurePosixPath(stripped).is_absolute()
-        )
-    except (ValueError, TypeError):
-        return False
-
-
-def _quote_path(absolute_path: str) -> str:
-    return f'"{absolute_path}"'
-
-
-def _rewrite_placeholder_tokens(command_suffix: str, registry: dict[str, str]) -> str:
-    def replace_placeholder(match: re.Match) -> str:
-        inner_name = match.group(1)
-        if inner_name not in registry:
-            return match.group(0)
-        return _quote_path(registry[inner_name])
-
-    return PLACEHOLDER_TOKEN_PATTERN.sub(replace_placeholder, command_suffix)
-
-
-def _split_on_es_exe(command: str) -> tuple[str, str]:
-    match = _ES_EXE_TRIGGER_PATTERN.search(command)
-    if not match:
-        return command, ""
-    return command[: match.end()], command[match.end() :]
-
-
-def _strip_matching_outer_quotes(token: str) -> tuple[str, bool]:
-    """Return (inner_text, was_quoted) after removing matched outer quotes."""
-    if len(token) > 1 and token[0] in ('"', "'") and token[-1] == token[0]:
-        return token[1:-1], True
-    return token, False
-
-
-def _rewrite_bare_tokens(command_suffix: str, registry: dict[str, str]) -> str:
-    all_raw_parts = re.split(r"(\s+)", command_suffix)
-    all_rewritten_parts: list[str] = []
-    for each_raw_part in all_raw_parts:
-        if not each_raw_part or each_raw_part.isspace():
-            all_rewritten_parts.append(each_raw_part)
-            continue
-        unquoted_text, _was_quoted = _strip_matching_outer_quotes(each_raw_part)
-        if unquoted_text in registry and not _token_is_absolute_path(unquoted_text):
-            all_rewritten_parts.append(_quote_path(registry[unquoted_text]))
-        else:
-            all_rewritten_parts.append(each_raw_part)
-    return "".join(all_rewritten_parts)
-
-
-def rewrite_command(command: str, registry: dict[str, str]) -> str:
-    """Apply registry substitutions to any es.exe argument tokens.
-
-    Applies placeholder form {name} first, then bare-token form.
-    Absolute-path arguments and unknown tokens are left untouched.
-    Returns the original command when no substitution applies.
-    """
-    if not registry:
-        return command
-    prefix, suffix = _split_on_es_exe(command)
-    rewritten_suffix = _rewrite_placeholder_tokens(suffix, registry)
-    rewritten_suffix = _rewrite_bare_tokens(rewritten_suffix, registry)
-    return prefix + rewritten_suffix
-
-
-def _build_allow_response(rewritten_command: str, original_tool_input: dict) -> dict:
-    updated_input = {**original_tool_input, "command": rewritten_command}
-    return {
-        "hookSpecificOutput": {
-            "hookEventName": HOOK_EVENT_NAME,
-            "permissionDecision": PERMISSION_ALLOW,
-            "updatedInput": updated_input,
-        }
-    }
-
-
-def main() -> None:
-    try:
-        hook_input = read_hook_input_dictionary_from_stdin()
-        if hook_input is None:
-            sys.exit(0)
-        raw_tool_name = hook_input.get("tool_name", "")
-        raw_tool_input = hook_input.get("tool_input", {})
-        tool_name = raw_tool_name if isinstance(raw_tool_name, str) else ""
-        tool_input = raw_tool_input if isinstance(raw_tool_input, dict) else {}
-        if tool_name != BASH_TOOL_NAME:
-            sys.exit(0)
-        raw_command = tool_input.get("command", "")
-        command = raw_command if isinstance(raw_command, str) else ""
-        if not command_invokes_es_exe(command):
-            sys.exit(0)
-        known_registry = load_registry()
-        if not known_registry:
-            sys.exit(0)
-        rewritten_command = rewrite_command(command, known_registry)
-        if rewritten_command == command:
-            sys.exit(0)
-        print(json.dumps(_build_allow_response(rewritten_command, tool_input)))
-    except Exception as e:
-        _logger.error("%s", e)
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/test_es_exe_path_rewriter.py

@@ -1,447 +0,0 @@
-"""Tests for es_exe_path_rewriter — PreToolUse hook that rewrites es.exe paths."""
-
-import json
-import sys
-from io import StringIO
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-
-_BLOCKING_DIR = Path(__file__).resolve().parent
-_HOOKS_ROOT = _BLOCKING_DIR.parent
-for each_sys_path_entry in (str(_BLOCKING_DIR), str(_HOOKS_ROOT)):
-    if each_sys_path_entry not in sys.path:
-        sys.path.insert(0, each_sys_path_entry)
-
-import es_exe_path_rewriter as rewriter
-
-
-def test_rewriter_does_not_redefine_dynamic_stderr_handler_locally() -> None:
-    """Pin PR #230 round 3 DRY fix: handler is imported from the shared module.
-
-    Both project_paths_reader and es_exe_path_rewriter previously defined
-    identical `_DynamicStderrHandler` classes. This test fails if the
-    duplicate class reappears in es_exe_path_rewriter.
-    """
-    assert not hasattr(rewriter, "_DynamicStderrHandler")
-
-
-REGISTRY_WITH_ONE_REPO = {"my-repo": "Y:\\Projects\\my-repo"}
-REGISTRY_WITH_TWO_REPOS = {
-    "my-repo": "Y:\\Projects\\my-repo",
-    "other-repo": "C:\\Dev\\other-repo",
-}
-ABSOLUTE_PATH_ARGUMENT = "Y:\\Projects\\already-absolute\\file.py"
-KNOWN_REPO_NAME = "my-repo"
-KNOWN_REPO_PATH = "Y:\\Projects\\my-repo"
-OTHER_REPO_NAME = "other-repo"
-OTHER_REPO_PATH = "C:\\Dev\\other-repo"
-
-
-def _run_main_with_stdin_text(stdin_text: str) -> tuple[str, str, int]:
-    """Return (stdout, stderr, exit_code) from running main() with the given stdin text."""
-    captured_stdout = StringIO()
-    captured_stderr = StringIO()
-    exit_code = 0
-    try:
-        with (
-            patch("sys.stdin", StringIO(stdin_text)),
-            patch("sys.stdout", captured_stdout),
-            patch("sys.stderr", captured_stderr),
-        ):
-            rewriter.main()
-    except SystemExit as e:
-        exit_code = e.code or 0
-    return captured_stdout.getvalue(), captured_stderr.getvalue(), exit_code
-
-
-def _run_main_with_input(hook_input: dict) -> tuple[str, str, int]:
-    """Return (stdout, stderr, exit_code) from running main() with the given hook input."""
-    return _run_main_with_stdin_text(json.dumps(hook_input))
-
-
-def _make_bash_input(command: str, description: str = "search files") -> dict:
-    return {
-        "tool_name": "Bash",
-        "tool_input": {"command": command, "description": description},
-    }
-
-
-class TestTriggerRegex:
-    def test_matches_bare_es_exe(self) -> None:
-        assert rewriter.command_invokes_es_exe("es.exe my-repo")
-
-    def test_matches_everything_forward_slash_path(self) -> None:
-        assert rewriter.command_invokes_es_exe("Everything/es.exe my-repo")
-
-    def test_matches_everything_backslash_path(self) -> None:
-        assert rewriter.command_invokes_es_exe("Everything\\es.exe my-repo")
-
-    def test_does_not_match_unrelated_command(self) -> None:
-        assert not rewriter.command_invokes_es_exe("git status")
-
-    def test_does_not_match_es_exe_inside_longer_word(self) -> None:
-        assert not rewriter.command_invokes_es_exe("not_es.exe_here")
-
-    def test_matches_case_insensitively(self) -> None:
-        assert rewriter.command_invokes_es_exe("ES.EXE my-repo")
-
-
-class TestRewriteCommand:
-    def test_bare_token_rewrite_substitutes_registry_path(self) -> None:
-        rewritten = rewriter.rewrite_command(
-            "es.exe my-repo config.py", REGISTRY_WITH_ONE_REPO
-        )
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}" config.py'
-
-    def test_placeholder_token_rewrite_substitutes_registry_path(self) -> None:
-        rewritten = rewriter.rewrite_command(
-            'es.exe "{my-repo}" config.py', REGISTRY_WITH_ONE_REPO
-        )
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}" config.py'
-
-    def test_single_quoted_placeholder_rewrite_substitutes_registry_path(self) -> None:
-        rewritten = rewriter.rewrite_command(
-            "es.exe '{my-repo}' config.py", REGISTRY_WITH_ONE_REPO
-        )
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}" config.py'
-
-    def test_placeholder_without_quotes_rewrite_substitutes_registry_path(self) -> None:
-        rewritten = rewriter.rewrite_command(
-            "es.exe {my-repo} config.py", REGISTRY_WITH_ONE_REPO
-        )
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}" config.py'
-
-    def test_absolute_path_argument_is_never_modified(self) -> None:
-        command = f'es.exe "{ABSOLUTE_PATH_ARGUMENT}" config.py'
-        rewritten = rewriter.rewrite_command(command, REGISTRY_WITH_ONE_REPO)
-        assert rewritten == command
-
-    def test_unknown_token_is_never_touched(self) -> None:
-        command = "es.exe unknown-name config.py"
-        rewritten = rewriter.rewrite_command(command, REGISTRY_WITH_ONE_REPO)
-        assert rewritten == command
-
-    def test_multiple_tokens_all_rewrite(self) -> None:
-        command = "es.exe my-repo other-repo config.py"
-        rewritten = rewriter.rewrite_command(command, REGISTRY_WITH_TWO_REPOS)
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}" "{OTHER_REPO_PATH}" config.py'
-
-    def test_empty_registry_returns_unchanged_command(self) -> None:
-        command = "es.exe my-repo config.py"
-        rewritten = rewriter.rewrite_command(command, {})
-        assert rewritten == command
-
-    def test_double_spaces_inside_quoted_arg_pass_through_unchanged_on_no_registry_hit(
-        self,
-    ) -> None:
-        command = 'es.exe "foo  bar" baz'
-        rewritten = rewriter.rewrite_command(command, REGISTRY_WITH_ONE_REPO)
-        assert rewritten == command
-
-    def test_tab_separator_is_preserved_when_bare_token_is_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe my-repo\tconfig.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo"\tconfig.py'
-
-    def test_multiple_substitutions_preserve_all_inter_token_whitespace(self) -> None:
-        command = "es.exe my-repo  other-repo   config.py"
-        rewritten = rewriter.rewrite_command(command, REGISTRY_WITH_TWO_REPOS)
-        assert rewritten == f'es.exe "{KNOWN_REPO_PATH}"  "{OTHER_REPO_PATH}"   config.py'
-
-
-class TestEmittedJsonShape:
-    def test_emitted_json_has_correct_hook_event_name(self) -> None:
-        hook_input = _make_bash_input(f"es.exe {KNOWN_REPO_NAME} config.py")
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        emitted = json.loads(stdout)
-        assert emitted["hookSpecificOutput"]["hookEventName"] == "PreToolUse"
-
-    def test_emitted_json_has_allow_permission_decision(self) -> None:
-        hook_input = _make_bash_input(f"es.exe {KNOWN_REPO_NAME} config.py")
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        emitted = json.loads(stdout)
-        assert emitted["hookSpecificOutput"]["permissionDecision"] == "allow"
-
-    def test_emitted_json_has_rewritten_command(self) -> None:
-        hook_input = _make_bash_input(f"es.exe {KNOWN_REPO_NAME} config.py")
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        emitted = json.loads(stdout)
-        updated_command = emitted["hookSpecificOutput"]["updatedInput"]["command"]
-        assert updated_command == f'es.exe "{KNOWN_REPO_PATH}" config.py'
-
-    def test_description_field_round_trips_unchanged(self) -> None:
-        original_description = "my special search description"
-        hook_input = _make_bash_input(
-            f"es.exe {KNOWN_REPO_NAME} config.py", original_description
-        )
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        emitted = json.loads(stdout)
-        assert (
-            emitted["hookSpecificOutput"]["updatedInput"]["description"]
-            == original_description
-        )
-
-    def test_additional_unknown_fields_pass_through_into_updated_input(self) -> None:
-        hook_input = {
-            "tool_name": "Bash",
-            "tool_input": {
-                "command": f"es.exe {KNOWN_REPO_NAME} config.py",
-                "description": "search",
-                "extra_field": "extra_value",
-            },
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        emitted = json.loads(stdout)
-        assert (
-            emitted["hookSpecificOutput"]["updatedInput"]["extra_field"]
-            == "extra_value"
-        )
-
-    def test_no_code_path_returns_deny_decision(self) -> None:
-        for command in [
-            f"es.exe {KNOWN_REPO_NAME} config.py",
-            "es.exe unknown-token config.py",
-            "git status",
-        ]:
-            hook_input = _make_bash_input(command)
-            with patch(
-                "es_exe_path_rewriter.load_registry",
-                return_value=REGISTRY_WITH_ONE_REPO,
-            ):
-                stdout, _, _ = _run_main_with_input(hook_input)
-            if stdout.strip():
-                emitted = json.loads(stdout)
-                decision = emitted.get("hookSpecificOutput", {}).get(
-                    "permissionDecision", ""
-                )
-                assert decision != "deny", f"deny returned for command: {command!r}"
-
-
-class TestStdinParsingRobustness:
-    def test_empty_stdin_exits_zero_without_stdout_or_stderr(self) -> None:
-        stdout, stderr, exit_code = _run_main_with_stdin_text("")
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-    def test_whitespace_only_stdin_exits_zero_without_stdout_or_stderr(self) -> None:
-        stdout, stderr, exit_code = _run_main_with_stdin_text("  \n\t ")
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-    def test_invalid_json_stdin_exits_zero_without_stdout_or_stderr(self) -> None:
-        stdout, stderr, exit_code = _run_main_with_stdin_text("{not valid")
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-
-class TestMalformedHookPayloadTypes:
-    def test_null_tool_input_exits_zero_without_stdout_or_stderr(self) -> None:
-        hook_input = {
-            "tool_name": "Bash",
-            "tool_input": None,
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, stderr, exit_code = _run_main_with_input(hook_input)
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-    def test_list_tool_input_exits_zero_without_stdout_or_stderr(self) -> None:
-        hook_input = {
-            "tool_name": "Bash",
-            "tool_input": ["es.exe", KNOWN_REPO_NAME],
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, stderr, exit_code = _run_main_with_input(hook_input)
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-    def test_string_tool_input_exits_zero_without_stdout_or_stderr(self) -> None:
-        hook_input = {
-            "tool_name": "Bash",
-            "tool_input": f"es.exe {KNOWN_REPO_NAME}",
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, stderr, exit_code = _run_main_with_input(hook_input)
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-    def test_non_string_command_exits_zero_without_stdout_or_stderr(self) -> None:
-        hook_input = {
-            "tool_name": "Bash",
-            "tool_input": {"command": 12345, "description": "search"},
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, stderr, exit_code = _run_main_with_input(hook_input)
-        assert exit_code == 0
-        assert stdout.strip() == ""
-        assert stderr.strip() == ""
-
-
-class TestNoOutputCases:
-    def test_non_es_exe_command_produces_no_output(self) -> None:
-        hook_input = _make_bash_input("git status")
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        assert stdout.strip() == ""
-
-    def test_empty_registry_produces_no_output(self) -> None:
-        hook_input = _make_bash_input(f"es.exe {KNOWN_REPO_NAME} config.py")
-        with patch("es_exe_path_rewriter.load_registry", return_value={}):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        assert stdout.strip() == ""
-
-    def test_unchanged_command_produces_no_output(self) -> None:
-        hook_input = _make_bash_input("es.exe unknown-token config.py")
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        assert stdout.strip() == ""
-
-    def test_malformed_registry_produces_no_output_and_one_stderr_line(self) -> None:
-        hook_input = _make_bash_input(f"es.exe {KNOWN_REPO_NAME} config.py")
-        with patch(
-            "es_exe_path_rewriter.load_registry",
-            side_effect=Exception("simulated read error"),
-        ):
-            stdout, stderr, _ = _run_main_with_input(hook_input)
-        assert stdout.strip() == ""
-        assert stderr.strip() != ""
-        assert stderr.strip().count("\n") == 0
-
-    def test_non_bash_tool_produces_no_output(self) -> None:
-        hook_input = {
-            "tool_name": "Write",
-            "tool_input": {"command": f"es.exe {KNOWN_REPO_NAME}"},
-        }
-        with patch(
-            "es_exe_path_rewriter.load_registry", return_value=REGISTRY_WITH_ONE_REPO
-        ):
-            stdout, _, _ = _run_main_with_input(hook_input)
-        assert stdout.strip() == ""
-
-
-class TestQuoteAwareTokenizer:
-    def test_double_quoted_multiword_arg_with_registry_key_prefix_is_not_substituted(
-        self,
-    ) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = 'es.exe "my-repo foo" baz'
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == command
-
-    def test_single_quoted_multiword_arg_with_registry_key_prefix_is_not_substituted(
-        self,
-    ) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe 'my-repo baz' config.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == command
-
-    def test_bare_token_matching_registry_key_is_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe my-repo config.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo" config.py'
-
-    def test_whitespace_between_bare_tokens_is_preserved_after_rewrite(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo", "other-repo": "C:\\Dev\\other"}
-        command = "es.exe my-repo  other-repo   config.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo"  "C:\\Dev\\other"   config.py'
-
-    def test_tab_separator_is_preserved_when_bare_token_is_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe my-repo\tconfig.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo"\tconfig.py'
-
-
-class TestQuotedSingleWordRewrite:
-    def test_double_quoted_single_word_registry_key_is_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = 'es.exe "my-repo" config.py'
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo" config.py'
-
-    def test_single_quoted_single_word_registry_key_is_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe 'my-repo' config.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo" config.py'
-
-
-class TestPlaceholderBoundaryEnforcement:
-    def test_placeholder_inside_flag_argument_is_not_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe --regex=^{my-repo}$"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == command
-
-    def test_placeholder_embedded_in_token_is_not_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe foo{my-repo}bar"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == command
-
-    def test_standalone_placeholder_is_still_rewritten(self) -> None:
-        registry = {"my-repo": "Y:\\Projects\\my-repo"}
-        command = "es.exe {my-repo} config.py"
-        rewritten = rewriter.rewrite_command(command, registry)
-        assert rewritten == f'es.exe "Y:\\Projects\\my-repo" config.py'
-
-
-class TestAbsolutePathDetection:
-    def test_windows_drive_letter_path_detected_as_absolute(self) -> None:
-        assert rewriter._token_is_absolute_path("C:\\Users\\x")
-
-    def test_windows_drive_letter_path_with_forward_slashes_detected_as_absolute(
-        self,
-    ) -> None:
-        assert rewriter._token_is_absolute_path("Y:/Projects/foo")
-
-    def test_unc_path_detected_as_absolute(self) -> None:
-        assert rewriter._token_is_absolute_path("\\\\server\\share\\path")
-
-    def test_posix_absolute_path_detected_as_absolute(self) -> None:
-        assert rewriter._token_is_absolute_path("/etc/hosts")
-
-    def test_relative_path_not_detected_as_absolute(self) -> None:
-        assert not rewriter._token_is_absolute_path("./foo")
-
-    def test_bare_registry_token_not_detected_as_absolute(self) -> None:
-        assert not rewriter._token_is_absolute_path("my-repo")

package/hooks/hooks_constants/path_rewriter_constants.py

@@ -1,13 +0,0 @@
-"""Configuration constants for the es_exe_path_rewriter PreToolUse hook."""
-
-import re
-
-BASH_TOOL_NAME = "Bash"
-
-HOOK_EVENT_NAME = "PreToolUse"
-
-PERMISSION_ALLOW = "allow"
-
-PLACEHOLDER_TOKEN_PATTERN = re.compile(
-    r"""(?:(?<=\s)|^)['"]?(?<!\$)\{([^}]+)\}['"]?(?=\s|$)""",
-)

package/hooks/hooks_constants/test_path_rewriter_constants.py

@@ -1,57 +0,0 @@
-"""Pin tests for path_rewriter_constants — values consumed by es_exe_path_rewriter."""
-
-import sys
-from pathlib import Path
-
-_HOOKS_ROOT = Path(__file__).resolve().parent.parent
-if str(_HOOKS_ROOT) not in sys.path:
-    sys.path.insert(0, str(_HOOKS_ROOT))
-
-from hooks_constants.path_rewriter_constants import (
-    BASH_TOOL_NAME,
-    HOOK_EVENT_NAME,
-    PERMISSION_ALLOW,
-    PLACEHOLDER_TOKEN_PATTERN,
-)
-
-
-def test_bash_tool_name_is_bash() -> None:
-    assert BASH_TOOL_NAME == "Bash"
-
-
-def test_hook_event_name_is_pre_tool_use() -> None:
-    assert HOOK_EVENT_NAME == "PreToolUse"
-
-
-def test_permission_allow_is_allow() -> None:
-    assert PERMISSION_ALLOW == "allow"
-
-
-def test_placeholder_token_pattern_matches_curly_brace_form() -> None:
-    match = PLACEHOLDER_TOKEN_PATTERN.match("{my-repo}")
-    assert match is not None
-    assert match.group(1) == "my-repo"
-
-
-def test_placeholder_token_pattern_matches_double_quoted_form() -> None:
-    match = PLACEHOLDER_TOKEN_PATTERN.match('"{my-repo}"')
-    assert match is not None
-    assert match.group(1) == "my-repo"
-
-
-def test_placeholder_token_pattern_matches_single_quoted_form() -> None:
-    match = PLACEHOLDER_TOKEN_PATTERN.match("'{my-repo}'")
-    assert match is not None
-    assert match.group(1) == "my-repo"
-
-
-def test_placeholder_token_pattern_does_not_match_shell_parameter_expansion() -> None:
-    assert PLACEHOLDER_TOKEN_PATTERN.search("${myrepo}") is None
-
-
-def test_placeholder_token_pattern_does_not_match_embedded_in_flag() -> None:
-    assert PLACEHOLDER_TOKEN_PATTERN.search("--flag={my-repo}") is None
-
-
-def test_placeholder_token_pattern_does_not_match_embedded_in_token() -> None:
-    assert PLACEHOLDER_TOKEN_PATTERN.search("foo{my-repo}bar") is None