ai-push-hooks 0.3.0 → 0.3.1

package/src/ai_push_hooks/hook.py

@@ -10,7 +10,7 @@ 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 .git_utils import (
     collect_changed_files,
     collect_diff,
     collect_revision_ranges,

package/src/ai_push_hooks/modules/beads.py

@@ -2,7 +2,7 @@ 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
 
 

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,6 +204,54 @@ def _fallback_docs_context(repo_root: pathlib.Path, doc_files: list[pathlib.Path
     return "\n\n".join(snippets)
 
 
+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:
@@ -163,83 +259,27 @@ def _search_docs_context(repo_root: pathlib.Path, doc_files: list[pathlib.Path],
     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:

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,

package/src/ai_push_hooks/plugin_loader.py

@@ -10,7 +10,6 @@ completed.
 
 from __future__ import annotations  # noqa: I001
 
-import copy
 import errno
 import hashlib
 import inspect
@@ -174,96 +173,121 @@ class PluginLoader:
     def __init__(self) -> None:
         self._cache: dict[tuple[pathlib.Path, pathlib.Path], ModuleType] = {}
         self._lock = threading.RLock()
+        self._source_locks: dict[tuple[pathlib.Path, pathlib.Path], threading.Lock] = {}
         self._module_number = 0
 
+    def _source_lock(
+        self, key: tuple[pathlib.Path, pathlib.Path]
+    ) -> threading.Lock:
+        with self._lock:
+            lock = self._source_locks.get(key)
+            if lock is None:
+                lock = threading.Lock()
+                self._source_locks[key] = lock
+            return lock
+
+    def _load_module(
+        self,
+        root: pathlib.Path,
+        relative_path: str,
+        callable_name: str,
+    ) -> ModuleType:
+        try:
+            callback_path, source = _open_source(root, relative_path)
+        except HookError as exc:
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} could not be loaded safely: "
+                f"{str(exc).removeprefix('Python plugin ')}"
+            ) from None
+        # ``callback_path`` is canonical after containment checks and is equal
+        # to the lexical cache key for a safe repository file.
+        try:
+            source_text = source.decode(_SOURCE_ENCODING)
+            code = compile(source_text, str(callback_path), "exec")
+        except UnicodeDecodeError:
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} source is not valid UTF-8"
+            ) from None
+        except (SyntaxError, ValueError, TypeError):
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} could not be compiled"
+            ) from None
+
+        with self._lock:
+            self._module_number += 1
+            module_number = self._module_number
+        digest = hashlib.sha256(f"{root}\0{callback_path}".encode()).hexdigest()[:16]
+        module_name = f"ai_push_hooks_plugin_{digest}_{module_number}"
+        module = ModuleType(module_name)
+        module.__file__ = str(callback_path)
+        module.__package__ = ""
+        try:
+            exec(code, module.__dict__)  # noqa: S102
+        except KeyboardInterrupt:
+            raise
+        except SystemExit:
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} exited during import"
+            ) from None
+        except ModuleNotFoundError as exc:
+            if exc.name:
+                detail = f"is missing dependency {exc.name!r}"
+            else:
+                detail = "could not import a dependency"
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} {detail}"
+            ) from None
+        except ImportError:
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} could not import a dependency"
+            ) from None
+        except Exception:  # noqa: BLE001
+            raise HookError(
+                f"Python plugin {relative_path}:{callable_name} failed during import"
+            ) from None
+        return module
+
     def load(self, repo_root: pathlib.Path, reference: str) -> Callable[..., Any]:
         """Return the named top-level callable from a safe source snapshot.
 
-        The lock includes descriptor open, source read, compilation, and module
-        execution.  Thus concurrent collectors cannot execute the same source
-        twice.  The cache key includes both canonical repository root and
-        canonical file path, so identical relative names in two repositories
-        remain independent.
+        A per-source lock includes descriptor open, source read, compilation,
+        and module execution.  Thus concurrent collectors cannot execute the
+        same source twice, while different sources can import concurrently.
+        The cache key includes both canonical repository root and canonical
+        file path, so identical relative names in two repositories remain
+        independent.
         """
 
         relative_path, callable_name = _reference_parts(reference)
         root = _canonical_root(repo_root)
+        lexical_callback_path = root.joinpath(*relative_path.split("/"))
+        key = (root, lexical_callback_path)
         with self._lock:
-            lexical_callback_path = root.joinpath(*relative_path.split("/"))
-            key = (root, lexical_callback_path)
             module = self._cache.get(key)
-            if module is None:
-                try:
-                    callback_path, source = _open_source(root, relative_path)
-                except HookError as exc:
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} could not be loaded safely: "
-                        f"{str(exc).removeprefix('Python plugin ')}"
-                    ) from None
-                # ``callback_path`` is canonical after containment checks and
-                # is equal to the lexical path for a safe repository file.
-                key = (root, callback_path)
-                try:
-                    source_text = source.decode(_SOURCE_ENCODING)
-                    code = compile(source_text, str(callback_path), "exec")
-                except UnicodeDecodeError:
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} source is not valid UTF-8"
-                    ) from None
-                except (SyntaxError, ValueError, TypeError):
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} could not be compiled"
-                    ) from None
-
-                self._module_number += 1
-                digest = hashlib.sha256(
-                    f"{root}\0{callback_path}".encode()
-                ).hexdigest()[:16]
-                module_name = f"ai_push_hooks_plugin_{digest}_{self._module_number}"
-                module = ModuleType(module_name)
-                module.__file__ = str(callback_path)
-                module.__package__ = ""
-                try:
-                    exec(code, module.__dict__)  # noqa: S102
-                except KeyboardInterrupt:
-                    raise
-                except SystemExit:
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} exited during import"
-                    ) from None
-                except ModuleNotFoundError as exc:
-                    if exc.name:
-                        detail = f"is missing dependency {exc.name!r}"
-                    else:
-                        detail = "could not import a dependency"
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} {detail}"
-                    ) from None
-                except ImportError:
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} could not import a dependency"
-                    ) from None
-                except Exception:  # noqa: BLE001
-                    raise HookError(
-                        f"Python plugin {relative_path}:{callable_name} failed during import"
-                    ) from None
-                self._cache[key] = module
-
-            try:
-                callback = getattr(module, callable_name)
-            except AttributeError:
-                raise _failure(
-                    "callback", relative_path, callable_name, "was not defined"
-                ) from None
-            if not callable(callback):
-                raise _failure(
-                    "callback", relative_path, callable_name, "is not callable"
-                ) from None
-            if inspect.iscoroutinefunction(callback):
-                raise _failure(
-                    "callback", relative_path, callable_name, "must be synchronous"
-                ) from None
-            return callback
+        if module is None:
+            with self._source_lock(key):
+                with self._lock:
+                    module = self._cache.get(key)
+                if module is None:
+                    module = self._load_module(root, relative_path, callable_name)
+                    with self._lock:
+                        self._cache[key] = module
+
+        try:
+            callback = getattr(module, callable_name)
+        except AttributeError:
+            raise _failure(
+                "callback", relative_path, callable_name, "was not defined"
+            ) from None
+        if not callable(callback):
+            raise _failure(
+                "callback", relative_path, callable_name, "is not callable"
+            ) from None
+        if inspect.iscoroutinefunction(callback):
+            raise _failure(
+                "callback", relative_path, callable_name, "must be synchronous"
+            ) from None
+        return callback
 
     def invoke(
         self,
@@ -358,8 +382,8 @@ def build_plugin_context(
         module_id=state.module.id,
         step_id=step.id,
         inputs=_ordered_inputs(step, input_paths),
-        options=copy.deepcopy(step.options),
-        prior_module_metadata=copy.deepcopy(state.metadata),
+        options=step.options,
+        prior_module_metadata=state.metadata,
         push=push,
         logger=runtime.logger,
     )

package/src/ai_push_hooks/types.py

@@ -14,6 +14,7 @@ from typing import Any, ClassVar
 READ_ONLY_STEP_TYPES = frozenset({"collect", "ask"})
 PROMPTABLE_STEP_TYPES = frozenset({"ask", "apply"})
 SUPPORTED_STEP_TYPES = frozenset({"collect", "ask", "apply", "exec", "assert"})
+DEFAULT_STEP_COMMAND_TIMEOUT_SECONDS = 60
 FEATURE_BRANCH_PREFIXES = ("feat/", "feature/")
 ZERO_OID_LENGTHS = frozenset({40, 64})
 

package/vendor/README.md

@@ -0,0 +1,15 @@
+# Bundled Python Dependency
+
+The npm package includes the unmodified pure-Python wheel for [Tomli](https://pypi.org/project/tomli/2.4.0/). Python 3.10 uses it to parse TOML; Python 3.11+ uses the standard-library `tomllib` module.
+
+The wrapper adds the wheel to `PYTHONPATH`, so no pip install, install script, or runtime download is needed. The wheel includes Tomli's MIT license under `tomli-2.4.0.dist-info/licenses/LICENSE`.
+
+To reproduce the bundled download from the repository root:
+
+```bash
+python -m pip download --index-url https://pypi.org/simple --require-hashes \
+  --only-binary=:all: --no-deps --platform any --implementation py --abi none \
+  --python-version 3.10 --dest vendor --requirement vendor/requirements.txt
+```
+
+When updating, verify the pure-Python wheel's SHA-256 against PyPI, update the pin and wrapper path, and run the npm installed-hook tests on Python 3.10.

package/vendor/requirements.txt

@@ -0,0 +1 @@
+tomli==2.4.0 --hash=sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a