ai-push-hooks 0.3.1 → 0.3.2

package/src/ai_push_hooks/executors/step_commands.py

@@ -79,7 +79,10 @@ class StepCommandResult:
             raise TypeError("step command returncode must be an integer")
         if not isinstance(self.stdout, bytes) or not isinstance(self.stderr, bytes):
             raise TypeError("step command streams must be bytes")
-        if type(self.stdout_truncated) is not bool or type(self.stderr_truncated) is not bool:
+        if (
+            type(self.stdout_truncated) is not bool
+            or type(self.stderr_truncated) is not bool
+        ):
             raise TypeError("step command truncation flags must be booleans")
 
     def __repr__(self) -> str:
@@ -118,18 +121,24 @@ def _validated_inputs(
     if inputs is None:
         return {}
     if not isinstance(inputs, Mapping):
-        raise StepCommandError("step command inputs must be a logical-reference mapping")
+        raise StepCommandError(
+            "step command inputs must be a logical-reference mapping"
+        )
     normalized: dict[str, pathlib.Path] = {}
     for logical_ref, path in inputs.items():
         if not isinstance(logical_ref, str) or not logical_ref:
-            raise StepCommandError("step command input references must be non-empty strings")
+            raise StepCommandError(
+                "step command input references must be non-empty strings"
+            )
         if not isinstance(path, pathlib.Path):
             path = pathlib.Path(path)
         try:
             resolved = path.resolve(strict=True)
             metadata = resolved.stat()
         except (OSError, RuntimeError) as exc:
-            raise StepCommandError("step command input artifact could not be opened") from exc
+            raise StepCommandError(
+                "step command input artifact could not be opened"
+            ) from exc
         if path_is_link_or_reparse(path) or not resolved.is_file() or not metadata:
             raise StepCommandError("step command input artifact must be a regular file")
         normalized[logical_ref] = resolved
@@ -160,7 +169,9 @@ def _substitute_argv(
                     )
                 rendered.append(str(inputs[logical_ref]))
             else:
-                raise StepCommandError(f"unknown step command placeholder in argument {index}")
+                raise StepCommandError(
+                    f"unknown step command placeholder in argument {index}"
+                )
             continue
 
         if _RECOGNIZED_TOKEN.search(argument):
@@ -183,12 +194,16 @@ def resolve_step_command_argv(
     try:
         root = pathlib.Path(repo_root).resolve(strict=True)
     except (OSError, RuntimeError) as exc:
-        raise StepCommandError("step command repository root could not be resolved") from exc
+        raise StepCommandError(
+            "step command repository root could not be resolved"
+        ) from exc
     if not root.is_dir():
         raise StepCommandError("step command repository root must be a directory")
     executable = python_executable or sys.executable
     if not isinstance(executable, str) or not executable or "\x00" in executable:
-        raise StepCommandError("step command Python interpreter must be a non-empty NUL-free string")
+        raise StepCommandError(
+            "step command Python interpreter must be a non-empty NUL-free string"
+        )
     return _substitute_argv(
         command,
         repo_root=root,
@@ -227,7 +242,9 @@ def _validate_utf8(result: StepCommandResult) -> None:
         try:
             stream.decode("utf-8")
         except UnicodeDecodeError as exc:
-            error = StepCommandEncodingError(f"step command emitted invalid UTF-8 on {name}")
+            error = StepCommandEncodingError(
+                f"step command emitted invalid UTF-8 on {name}"
+            )
             error._step_command_result = result
             raise error from exc
 
@@ -250,17 +267,27 @@ def run_step_command(
     their private ``_process_result`` attribute for the persistence helper.
     """
 
-    if isinstance(timeout_seconds, bool) or not isinstance(timeout_seconds, (int, float)):
+    if isinstance(timeout_seconds, bool) or not isinstance(
+        timeout_seconds, (int, float)
+    ):
         raise StepCommandError("step command timeout must be a finite positive number")
     if not math.isfinite(timeout_seconds) or timeout_seconds <= 0:
         raise StepCommandError("step command timeout must be a finite positive number")
-    if isinstance(max_output_bytes, bool) or not isinstance(max_output_bytes, int) or max_output_bytes < 0:
-        raise StepCommandError("step command output bound must be a non-negative integer")
+    if (
+        isinstance(max_output_bytes, bool)
+        or not isinstance(max_output_bytes, int)
+        or max_output_bytes < 0
+    ):
+        raise StepCommandError(
+            "step command output bound must be a non-negative integer"
+        )
 
     input_paths = _validated_inputs(inputs)
     if stdin is not None:
         if not isinstance(stdin, str) or stdin not in input_paths:
-            raise StepCommandError("step command stdin must exactly match a declared input")
+            raise StepCommandError(
+                "step command stdin must exactly match a declared input"
+            )
         input_path = input_paths[stdin]
     else:
         input_path = None
@@ -288,7 +315,9 @@ def run_step_command(
             )
             if truncated
         )
-        error = StepCommandTruncatedError(f"step command {streams} exceeded its capture limit")
+        error = StepCommandTruncatedError(
+            f"step command {streams} exceeded its capture limit"
+        )
         error._step_command_result = result
         raise error
     _validate_utf8(result)
@@ -312,7 +341,10 @@ def _assert_message(result: StepCommandResult) -> str:
     stderr = result.stderr.decode("utf-8", errors="surrogateescape")
     combined = "\n".join(part for part in (stderr.strip(), stdout.strip()) if part)
     safe = redact_diagnostic(combined, secrets=_environment_secrets())
-    return bounded_diagnostic(safe, max_chars=1_200) or f"command exited with status {result.returncode}"
+    return (
+        bounded_diagnostic(safe, max_chars=1_200)
+        or f"command exited with status {result.returncode}"
+    )
 
 
 def step_command_result_payload(
@@ -397,7 +429,9 @@ def execute_step_command(
     """
 
     if step.type not in {"exec", "assert"}:
-        raise StepCommandError("step command implementation requires an exec or assert step")
+        raise StepCommandError(
+            "step command implementation requires an exec or assert step"
+        )
     if isinstance(inputs, Mapping):
         input_map = dict(inputs)
         declared_references = set(step.inputs)
@@ -407,7 +441,9 @@ def execute_step_command(
             )
     else:
         if len(inputs) != len(step.inputs):
-            raise StepCommandError("step command input paths do not match declared inputs")
+            raise StepCommandError(
+                "step command input paths do not match declared inputs"
+            )
         input_map = dict(zip(step.inputs, inputs))
     store = artifacts or ArtifactStore(context.run_dir)
     store.prepare()
@@ -444,9 +480,13 @@ def execute_step_command(
         raise
 
     payload = step_command_result_payload(process_result, step_type=step.type)
-    persisted = _persist_process_result(store, state, step, process_result, payload=payload)
+    persisted = _persist_process_result(
+        store, state, step, process_result, payload=payload
+    )
     if step.type == "exec" and process_result.returncode != 0:
-        error = StepCommandExecutionError("step exec command returned a non-zero status")
+        error = StepCommandExecutionError(
+            "step exec command returned a non-zero status"
+        )
         error._step_command_result = process_result
         error._step_command_persisted = persisted
         raise error

package/src/ai_push_hooks/git_utils.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import codecs
 import fnmatch
 import json
 import os
@@ -82,9 +83,7 @@ def run_command(
             else:
                 merged_env[key] = value
 
-    effective_timeout = (
-        COMMAND_DEFAULT_TIMEOUT_SECONDS if timeout is None else timeout
-    )
+    effective_timeout = COMMAND_DEFAULT_TIMEOUT_SECONDS if timeout is None else timeout
     result = _run_bounded_text_command(
         args,
         cwd,
@@ -199,7 +198,14 @@ def _command_diagnostics(
     if input_text:
         secret_values.append(input_text)
     if env is not None:
-        secret_markers = ("API_KEY", "TOKEN", "SECRET", "PASSWORD", "AUTH", "CREDENTIAL")
+        secret_markers = (
+            "API_KEY",
+            "TOKEN",
+            "SECRET",
+            "PASSWORD",
+            "AUTH",
+            "CREDENTIAL",
+        )
         secret_values.extend(
             value
             for name, value in env.items()
@@ -233,7 +239,9 @@ def resolve_git_common_dir(repo_root: pathlib.Path) -> pathlib.Path:
     return (repo_root / path).resolve()
 
 
-def resolve_storage_path(repo_root: pathlib.Path, git_dir: pathlib.Path, raw: str) -> pathlib.Path:
+def resolve_storage_path(
+    repo_root: pathlib.Path, git_dir: pathlib.Path, raw: str
+) -> pathlib.Path:
     parts = relative_path_parts(raw, "Configured storage path")
     posix_raw = raw.replace("\\", "/")
     if parts[0] == ".git":
@@ -241,7 +249,9 @@ def resolve_storage_path(repo_root: pathlib.Path, git_dir: pathlib.Path, raw: st
             return pathlib.Path(git_dir).resolve(strict=False)
         lexical_path = pathlib.Path(git_dir).joinpath(*parts[1:])
         if path_has_symlink(pathlib.Path(git_dir), lexical_path):
-            raise HookError(f"Configured Git storage path must not traverse a symlink: {raw}")
+            raise HookError(
+                f"Configured Git storage path must not traverse a symlink: {raw}"
+            )
         return resolve_contained_path(
             git_dir,
             "/".join(parts[1:]),
@@ -249,8 +259,12 @@ def resolve_storage_path(repo_root: pathlib.Path, git_dir: pathlib.Path, raw: st
         )
     lexical_path = repo_root.joinpath(*parts)
     if path_has_symlink(repo_root, lexical_path):
-        raise HookError(f"Configured repository storage path must not traverse a symlink: {raw}")
-    return resolve_contained_path(repo_root, posix_raw, "Configured repository storage path")
+        raise HookError(
+            f"Configured repository storage path must not traverse a symlink: {raw}"
+        )
+    return resolve_contained_path(
+        repo_root, posix_raw, "Configured repository storage path"
+    )
 
 
 def ensure_dir(path: pathlib.Path) -> pathlib.Path | None:
@@ -322,9 +336,13 @@ def path_matches(path: str, pattern: str) -> bool:
                 path_index < len(path_parts) and matches(path_index + 1, pattern_index)
             )
         else:
-            result = path_index < len(path_parts) and fnmatch.fnmatchcase(
-                path_parts[path_index], pattern_parts[pattern_index]
-            ) and matches(path_index + 1, pattern_index + 1)
+            result = (
+                path_index < len(path_parts)
+                and fnmatch.fnmatchcase(
+                    path_parts[path_index], pattern_parts[pattern_index]
+                )
+                and matches(path_index + 1, pattern_index + 1)
+            )
         memo[key] = result
         return result
 
@@ -350,7 +368,9 @@ def list_repo_changes(repo_root: pathlib.Path) -> set[str]:
         changes.add(record[3:])
         if "R" in status or "C" in status:
             if index >= len(records) or not records[index]:
-                raise HookError("Malformed rename output from `git status --porcelain=v1 -z`")
+                raise HookError(
+                    "Malformed rename output from `git status --porcelain=v1 -z`"
+                )
             changes.add(records[index])
             index += 1
     return changes
@@ -389,7 +409,11 @@ def parse_push_updates(stdin_lines: list[str]) -> list[PushRefUpdate]:
 
 
 def _resolve_commit(repo_root: pathlib.Path, oid: str) -> str:
-    return git(repo_root, ["rev-parse", "--verify", "--quiet", f"{oid}^{{commit}}"], check=False)
+    return git(
+        repo_root,
+        ["rev-parse", "--verify", "--quiet", f"{oid}^{{commit}}"],
+        check=False,
+    )
 
 
 def _configured_base_commit(
@@ -428,10 +452,29 @@ def _fallback_range(
     local_commit: str,
     *,
     reason: str,
+    pushed_ref: str,
 ) -> tuple[str, str]:
+    configured_base = base_branch.strip() or "main"
+    configured_base_ref = ""
+    if configured_base.startswith("refs/heads/"):
+        configured_base_ref = configured_base
+    elif configured_base.startswith("refs/remotes/"):
+        remote_base = configured_base.removeprefix("refs/remotes/").split("/", 1)
+        if len(remote_base) == 2 and all(remote_base):
+            configured_base_ref = f"refs/heads/{remote_base[1]}"
+    elif not configured_base.startswith("refs/"):
+        configured_base_ref = f"refs/heads/{configured_base}"
+
+    # A zero advertised OID means the remote target is absent; a local or stale
+    # tracking base cannot describe this first publication.
+    if pushed_ref == configured_base_ref:
+        return f"{_empty_tree_oid(repo_root)}..{local_commit}", f"{reason}:empty-tree"
+
     base_commit = _configured_base_commit(repo_root, remote_name, base_branch)
     if base_commit:
-        merge_base = git(repo_root, ["merge-base", local_commit, base_commit], check=False)
+        merge_base = git(
+            repo_root, ["merge-base", local_commit, base_commit], check=False
+        )
         if merge_base:
             return f"{merge_base}..{local_commit}", f"{reason}:configured-base"
     return f"{_empty_tree_oid(repo_root)}..{local_commit}", f"{reason}:empty-tree"
@@ -469,6 +512,7 @@ def collect_revision_ranges(
                 base_branch,
                 local_commit,
                 reason="new-ref",
+                pushed_ref=update.remote_ref,
             )
         ranges.append(
             PushRevisionRange(update=update, expression=expression, strategy=strategy)
@@ -537,7 +581,11 @@ def _collect_bounded_git_diff(
             process_result.stdout if process_result else "",
             process_result.stderr if process_result else "",
         )
-        reason = "timed out" if isinstance(exc, RunnerTimeoutError) else "terminated by signal"
+        reason = (
+            "timed out"
+            if isinstance(exc, RunnerTimeoutError)
+            else "terminated by signal"
+        )
         suffix = f": {details}" if details else ""
         raise HookError(f"Git diff command {reason}{suffix}") from exc
     except RunnerError as exc:
@@ -553,17 +601,26 @@ def _collect_bounded_git_diff(
 
 
 def _decode_diff_output(output: bytes, max_bytes: int, truncated: bool) -> str:
-    if not truncated:
-        return output.decode("utf-8", errors="surrogateescape")
     limit = max(0, max_bytes)
     if limit == 0:
         return ""
+
+    # Diff artifacts are written as strict UTF-8. Git normally emits UTF-8,
+    # but malformed bytes are represented explicitly as U+FFFD rather than
+    # leaking surrogateescape code points into the artifact writer. A decoder
+    # left non-final for a source-truncated stream drops only its incomplete
+    # pending character; a final decoder represents malformed EOF bytes.
+    decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+    normalized = decoder.decode(output, final=not truncated)
+    normalized_bytes = normalized.encode("utf-8")
     marker = DIFF_TRUNCATION_MARKER.encode("utf-8")
+    if not truncated and len(normalized_bytes) <= limit:
+        return normalized
     if len(marker) >= limit:
-        return marker[:limit].decode("utf-8", errors="surrogateescape")
-    return (output[: limit - len(marker)] + marker).decode(
-        "utf-8", errors="surrogateescape"
-    )
+        return marker[:limit].decode("ascii")
+    payload_limit = limit - len(marker)
+    payload = normalized_bytes[:payload_limit].decode("utf-8", errors="ignore")
+    return payload + DIFF_TRUNCATION_MARKER
 
 
 def collect_diff(repo_root: pathlib.Path, ranges: list[str], max_bytes: int) -> str:
@@ -688,7 +745,9 @@ def _github_repository_from_url(remote_url: str) -> str:
     value = remote_url.strip()
     if not value or "\x00" in value or any(ord(character) < 32 for character in value):
         return ""
-    scp_match = re.fullmatch(r"(?:[^@/:\s]+@)?github\.com:([^/\s]+)/([^/\s]+)", value, re.IGNORECASE)
+    scp_match = re.fullmatch(
+        r"(?:[^@/:\s]+@)?github\.com:([^/\s]+)/([^/\s]+)", value, re.IGNORECASE
+    )
     if scp_match:
         owner, repository = scp_match.groups()
     else:
@@ -729,17 +788,21 @@ def resolve_github_repository(
     if repository:
         return repository
     if remote_url.strip():
-        raise HookError(f"Cannot safely determine GitHub repository from push remote URL: {remote_url!r}")
+        raise HookError(
+            "Cannot safely determine GitHub repository from push remote URL"
+        )
     repository = _github_repository_from_url(remote_name)
     if repository:
         return repository
     if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._/-]*", remote_name):
-        raise HookError(f"Cannot safely resolve push remote name: {remote_name!r}")
-    configured_url = git(repo_root, ["remote", "get-url", "--push", remote_name], check=False)
+        raise HookError("Cannot safely resolve push remote name")
+    configured_url = git(
+        repo_root, ["remote", "get-url", "--push", remote_name], check=False
+    )
     repository = _github_repository_from_url(configured_url)
     if not repository:
         raise HookError(
-            f"Cannot safely determine GitHub repository for push remote {remote_name!r}"
+            "Cannot safely determine GitHub repository for the configured push remote"
         )
     return repository
 
@@ -775,7 +838,9 @@ def lookup_open_pr_url(
         check=False,
     )
     if completed.returncode != 0:
-        details = _command_diagnostics(args, completed.stdout or "", completed.stderr or "")
+        details = _command_diagnostics(
+            args, completed.stdout or "", completed.stderr or ""
+        )
         raise HookError(details or "`gh pr list` failed")
     try:
         payload = json.loads((completed.stdout or "").strip() or "[]")

package/src/ai_push_hooks/hook.py

@@ -9,7 +9,11 @@ from typing import Sequence
 from .artifacts import ArtifactStore, generate_run_id
 from .config import load_config
 from .engine import WorkflowEngine
-from .paths import ensure_private_directory, resolve_contained_path, write_text_no_follow
+from .paths import (
+    ensure_private_directory,
+    resolve_contained_path,
+    write_text_no_follow,
+)
 from .git_utils import (
     collect_changed_files,
     collect_diff,
@@ -28,11 +32,15 @@ from .git_utils import (
 from .types import HookConfig, HookError, HookLogger, RuntimeContext
 
 
-def _build_logger(repo_root: pathlib.Path, git_dir: pathlib.Path, config: HookConfig) -> HookLogger:
+def _build_logger(
+    repo_root: pathlib.Path, git_dir: pathlib.Path, config: HookConfig
+) -> HookLogger:
     ensure_private_directory(git_dir / "ai-push-hooks")
     jsonl_path = None
     if config.logging.jsonl:
-        log_dir = ensure_dir(resolve_storage_path(repo_root, git_dir, config.logging.dir))
+        log_dir = ensure_dir(
+            resolve_storage_path(repo_root, git_dir, config.logging.dir)
+        )
         if log_dir is not None:
             jsonl_path = resolve_contained_path(log_dir, "hook.jsonl", "JSONL log path")
     return HookLogger(jsonl_path=jsonl_path, console_level=config.logging.level)
@@ -40,7 +48,9 @@ def _build_logger(repo_root: pathlib.Path, git_dir: pathlib.Path, config: HookCo
 
 def _write_summary(context: RuntimeContext, result: dict[str, object]) -> None:
     summary_dir = ensure_dir(
-        resolve_storage_path(context.repo_root, context.git_dir, context.config.logging.summary_dir)
+        resolve_storage_path(
+            context.repo_root, context.git_dir, context.config.logging.summary_dir
+        )
     )
     if summary_dir is None:
         return
@@ -49,7 +59,9 @@ def _write_summary(context: RuntimeContext, result: dict[str, object]) -> None:
         f"{context.run_id}.json",
         "Summary output path",
     )
-    write_text_no_follow(summary_path, json.dumps(result, ensure_ascii=True, indent=2) + "\n")
+    write_text_no_follow(
+        summary_path, json.dumps(result, ensure_ascii=True, indent=2) + "\n"
+    )
 
 
 def _assert_clean_worktree(repo_root: pathlib.Path) -> None:
@@ -77,7 +89,11 @@ def _run_hook_impl(
     if config.general.require_clean_worktree:
         _assert_clean_worktree(repo_root)
 
-    actual_stdin = list(stdin_lines) if stdin_lines is not None else [line.rstrip("\n") for line in sys.stdin]
+    actual_stdin = (
+        list(stdin_lines)
+        if stdin_lines is not None
+        else [line.rstrip("\n") for line in sys.stdin]
+    )
     push_updates = parse_push_updates(actual_stdin)
     pushed_branch_updates = [
         update
@@ -92,7 +108,9 @@ def _run_hook_impl(
         )
     pushed_branches = list(
         dict.fromkeys(
-            update.branch_name for update in pushed_branch_updates if update.branch_name is not None
+            update.branch_name
+            for update in pushed_branch_updates
+            if update.branch_name is not None
         )
     )
     if config.general.skip_on_sync_branch:
@@ -108,7 +126,9 @@ def _run_hook_impl(
     )
     ranges = unique_range_expressions(revision_ranges)
     changed_files = collect_changed_files(repo_root, ranges) if ranges else []
-    diff_text = collect_diff(repo_root, ranges, config.llm.max_diff_bytes) if ranges else ""
+    diff_text = (
+        collect_diff(repo_root, ranges, config.llm.max_diff_bytes) if ranges else ""
+    )
     if len(pushed_branches) == 1:
         branch_name = pushed_branches[0]
         branch_selection_reason = "single pushed branch"
@@ -141,7 +161,9 @@ def _run_hook_impl(
         branch_diff_text = ""
         branch_is_new = False
     run_id = generate_run_id()
-    run_dir = resolve_storage_path(repo_root, git_dir, f".git/ai-push-hooks/runs/{run_id}")
+    run_dir = resolve_storage_path(
+        repo_root, git_dir, f".git/ai-push-hooks/runs/{run_id}"
+    )
 
     context = RuntimeContext(
         repo_root=repo_root,
@@ -198,14 +220,28 @@ def _run_hook_impl(
     try:
         workflow_result = engine.run()
         logger.llm_summary()
-        _write_summary(context, {"run_dir": str(workflow_result.run_dir), "modules": workflow_result.modules})
-        logger.status("hook.complete", "AI push hooks workflow completed", run_dir=str(workflow_result.run_dir))
+        _write_summary(
+            context,
+            {
+                "run_dir": str(workflow_result.run_dir),
+                "modules": workflow_result.modules,
+            },
+        )
+        logger.status(
+            "hook.complete",
+            "AI push hooks workflow completed",
+            run_dir=str(workflow_result.run_dir),
+        )
         return 0
     except Exception as exc:  # noqa: BLE001
         message = str(exc).strip() or exc.__class__.__name__
         logger.error("hook.failed", "AI push hooks workflow failed", error=message)
         if config.general.allow_push_on_error:
-            logger.warn("hook.fail_open", "Allowing push because allow_push_on_error=true", error=message)
+            logger.warn(
+                "hook.fail_open",
+                "Allowing push because allow_push_on_error=true",
+                error=message,
+            )
             return 0
         raise
 

package/src/ai_push_hooks/install.py

@@ -61,11 +61,7 @@ def pre_push_hook_script(delegate: tuple[str, ...] | None = None) -> str:
         )
     else:
         availability_check = ""
-    return (
-        "#!/bin/sh\n"
-        + availability_check
-        + f'exec {command} hook "$@"\n'
-    )
+    return "#!/bin/sh\n" + availability_check + f'exec {command} hook "$@"\n'
 
 
 def _git_value(cwd: pathlib.Path, *args: str) -> str:
@@ -81,7 +77,9 @@ def _git_value(cwd: pathlib.Path, *args: str) -> str:
     except FileNotFoundError as exc:
         raise HookError("Git is required for `ai-push-hooks install`") from exc
     except subprocess.TimeoutExpired as exc:
-        raise HookError(f"Git command timed out while resolving hook location: {' '.join(args)}") from exc
+        raise HookError(
+            f"Git command timed out while resolving hook location: {' '.join(args)}"
+        ) from exc
     except subprocess.CalledProcessError as exc:
         detail = (exc.stderr or exc.stdout or "not a Git repository").strip()
         raise HookError(f"Could not resolve Git hook location: {detail}") from exc
@@ -93,11 +91,15 @@ def _resolve_git_namespace(repo_root: pathlib.Path, value: str) -> pathlib.Path:
     return (repo_root / path).resolve() if not path.is_absolute() else path.resolve()
 
 
-def _path_is_in_namespace(path: pathlib.Path, namespaces: tuple[pathlib.Path, ...]) -> bool:
+def _path_is_in_namespace(
+    path: pathlib.Path, namespaces: tuple[pathlib.Path, ...]
+) -> bool:
     return any(is_path_within(path, namespace) for namespace in namespaces)
 
 
-def _validate_parent_chain(path: pathlib.Path, namespaces: tuple[pathlib.Path, ...]) -> None:
+def _validate_parent_chain(
+    path: pathlib.Path, namespaces: tuple[pathlib.Path, ...]
+) -> None:
     """Reject symlink/reparse parents and create only missing safe directories."""
     parent = path.parent
     existing: list[pathlib.Path] = []
@@ -129,25 +131,41 @@ def _validate_parent_chain(path: pathlib.Path, namespaces: tuple[pathlib.Path, .
         current = current.parent
 
 
-def _effective_hook_path(current_dir: pathlib.Path) -> tuple[pathlib.Path, pathlib.Path, pathlib.Path, pathlib.Path]:
-    repo_root = pathlib.Path(_git_value(current_dir, "rev-parse", "--show-toplevel")).resolve()
-    git_dir = _resolve_git_namespace(repo_root, _git_value(repo_root, "rev-parse", "--git-dir"))
+def _effective_hook_path(
+    current_dir: pathlib.Path,
+) -> tuple[pathlib.Path, pathlib.Path, pathlib.Path, pathlib.Path]:
+    repo_root = pathlib.Path(
+        _git_value(current_dir, "rev-parse", "--show-toplevel")
+    ).resolve()
+    git_dir = _resolve_git_namespace(
+        repo_root, _git_value(repo_root, "rev-parse", "--git-dir")
+    )
     common_dir = _resolve_git_namespace(
         repo_root, _git_value(repo_root, "rev-parse", "--git-common-dir")
     )
-    raw_hooks_dir = pathlib.Path(_git_value(current_dir, "rev-parse", "--git-path", "hooks"))
+    raw_hooks_dir = pathlib.Path(
+        _git_value(current_dir, "rev-parse", "--git-path", "hooks")
+    )
     lexical_hooks_dir = (
         raw_hooks_dir if raw_hooks_dir.is_absolute() else current_dir / raw_hooks_dir
     )
     if path_is_link_or_reparse(current_dir) or not current_dir.is_dir():
-        raise HookError(f"Refusing to install from an unsafe working directory: {current_dir}")
+        raise HookError(
+            f"Refusing to install from an unsafe working directory: {current_dir}"
+        )
     if any(path_is_link_or_reparse(part) for part in lexical_hooks_dir.parents):
-        raise HookError(f"Refusing hook path with a symlink or reparse parent: {lexical_hooks_dir}")
+        raise HookError(
+            f"Refusing hook path with a symlink or reparse parent: {lexical_hooks_dir}"
+        )
     if path_is_link_or_reparse(lexical_hooks_dir):
-        raise HookError(f"Refusing hook path with a symlink or reparse parent: {lexical_hooks_dir}")
+        raise HookError(
+            f"Refusing hook path with a symlink or reparse parent: {lexical_hooks_dir}"
+        )
     lexical_hook_path = lexical_hooks_dir / "pre-push"
     if path_is_link_or_reparse(lexical_hook_path):
-        raise HookError(f"Refusing symlink or reparse-point hook target: {lexical_hook_path}")
+        raise HookError(
+            f"Refusing symlink or reparse-point hook target: {lexical_hook_path}"
+        )
     hook_path = lexical_hook_path.resolve(strict=False)
 
     namespaces = (repo_root, git_dir)
@@ -179,11 +197,15 @@ def install_hook(force: bool, cwd: pathlib.Path | None = None) -> int:
     except FileNotFoundError:
         metadata = None
     except OSError as exc:
-        raise HookError(f"Could not inspect pre-push hook path {hook_path}: {exc}") from exc
+        raise HookError(
+            f"Could not inspect pre-push hook path {hook_path}: {exc}"
+        ) from exc
 
     if metadata is not None:
         if path_is_link_or_reparse(hook_path):
-            raise HookError(f"Refusing symlink or reparse-point hook target: {hook_path}")
+            raise HookError(
+                f"Refusing symlink or reparse-point hook target: {hook_path}"
+            )
         if not stat.S_ISREG(metadata.st_mode):
             raise HookError(f"Refusing non-regular hook target: {hook_path}")
         if not force: