ai-push-hooks 0.3.0 → 0.3.2

package/src/ai_push_hooks/hook.py

@@ -9,8 +9,12 @@ 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 .executors.exec import (
+from .paths import (
+    ensure_private_directory,
+    resolve_contained_path,
+    write_text_no_follow,
+)
+from .git_utils import (
     collect_changed_files,
     collect_diff,
     collect_revision_ranges,
@@ -28,11 +32,15 @@ from .executors.exec 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:

package/src/ai_push_hooks/modules/beads.py

@@ -2,11 +2,13 @@ from __future__ import annotations
 
 from typing import Any
 
-from ..executors.exec import collect_commit_messages_for_ranges, is_feature_branch
+from ..git_utils import collect_commit_messages_for_ranges, is_feature_branch
 from ..types import CollectorResult, RuntimeContext
 
 
-def collect_beads_status_context(context: RuntimeContext, state: Any) -> CollectorResult:
+def collect_beads_status_context(
+    context: RuntimeContext, state: Any
+) -> CollectorResult:
     branch_name = str(context.cache.get("branch_name", ""))
     branch_selection_reason = str(
         context.cache.get("branch_selection_reason", "no pushed branch updates")
@@ -22,7 +24,9 @@ def collect_beads_status_context(context: RuntimeContext, state: Any) -> Collect
             skip_reason=branch_selection_reason,
         )
     sync_branch = context.cache.get("sync_branch", "beads-sync")
-    if branch_name in {"HEAD", "main", sync_branch} or not is_feature_branch(branch_name):
+    if branch_name in {"HEAD", "main", sync_branch} or not is_feature_branch(
+        branch_name
+    ):
         return CollectorResult(
             artifacts={"branch-context.txt": f"branch={branch_name}\n"},
             skip_module=True,
@@ -33,8 +37,12 @@ def collect_beads_status_context(context: RuntimeContext, state: Any) -> Collect
     changed_files = context.cache.get(
         "branch_changed_files", context.cache.get("changed_files", [])
     )
-    diff_text = context.cache.get("branch_diff_text", context.cache.get("diff_text", ""))
-    commits = collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    diff_text = context.cache.get(
+        "branch_diff_text", context.cache.get("diff_text", "")
+    )
+    commits = (
+        collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    )
     report_file = "BEADS_STATUS_ACTION_REQUIRED.md"
     commit_lines = []
     for commit in commits:
@@ -54,8 +62,11 @@ def collect_beads_status_context(context: RuntimeContext, state: Any) -> Collect
                 ]
             )
             + "\n",
-            "changed-files.txt": "\n".join(changed_files) + ("\n" if changed_files else ""),
-            "push.diff": diff_text + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
-            "commits.txt": "\n".join(commit_lines).strip() + ("\n" if commit_lines else ""),
+            "changed-files.txt": "\n".join(changed_files)
+            + ("\n" if changed_files else ""),
+            "push.diff": diff_text
+            + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
+            "commits.txt": "\n".join(commit_lines).strip()
+            + ("\n" if commit_lines else ""),
         }
     )

package/src/ai_push_hooks/modules/docs.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 import os
 import pathlib
 import re
@@ -10,7 +9,7 @@ from pathlib import PurePosixPath
 from typing import Any
 
 from ..types import CollectorResult, RuntimeContext
-from ..executors.exec import collect_commit_messages_for_ranges, git, path_matches, run_command
+from ..git_utils import collect_commit_messages_for_ranges, git, path_matches
 
 DOC_INCLUDE_PATTERNS = ("README.md", "docs/**/*.md")
 DOC_IGNORE_PATTERNS = ("docs/archive/**",)
@@ -18,6 +17,10 @@ DOC_CONTEXT_LINES = 2
 DOC_MAX_BYTES = 64 * 1024
 DOC_CONTEXT_BUDGET = 32000
 DOC_FALLBACK_FILE_LIMIT = 8
+# Matching metadata is deliberately bounded independently of the document
+# inventory.  The normal context budget is reached much earlier, while this
+# cap prevents a pathological repeated-match file from retaining every hit.
+DOC_MAX_QUERY_MATCHES = 4096
 
 
 def _path_matches(path: str, patterns: tuple[str, ...]) -> bool:
@@ -126,25 +129,70 @@ def _read_bounded_text(path: pathlib.Path, max_bytes: int | None = None) -> str:
             os.close(descriptor)
 
 
-def _append_context_chunk(chunks: list[str], chunk: str, budget: int) -> bool:
-    current_size = sum(len(item) for item in chunks) + max(0, len(chunks) - 1)
-    remaining = budget - current_size
-    if remaining <= 0:
-        return False
-    truncated = len(chunk) > remaining
-    if truncated:
-        if chunks:
+class _ContextAccumulator:
+    """Collect bounded snippets without rescanning all prior snippets."""
+
+    def __init__(self) -> None:
+        self.chunks: list[str] = []
+        self.size = 0
+
+    def append(self, chunk: str, budget: int) -> bool:
+        remaining = budget - self.size
+        separator_size = 1 if self.chunks else 0
+        remaining -= separator_size
+        if remaining <= 0:
             return False
-        chunk = chunk[:remaining]
-    chunks.append(chunk)
-    return not truncated
+        truncated = len(chunk) > remaining
+        if truncated:
+            if self.chunks:
+                return False
+            chunk = chunk[:remaining]
+        self.chunks.append(chunk)
+        self.size += separator_size + len(chunk)
+        return not truncated
 
+    def render(self) -> str:
+        return "\n".join(self.chunks)
 
-def _fallback_docs_context(repo_root: pathlib.Path, doc_files: list[pathlib.Path]) -> str:
+
+class _QueryMatchBuffer:
+    """Bounded query-ranked snippet metadata for one document scan."""
+
+    def __init__(self, max_matches: int = DOC_MAX_QUERY_MATCHES) -> None:
+        self.max_matches = max_matches
+        self.matches: list[tuple[tuple[int, int], str]] = []
+        self._seen: set[tuple[int, int]] = set()
+        self.characters = 0
+        self.saturated = False
+
+    def add(
+        self,
+        key: tuple[int, int],
+        relative: str,
+        line_number: int,
+        line: str,
+    ) -> None:
+        if key in self._seen or self.saturated or len(self.matches) >= self.max_matches:
+            return
+        chunk = f"{relative}:{line_number}: {line}"
+        self._seen.add(key)
+        self.matches.append((key, chunk))
+        self.characters += len(chunk)
+        self.saturated = (
+            len(self.matches) >= self.max_matches
+            or self.characters >= DOC_CONTEXT_BUDGET
+        )
+
+
+def _fallback_docs_context(
+    repo_root: pathlib.Path,
+    doc_files: list[pathlib.Path],
+    contents: dict[pathlib.Path, str] | None = None,
+) -> str:
     snippets: list[str] = []
     for path in doc_files[:DOC_FALLBACK_FILE_LIMIT]:
         relative = path.relative_to(repo_root).as_posix()
-        content = _read_bounded_text(path)
+        content = _read_bounded_text(path) if contents is None else contents[path]
         block = f"--- {relative} ---\n{content}"
         current_size = len("\n\n".join(snippets))
         remaining = DOC_CONTEXT_BUDGET - current_size
