claude-dev-env 1.95.0 → 2.0.1

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/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",