claude-dev-env 1.94.0 → 2.0.0

package/hooks/blocking/pii_prevention_blocker_parts/repository_exemption.py

@@ -0,0 +1,214 @@
+"""Per-repository PII-scan exemption and allowlist keyed on origin owner/repo.
+
+A commit's repository is exempt from the staged PII scan when its
+``remote.origin.url`` resolves to an ``owner/repo`` slug named in
+``CLAUDE_PII_EXEMPT_REPOS`` or the ``pii_exempt_repositories`` list in
+``~/.claude/local-identity.json``. A repository without a readable origin remote
+is never exempt (fail-closed to scanning). Exact values listed under
+``pii_allowlisted_values`` for the same slug may pass the scan in that
+repository only.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+from urllib.parse import urlparse
+
+try:
+    _blocking_directory = str(Path(__file__).resolve().parent.parent)
+    _hooks_directory = str(Path(__file__).resolve().parent.parent.parent)
+    for each_bootstrap_directory in (_blocking_directory, _hooks_directory):
+        if each_bootstrap_directory not in sys.path:
+            sys.path.insert(0, each_bootstrap_directory)
+    from hooks_constants.local_identity import (
+        pii_allowlisted_values_by_repository,
+        pii_exempt_repository_slugs,
+    )
+    from hooks_constants.pii_prevention_constants import (
+        ALL_GIT_ORIGIN_URL_COMMAND,
+        ALL_NETWORK_GIT_URL_SCHEMES,
+        GIT_COMMAND_TIMEOUT_SECONDS,
+        GIT_URL_SUFFIX,
+        GITHUB_COM_HOST,
+        MINIMUM_OWNER_REPO_SEGMENT_COUNT,
+        POSIX_PATH_SEPARATOR,
+        SCP_STYLE_PATH_SEPARATOR,
+        URL_SCHEME_SEPARATOR,
+        USERINFO_HOST_SEPARATOR,
+        WINDOWS_PATH_SEPARATOR,
+    )
+except ImportError as import_error:
+    raise ImportError(
+        "repository_exemption: cannot import its sibling constants; "
+        "ensure the blocking and hooks directories are importable."
+    ) from import_error
+
+
+def repository_allowlisted_values(repository_root: Path) -> frozenset[str]:
+    """Return the exact values the repository at *repository_root* may carry.
+
+    ::
+
+        origin slug in the allowlist mapping  ->  that repo's frozenset of values
+        no origin remote, or slug not mapped  ->  frozenset()
+
+    Args:
+        repository_root: Repository whose origin owner/repo slug keys the
+            per-repository PII allowlist.
+
+    Returns:
+        The exact literal values the repository's commits and writes may carry
+        past the PII scan, or an empty set when the repository has none.
+    """
+    origin_slug = _repository_origin_slug(repository_root)
+    if origin_slug is None:
+        return frozenset()
+    return pii_allowlisted_values_by_repository().get(origin_slug, frozenset())
+
+
+def _strip_trailing_path_separators(origin_url: str) -> str:
+    stripped_url = origin_url
+    while stripped_url and stripped_url[-1] in (
+        POSIX_PATH_SEPARATOR,
+        WINDOWS_PATH_SEPARATOR,
+    ):
+        stripped_url = stripped_url[:-1]
+    return stripped_url
+
+
+def _strip_trailing_git_suffix(origin_url: str) -> str:
+    if origin_url.lower().endswith(GIT_URL_SUFFIX):
+        return origin_url[: -len(GIT_URL_SUFFIX)]
+    return origin_url
+
+
+def _normalized_origin_url(origin_url: str) -> str:
+    return _strip_trailing_git_suffix(_strip_trailing_path_separators(origin_url))
+
+
+def _host_and_path_from_scheme_url(origin_url: str) -> tuple[str, str] | None:
+    parsed_url = urlparse(origin_url)
+    if parsed_url.scheme not in ALL_NETWORK_GIT_URL_SCHEMES:
+        return None
+    maybe_host = parsed_url.hostname
+    if maybe_host is None:
+        return None
+    try:
+        _ = parsed_url.port
+    except ValueError:
+        return None
+    repository_path = parsed_url.path.replace(WINDOWS_PATH_SEPARATOR, POSIX_PATH_SEPARATOR).lstrip(
+        POSIX_PATH_SEPARATOR
+    )
+    return maybe_host.lower(), repository_path
+
+
+def _host_and_path_from_scp_url(origin_url: str) -> tuple[str, str] | None:
+    if USERINFO_HOST_SEPARATOR not in origin_url:
+        return None
+    userinfo_and_host, separator, repository_path = origin_url.partition(SCP_STYLE_PATH_SEPARATOR)
+    if not separator or USERINFO_HOST_SEPARATOR not in userinfo_and_host:
+        return None
+    if not repository_path:
+        return None
+    host = userinfo_and_host.rsplit(USERINFO_HOST_SEPARATOR, maxsplit=1)[-1]
+    if not host:
+        return None
+    normalized_path = repository_path.replace(WINDOWS_PATH_SEPARATOR, POSIX_PATH_SEPARATOR)
+    return host.lower(), normalized_path
+
+
+def _host_and_repository_path_from_origin_url(
+    origin_url: str,
+) -> tuple[str, str] | None:
+    normalized_url = _normalized_origin_url(origin_url)
+    if URL_SCHEME_SEPARATOR in normalized_url:
+        return _host_and_path_from_scheme_url(normalized_url)
+    return _host_and_path_from_scp_url(normalized_url)
+
+
+def _owner_repo_slug_from_path(repository_path: str) -> str | None:
+    all_segments = [
+        each_segment for each_segment in repository_path.split(POSIX_PATH_SEPARATOR) if each_segment
+    ]
+    if len(all_segments) < MINIMUM_OWNER_REPO_SEGMENT_COUNT:
+        return None
+    owner_name = all_segments[0]
+    repository_name = all_segments[1]
+    return POSIX_PATH_SEPARATOR.join((owner_name, repository_name)).lower()
+
+
+def _owner_repo_slug_from_origin_url(origin_url: str) -> str | None:
+    """Return the lowercased owner/repo slug from a github.com origin URL.
+
+    ::
+
+        https://github.com/Owner/Repo.git    ->  owner/repo
+        https://github.com/Owner/Repo         ->  owner/repo
+        https://evil.test/Owner/Repo.git      ->  None
+
+    Accepts only the exact host ``github.com`` (case-insensitive), in https or
+    ssh form. Spoof hosts, unparseable port authorities, and path-shaped origins
+    return None so the repository is never exempt.
+
+    Args:
+        origin_url: The ``remote.origin.url`` value, https or ssh form.
+
+    Returns:
+        The ``owner/repo`` slug in lowercase, or None when the host is not
+        exactly ``github.com`` or the URL carries no owner/repo tail.
+    """
+    maybe_host_and_path = _host_and_repository_path_from_origin_url(origin_url)
+    if maybe_host_and_path is None:
+        return None
+    host, repository_path = maybe_host_and_path
+    if host != GITHUB_COM_HOST:
+        return None
+    return _owner_repo_slug_from_path(repository_path)
+
+
+def _repository_origin_slug(repository_root: Path) -> str | None:
+    """Return the lowercased owner/repo slug of the origin remote, or None.
+
+    Args:
+        repository_root: Repository whose origin remote identifies it.
+
+    Returns:
+        The ``owner/repo`` slug in lowercase, or None when the repository has no
+        readable origin remote or the URL carries no owner/repo tail.
+    """
+    try:
+        completed_process = subprocess.run(
+            list(ALL_GIT_ORIGIN_URL_COMMAND),
+            check=False, capture_output=True,
+            text=True,
+            timeout=GIT_COMMAND_TIMEOUT_SECONDS,
+            cwd=str(repository_root),
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return None
+    if completed_process.returncode != 0:
+        return None
+    return _owner_repo_slug_from_origin_url(completed_process.stdout.strip())
+
+
+def _is_repository_exempt_from_pii_scan(repository_root: Path) -> bool:
+    """Report whether commits in *repository_root* skip the staged PII scan.
+
+    Exempt repositories are named by owner/repo slug through
+    ``CLAUDE_PII_EXEMPT_REPOS`` or the ``pii_exempt_repositories`` list in the
+    git-ignored ``~/.claude/local-identity.json``. A repository without a readable
+    origin remote is never exempt (fail-closed to scanning).
+
+    Args:
+        repository_root: Repository whose index is about to be committed.
+
+    Returns:
+        True when the repository's origin slug is in the exempt set.
+    """
+    origin_slug = _repository_origin_slug(repository_root)
+    if origin_slug is None:
+        return False
+    return origin_slug in pii_exempt_repository_slugs()

package/hooks/blocking/pii_prevention_blocker_parts/repository_resolution.py

@@ -0,0 +1,208 @@
+"""Resolve the repository a git-commit command targets, not the session cwd.
+
+The gate must scan the repository the command names, so a commit that names a
+healthy repo is scanned even when the session working directory is gone::
+
+    git -C /a -C sub commit    ->  /a/sub   (each -C composes, like chdir)
+    git -C /a/b -C /c/d commit ->  /c/d     (a later absolute -C resets)
+    cd "/my repo" && git commit ->  /my repo (quoted cd path, shlex-parsed)
+    git commit                 ->  None      (falls back to the session cwd)
+
+The session working directory is used only when the command names no path, so a
+removed or invalid cwd never blocks a commit that targets a valid repo.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+try:
+    _blocking_directory = str(Path(__file__).resolve().parent.parent)
+    _hooks_directory = str(Path(__file__).resolve().parent.parent.parent)
+    for each_bootstrap_directory in (_blocking_directory, _hooks_directory):
+        if each_bootstrap_directory not in sys.path:
+            sys.path.insert(0, each_bootstrap_directory)
+    from pii_commit_command import (
+        _all_command_segments,
+        _segment_invokes_git_commit,
+        _skip_leading_noop_tokens,
+        _strip_token_edge_quotes,
+        _token_is_git_binary,
+    )
+    from pii_prevention_blocker_parts.config.repository_resolution_constants import (
+        ALL_DIRECTORY_CHANGE_COMMAND_NAMES,
+        ALL_DIRECTORY_CHANGE_PATH_OPTION_NAMES,
+        DIRECTORY_CHANGE_OPTION_TERMINATOR,
+        REPOSITORY_ROOT_UNRESOLVED_CWD_LABEL,
+        REPOSITORY_ROOT_UNRESOLVED_REASON_TEMPLATE,
+    )
+
+    from hooks_constants.pii_prevention_constants import (
+        ALL_VALUE_TAKING_GIT_OPTIONS,
+        GIT_OPTION_WITH_VALUE_STEP,
+        GIT_WORKING_DIRECTORY_OPTION,
+        SINGLE_DASH_OPTION_PREFIX,
+    )
+except ImportError as import_error:
+    raise ImportError(
+        "repository_resolution: cannot import its sibling helpers; "
+        "ensure the blocking and hooks directories are importable."
+    ) from import_error
+
+
+def _consume_token(
+    all_following_tokens: list[str], token_index: int, all_values: list[str]
+) -> int | None:
+    """Advance past one token, appending any ``-C`` value; None ends the walk."""
+    each_token = _strip_token_edge_quotes(all_following_tokens[token_index])
+    if each_token == GIT_WORKING_DIRECTORY_OPTION:
+        value_index = token_index + 1
+        if value_index >= len(all_following_tokens):
+            return None
+        all_values.append(_strip_token_edge_quotes(all_following_tokens[value_index]))
+        return value_index + 1
+    if each_token in ALL_VALUE_TAKING_GIT_OPTIONS:
+        return token_index + GIT_OPTION_WITH_VALUE_STEP
+    if each_token.startswith(SINGLE_DASH_OPTION_PREFIX):
+        return token_index + 1
+    return None
+
+
+def _collect_working_directory_values(all_following_tokens: list[str]) -> list[str]:
+    """Return every ``-C`` value, in order, from a commit segment's tokens."""
+    all_values: list[str] = []
+    token_index: int | None = 0
+    while token_index is not None and token_index < len(all_following_tokens):
+        token_index = _consume_token(all_following_tokens, token_index, all_values)
+    return all_values
+
+
+def _all_commit_working_directory_values(shell_command: str) -> list[str]:
+    """Return every ``-C`` value on the command's git-commit segment, in order."""
+    for each_segment in _all_command_segments(shell_command):
+        if not _segment_invokes_git_commit(each_segment):
+            continue
+        command_index = _skip_leading_noop_tokens(each_segment)
+        if command_index >= len(each_segment):
+            continue
+        if not _token_is_git_binary(each_segment[command_index]):
+            continue
+        return _collect_working_directory_values(each_segment[command_index + 1 :])
+    return []
+
+
+def _directory_change_target_from_segment(
+    all_segment_tokens: list[str],
+) -> str | None:
+    """Return the destination path of a ``cd``/``pushd`` segment, or None."""
+    command_index = _skip_leading_noop_tokens(all_segment_tokens)
+    if command_index >= len(all_segment_tokens):
+        return None
+    command_token = _strip_token_edge_quotes(
+        all_segment_tokens[command_index]
+    ).lower()
+    if command_token not in ALL_DIRECTORY_CHANGE_COMMAND_NAMES:
+        return None
+    token_index = command_index + 1
+    while token_index < len(all_segment_tokens):
+        each_token = _strip_token_edge_quotes(all_segment_tokens[token_index])
+        if each_token == DIRECTORY_CHANGE_OPTION_TERMINATOR:
+            token_index += 1
+            continue
+        if each_token.lower() in ALL_DIRECTORY_CHANGE_PATH_OPTION_NAMES:
+            token_index += 1
+            continue
+        return each_token
+    return None
+
+
+def _leading_directory_change_path(shell_command: str) -> str | None:
+    """Return the last ``cd``/``pushd`` path before the first git-commit segment.
+
+    Token-aware so ``git.exe`` (and other recognized git binary spellings) still
+    pick up a leading directory change, which the regex ``git commit`` fallback
+    misses.
+    """
+    last_changed_directory: str | None = None
+    for each_segment in _all_command_segments(shell_command):
+        if _segment_invokes_git_commit(each_segment):
+            return last_changed_directory
+        segment_directory = _directory_change_target_from_segment(each_segment)
+        if segment_directory is not None:
+            last_changed_directory = segment_directory
+    return None
+
+
+def _next_composed_directory(composed_directory: str | None, each_value: str) -> str:
+    """Apply one ``-C`` value to the running composition, like a chained chdir."""
+    if os.path.isabs(each_value):
+        return each_value
+    if composed_directory is None:
+        return each_value
+    return os.path.join(composed_directory, each_value)
+
+
+def _compose_working_directories(all_values: list[str]) -> str | None:
+    """Compose ordered ``-C`` values the way git applies them."""
+    composed_directory: str | None = None
+    for each_value in all_values:
+        composed_directory = _next_composed_directory(composed_directory, each_value)
+    return composed_directory
+
+
+def compose_command_working_directory(shell_command: str) -> str | None:
+    """Return the directory a git-commit command targets, or None for the cwd.
+
+    ::
+
+        git -C /a -C sub commit    ->  /a/sub
+        cd "/my repo" && git commit ->  /my repo
+        cd /repo && git.exe commit ->  /repo
+        git commit                 ->  None
+
+    Multiple ``-C`` values compose in order (a later absolute value resets); a
+    leading ``cd``/``pushd`` supplies the target when the command carries no
+    ``-C``.
+
+    Args:
+        shell_command: Bash or PowerShell tool command string.
+
+    Returns:
+        The composed target directory, or None when the command names none and
+        the commit runs in the session working directory.
+    """
+    all_values = _all_commit_working_directory_values(shell_command)
+    if all_values:
+        return _compose_working_directories(all_values)
+    return _leading_directory_change_path(shell_command)
+
+
+def expand_user_directory(directory: str | None) -> str | None:
+    """Expand a leading ``~`` in *directory*, passing None through unchanged.
+
+    Args:
+        directory: A directory path that may carry a leading ``~``, or None.
+
+    Returns:
+        The tilde-expanded path, or None when *directory* is None.
+    """
+    if directory is None:
+        return None
+    return os.path.expanduser(directory)
+
+
+def refusal_reason_for_unresolved_repository(attempted_directory: str | None) -> str:
+    """Return the deny reason naming the path whose repository root did not resolve.
+
+    Args:
+        attempted_directory: The directory the gate tried to resolve, or None
+            when it fell back to the session working directory.
+
+    Returns:
+        The deny reason text, naming the attempted path so the reader sees which
+        directory failed to resolve.
+    """
+    attempted_path = attempted_directory or REPOSITORY_ROOT_UNRESOLVED_CWD_LABEL
+    return REPOSITORY_ROOT_UNRESOLVED_REASON_TEMPLATE.format(attempted_path=attempted_path)