@@ -156,90 +204,84 @@ def _fallback_docs_context(repo_root: pathlib.Path, doc_files: list[pathlib.Path
     return "\n\n".join(snippets)
 
 
-def _search_docs_context(repo_root: pathlib.Path, doc_files: list[pathlib.Path], queries: list[str]) -> str:
+def _collect_query_matches(
+    repo_root: pathlib.Path,
+    doc_files: list[pathlib.Path],
+    queries: list[str],
+    *,
+    rg_available: bool,
+) -> tuple[list[_QueryMatchBuffer], dict[pathlib.Path, str]]:
+    """Read each document once and retain only bounded ranked snippet metadata.
+
+    The old rg path skipped files larger than ``DOC_MAX_BYTES`` while its
+    no-rg fallback read a bounded prefix.  Keep that environment-dependent
+    compatibility behavior explicit while avoiding N query subprocesses and
+    without caching the whole documentation tree.
+    """
+
+    buffers = [_QueryMatchBuffer() for _query in queries]
+    fallback_contents: dict[pathlib.Path, str] = {}
+    for path_index, path in enumerate(doc_files):
+        if rg_available:
+            try:
+                if path.stat().st_size > DOC_MAX_BYTES:
+                    continue
+            except OSError:
+                continue
+        content = _read_bounded_text(path)
+        if not rg_available and path_index < DOC_FALLBACK_FILE_LIMIT:
+            fallback_contents[path] = content
+        lines = content.splitlines()
+        relative = path.relative_to(repo_root).as_posix()
+        for line_index, line in enumerate(lines):
+            for query_index, query in enumerate(queries):
+                if query not in line:
+                    continue
+                first = max(0, line_index - DOC_CONTEXT_LINES)
+                last = min(len(lines), line_index + DOC_CONTEXT_LINES + 1)
+                buffer = buffers[query_index]
+                for index in range(first, last):
+                    buffer.add(
+                        (path_index, index),
+                        relative,
+                        index + 1,
+                        lines[index],
+                    )
+                if all(buffer.saturated for buffer in buffers):
+                    return buffers, fallback_contents
+    return buffers, fallback_contents
+
+
+def _search_docs_context(
+    repo_root: pathlib.Path, doc_files: list[pathlib.Path], queries: list[str]
+) -> str:
     repo_root = repo_root.resolve(strict=True)
     if not doc_files:
         return ""
     if not queries:
         return _fallback_docs_context(repo_root, doc_files)
 
-    if shutil.which("rg") is None:
-        chunks: list[str] = []
-        seen: set[tuple[str, int]] = set()
-        for query in queries:
-            for path in doc_files:
-                relative = path.relative_to(repo_root).as_posix()
-                lines = _read_bounded_text(path).splitlines()
-                matching_lines = [index for index, line in enumerate(lines) if query in line]
-                for matching_index in matching_lines:
-                    first = max(0, matching_index - DOC_CONTEXT_LINES)
-                    last = min(len(lines), matching_index + DOC_CONTEXT_LINES + 1)
-                    for index in range(first, last):
-                        key = (relative, index + 1)
-                        if key in seen:
-                            continue
-                        seen.add(key)
-                        chunk = f"{relative}:{index + 1}: {lines[index]}"
-                        if not _append_context_chunk(chunks, chunk, DOC_CONTEXT_BUDGET):
-                            return "\n".join(chunks)
-        return "\n".join(chunks) if chunks else _fallback_docs_context(repo_root, doc_files)
-
-    files = [path.relative_to(repo_root).as_posix() for path in doc_files]
-    allowed_files = set(files)
-    chunks: list[str] = []
-    seen: set[tuple[str, int]] = set()
-    for query in queries:
-        completed = run_command(
-            [
-                "rg",
-                "--json",
-                "--fixed-strings",
-                "--with-filename",
-                "--color=never",
-                "--context",
-                str(DOC_CONTEXT_LINES),
-                "--max-filesize",
-                str(DOC_MAX_BYTES),
-                "--",
-                query,
-                *files,
-            ],
-            cwd=repo_root,
-            check=False,
-        )
-        if completed.returncode not in {0, 1}:
-            continue
-        for line in completed.stdout.splitlines():
-            try:
-                message = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            if message.get("type") not in {"match", "context"}:
-                continue
-            data = message.get("data")
-            if not isinstance(data, dict):
-                continue
-            path_data = data.get("path")
-            lines_data = data.get("lines")
-            file_name = path_data.get("text") if isinstance(path_data, dict) else None
-            line_number = data.get("line_number")
-            content = lines_data.get("text") if isinstance(lines_data, dict) else None
-            if (
-                not isinstance(file_name, str)
-                or file_name not in allowed_files
-                or not isinstance(line_number, int)
-                or not isinstance(content, str)
-            ):
-                continue
-            key = (file_name, line_number)
+    rg_available = shutil.which("rg") is not None
+    matches_by_query, fallback_contents = _collect_query_matches(
+        repo_root,
+        doc_files,
+        queries,
+        rg_available=rg_available,
+    )
+    accumulator = _ContextAccumulator()
+    seen: set[tuple[int, int]] = set()
+    for query_matches in matches_by_query:
+        for key, chunk in query_matches.matches:
             if key in seen:
                 continue
             seen.add(key)
-            clean_content = content.rstrip("\r\n")
-            chunk = f"{file_name}:{line_number}: {clean_content}"
-            if not _append_context_chunk(chunks, chunk, DOC_CONTEXT_BUDGET):
-                return "\n".join(chunks)
-    return "\n".join(chunks)
+            if not accumulator.append(chunk, DOC_CONTEXT_BUDGET):
+                return accumulator.render()
+    if accumulator.chunks:
+        return accumulator.render()
+    if rg_available:
+        return ""
+    return _fallback_docs_context(repo_root, doc_files, fallback_contents)
 
 
 def collect_docs_context(context: RuntimeContext, _state: Any) -> CollectorResult:
@@ -257,7 +299,9 @@ def collect_docs_context(context: RuntimeContext, _state: Any) -> CollectorResul
         ["log", "--oneline", "-n", "20", "--", "README.md", "docs"],
         check=False,
     )
-    commits = collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    commits = (
+        collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    )
     commit_lines = []
     for commit in commits:
         commit_lines.append(f"--- {commit['hash']}")
@@ -268,12 +312,18 @@ def collect_docs_context(context: RuntimeContext, _state: Any) -> CollectorResul
         commit_lines.append("")
     return CollectorResult(
         artifacts={
-            "changed-files.txt": "\n".join(changed_files) + ("\n" if changed_files else ""),
-            "push.diff": diff_text + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
-            "docs-inventory.txt": "\n".join(path.relative_to(context.repo_root).as_posix() for path in doc_files)
+            "changed-files.txt": "\n".join(changed_files)
+            + ("\n" if changed_files else ""),
+            "push.diff": diff_text
+            + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
+            "docs-inventory.txt": "\n".join(
+                path.relative_to(context.repo_root).as_posix() for path in doc_files
+            )
             + ("\n" if doc_files else ""),
             "docs-context.txt": docs_context + ("\n" if docs_context else ""),
-            "recent-commits.txt": recent_commits + ("\n" if recent_commits and not recent_commits.endswith("\n") else ""),
-            "commits.txt": "\n".join(commit_lines).strip() + ("\n" if commit_lines else ""),
+            "recent-commits.txt": recent_commits
+            + ("\n" if recent_commits and not recent_commits.endswith("\n") else ""),
+            "commits.txt": "\n".join(commit_lines).strip()
+            + ("\n" if commit_lines else ""),
         }
     )

package/src/ai_push_hooks/modules/pr.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from ..executors.exec import (
+from ..git_utils import (
     collect_commit_messages_for_ranges,
     env_bool,
     initial_pr_defer_reason,
@@ -37,7 +37,9 @@ def collect_pr_context(context: RuntimeContext, state: Any) -> CollectorResult:
             break
     if flag_env and env_bool(flag_env) is not True:
         return CollectorResult(
-            artifacts={"pr-context.txt": f"branch={branch_name}\nflag_env={flag_env}\n"},
+            artifacts={
+                "pr-context.txt": f"branch={branch_name}\nflag_env={flag_env}\n"
+            },
             skip_module=True,
             skip_reason="PR create env flag is not enabled",
         )
@@ -81,7 +83,9 @@ def collect_pr_context(context: RuntimeContext, state: Any) -> CollectorResult:
         existing_pr_url = ""
     if existing_pr_url:
         return CollectorResult(
-            artifacts={"pr-context.txt": f"branch={branch_name}\nexisting_pr_url={existing_pr_url}\n"},
+            artifacts={
+                "pr-context.txt": f"branch={branch_name}\nexisting_pr_url={existing_pr_url}\n"
+            },
             skip_module=True,
             skip_reason="open PR already exists",
             metadata={"existing_pr_url": existing_pr_url},
@@ -91,8 +95,12 @@ def collect_pr_context(context: RuntimeContext, state: Any) -> CollectorResult:
     changed_files = context.cache.get(
         "branch_changed_files", context.cache.get("changed_files", [])
     )
-    diff_text = context.cache.get("branch_diff_text", context.cache.get("diff_text", ""))
-    commits = collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    diff_text = context.cache.get(
+        "branch_diff_text", context.cache.get("diff_text", "")
+    )
+    commits = (
+        collect_commit_messages_for_ranges(context.repo_root, ranges) if ranges else []
+    )
     commit_lines = []
     for commit in commits:
         commit_lines.append(f"--- {commit['hash']}")
@@ -113,8 +121,11 @@ def collect_pr_context(context: RuntimeContext, state: Any) -> CollectorResult:
                 ]
             )
             + "\n",
-            "changed-files.txt": "\n".join(changed_files) + ("\n" if changed_files else ""),
-            "push.diff": diff_text + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
-            "commits.txt": "\n".join(commit_lines).strip() + ("\n" if commit_lines else ""),
+            "changed-files.txt": "\n".join(changed_files)
+            + ("\n" if changed_files else ""),
+            "push.diff": diff_text
+            + ("\n" if diff_text and not diff_text.endswith("\n") else ""),
+            "commits.txt": "\n".join(commit_lines).strip()
+            + ("\n" if commit_lines else ""),
         }
     )