package/hooks/blocking/plain_language_blocker.py

@@ -26,10 +26,14 @@ from hooks_constants.plain_language_blocker_constants import (  # noqa: E402
     ALL_WRITE_EDIT_TOOL_NAMES,
     ASK_USER_QUESTION_TOOL_NAME,
     BLOCKQUOTE_LINE_PATTERN,
+    DOT_CLAUDE_DIRECTORY_NAME,
     FENCED_CODE_BLOCK_PATTERN,
     FILE_PATH_PATTERN,
     INLINE_CODE_PATTERN,
     MARKDOWN_EXTENSION,
+    PROJECT_ALLOWLIST_FILENAME,
+    PROJECT_ROOT_WALK_LIMIT,
+    REPOSITORY_MARKER_NAME,
     URL_PATTERN,
     USER_FACING_PLAIN_LANGUAGE_NOTICE,
 )
@@ -49,13 +53,23 @@ def strip_non_prose_regions(text: str) -> str:
     return without_paths
 
 
-def find_banned_terms(text: str) -> list[tuple[str, str]]:
+def find_banned_terms(
+    text: str, all_allowlisted_terms: frozenset[str] = frozenset()
+) -> list[tuple[str, str]]:
     """Return each (matched term, suggested replacement) found in the prose.
 
     Each term appears at most once, in first-seen order. Matching is
     case-insensitive and respects word boundaries; multi-word phrases match as
-    whole units. Terms in the software-term allowlist are exempt and never
-    flagged.
+    whole units. Terms in the software-term allowlist and terms in the
+    caller-supplied per-project allowlist are exempt and never flagged.
+
+    Args:
+        text: The prose to scan.
+        all_allowlisted_terms: Lowercased project-vocabulary terms to exempt, on top
+            of the built-in software-term allowlist.
+
+    Returns:
+        The (matched term, suggested replacement) pairs, in first-seen order.
     """
     prose_text = strip_non_prose_regions(text)
     all_matches: list[tuple[str, str]] = []
@@ -69,11 +83,128 @@ def find_banned_terms(text: str) -> list[tuple[str, str]]:
             continue
         if normalized_term in ALL_SOFTWARE_TERMS:
             continue
+        if normalized_term in all_allowlisted_terms:
+            continue
         seen_terms.add(normalized_term)
         all_matches.append((normalized_term, each_replacement))
     return all_matches
 
 
+def _allowlist_start_directory(
+    tool_name: str, tool_input: dict, payload_by_key: dict[str, object]
+) -> Path | None:
+    """Return the directory to begin the project-allowlist search from.
+
+    A Write/Edit/MultiEdit on a file starts at that file's parent directory; an
+    AskUserQuestion (or a write with no path) starts at the session working
+    directory the payload carries.
+
+    Args:
+        tool_name: The intercepted tool's name.
+        tool_input: The intercepted tool's input payload.
+        payload_by_key: The full PreToolUse payload carrying ``cwd``.
+
+    Returns:
+        The starting directory, or None when neither a file path nor a working
+        directory is available.
+    """
+    if tool_name in ALL_WRITE_EDIT_TOOL_NAMES:
+        file_path = tool_input.get("file_path", "")
+        if isinstance(file_path, str) and file_path:
+            return Path(file_path).parent
+    working_directory = payload_by_key.get("cwd", "")
+    if isinstance(working_directory, str) and working_directory:
+        return Path(working_directory)
+    return None
+
+
+def _find_project_allowlist_file(start_directory: Path) -> Path | None:
+    """Walk ancestors from start_directory for a repo-scoped project allowlist file.
+
+    ::
+
+        parent/                      .claude/allow  -> ignored (above the repo root)
+        parent/repo/     <- .git     .claude/allow  -> applied (repo root reached)
+        parent/repo/pkg/             .claude/allow  -> applied (inside the repo tree)
+
+    The allowlist must live inside the repository so it is reviewed like any
+    other committed config. The walk checks each directory for the allowlist,
+    then for the ``.git`` repository marker; it accepts an allowlist at or below
+    the first ``.git``-bearing directory, stops at that repository root, and
+    never ascends past it. When no ``.git`` marker appears within the walk
+    limit, the directory is not inside a repository and no allowlist applies, so
+    a global file such as ``~/.claude/plain-language-allow.json`` never loosens
+    the gate for every project.
+
+    Args:
+        start_directory: The directory to begin the upward walk from.
+
+    Returns:
+        The nearest in-repository ``.claude/plain-language-allow.json`` at or
+        below the repository root, or None when the walk finds no repository
+        root or no allowlist within it.
+    """
+    nearest_allowlist: Path | None = None
+    current_directory = start_directory
+    for _ in range(PROJECT_ROOT_WALK_LIMIT):
+        candidate = current_directory / DOT_CLAUDE_DIRECTORY_NAME / PROJECT_ALLOWLIST_FILENAME
+        if nearest_allowlist is None and candidate.is_file():
+            nearest_allowlist = candidate
+        if (current_directory / REPOSITORY_MARKER_NAME).exists():
+            return nearest_allowlist
+        if current_directory.parent == current_directory:
+            break
+        current_directory = current_directory.parent
+    return None
+
+
+def _parse_project_allowlist_file(allowlist_path: Path) -> frozenset[str]:
+    """Read a JSON array of allowlist words into a lowercased term set.
+
+    Malformed JSON, an unreadable file, or any non-list shape yields an empty
+    set, so the hook falls back to the standard check rather than crashing.
+
+    Args:
+        allowlist_path: The allowlist file to read.
+
+    Returns:
+        The lowercased string entries, or an empty set on any read/parse fault.
+    """
+    try:
+        raw_text = allowlist_path.read_text(encoding="utf-8")
+        parsed_entries = json.loads(raw_text)
+    except (OSError, ValueError):
+        return frozenset()
+    if not isinstance(parsed_entries, list):
+        return frozenset()
+    return frozenset(
+        each_entry.lower() for each_entry in parsed_entries if isinstance(each_entry, str)
+    )
+
+
+def _load_project_allowlist(
+    tool_name: str, tool_input: dict, payload_by_key: dict[str, object]
+) -> frozenset[str]:
+    """Load the per-project domain-vocabulary allowlist for the write's project.
+
+    Args:
+        tool_name: The intercepted tool's name.
+        tool_input: The intercepted tool's input payload.
+        payload_by_key: The full PreToolUse payload carrying ``cwd``.
+
+    Returns:
+        The lowercased allowlist terms for the project the write targets, or an
+        empty set when no allowlist applies.
+    """
+    start_directory = _allowlist_start_directory(tool_name, tool_input, payload_by_key)
+    if start_directory is None:
+        return frozenset()
+    allowlist_path = _find_project_allowlist_file(start_directory)
+    if allowlist_path is None:
+        return frozenset()
+    return _parse_project_allowlist_file(allowlist_path)
+
+
 def build_block_reason(all_matches: list[tuple[str, str]]) -> str:
     """Return a deny reason naming each flagged term and its plain replacement."""
     swap_phrases = ", ".join(
@@ -197,7 +328,10 @@ def evaluate(payload_by_key: dict[str, object]) -> str | None:
     if not prose_text:
         return None
 
-    all_matches = find_banned_terms(prose_text)
+    all_allowlisted_terms = _load_project_allowlist(
+        raw_tool_name, raw_tool_input, payload_by_key
+    )
+    all_matches = find_banned_terms(prose_text, all_allowlisted_terms)
     if not all_matches:
         return None
 

package/hooks/blocking/pr_description_command_parser.py

@@ -46,14 +46,18 @@ def _read_body_file_contents(file_path: str) -> str | None:
         resolved_target = given_path.resolve()
         try:
             resolved_target.relative_to(allowed_root)
-        except ValueError:
-            raise PathTraversalError("symlink target resolves outside allowed root")
+        except ValueError as traversal_error:
+            raise PathTraversalError(
+                "symlink target resolves outside allowed root"
+            ) from traversal_error
     resolved_path = given_path.resolve()
     if not given_path.is_absolute():
         try:
             resolved_path.relative_to(allowed_root)
-        except ValueError:
-            raise PathTraversalError("relative path resolves outside allowed root")
+        except ValueError as traversal_error:
+            raise PathTraversalError(
+                "relative path resolves outside allowed root"
+            ) from traversal_error
     try:
         with open(resolved_path, "r", encoding=UTF8_ENCODING, errors="replace") as body_file:
             return body_file.read()

package/hooks/blocking/precommit_code_rules_gate.py

@@ -72,7 +72,7 @@ def resolve_repository_root(working_directory: str | None) -> Path | None:
     try:
         completed_process = subprocess.run(
             list(ALL_GIT_REPOSITORY_ROOT_COMMAND),
-            capture_output=True,
+            check=False, capture_output=True,
             text=True,
             timeout=GIT_COMMAND_TIMEOUT_SECONDS,
             cwd=working_directory,
@@ -102,7 +102,7 @@ def list_staged_python_files(repository_root: Path) -> list[str]:
     try:
         completed_process = subprocess.run(
             list(ALL_STAGED_PYTHON_FILES_COMMAND),
-            capture_output=True,
+            check=False, capture_output=True,
             text=True,
             timeout=GIT_COMMAND_TIMEOUT_SECONDS,
             cwd=str(repository_root),
@@ -145,7 +145,7 @@ def run_staged_gate(repository_root: Path) -> tuple[int, str]:
                 str(repository_root),
                 "--staged",
             ],
-            capture_output=True,
+            check=False, capture_output=True,
             text=True,
             encoding="utf-8",
             errors="replace",