feat(prek): support prek as hook runner (#73)

* feat(prek): support `prek` as hook runner

Author: noirbizarre

README.md

@@ -90,6 +90,9 @@ ignore = []
 # Name of the pre-commit config file to sync with
 # Can be set to ".pre-commit-config.yml" to support prek alternate config file
 pre-commit-config-file = ".pre-commit-config.yaml"
+# Hook runner to use for installing hooks: "pre-commit", "prek", or "auto"
+# "auto" tries prek first, then falls back to pre-commit
+hook-runner = "pre-commit"
 # Additional mapping of URLs to python packages
 # Default is empty, but will merge with the default mapping
 # "rev" indicates the format of the Git tags
@@ -103,12 +106,13 @@ dependency-mapping = {"package-name"= {"repo"= "https://github.com/example/packa
 
 Some settings are overridable by environment variables with the following `SYNC_PRE_COMMIT_LOCK_*` prefixed environment variables:
 
-| `toml` setting                | environment                            | format                            |
-| ----------------------------- | -------------------------------------- | --------------------------------- |
-| `automatically-install-hooks` | `SYNC_PRE_COMMIT_LOCK_INSTALL`         | `bool` as string (`true`, `1`...) |
-| `disable-sync-from-lock`      | `SYNC_PRE_COMMIT_LOCK_DISABLED`        | `bool` as string (`true`, `1`...) |
-| `ignore`                      | `SYNC_PRE_COMMIT_LOCK_IGNORE`          | comma-separated list              |
-| `pre-commit-config-file`      | `SYNC_PRE_COMMIT_LOCK_PRE_COMMIT_FILE` | `str`                             |
+| `toml` setting                | environment                            | format                                      |
+| ----------------------------- | -------------------------------------- | ------------------------------------------- |
+| `automatically-install-hooks` | `SYNC_PRE_COMMIT_LOCK_INSTALL`         | `bool` as string (`true`, `1`...)           |
+| `disable-sync-from-lock`      | `SYNC_PRE_COMMIT_LOCK_DISABLED`        | `bool` as string (`true`, `1`...)           |
+| `ignore`                      | `SYNC_PRE_COMMIT_LOCK_IGNORE`          | comma-separated list                        |
+| `pre-commit-config-file`      | `SYNC_PRE_COMMIT_LOCK_PRE_COMMIT_FILE` | `str`                                       |
+| `hook-runner`                 | `SYNC_PRE_COMMIT_LOCK_HOOK_RUNNER`     | `str` (`pre-commit`, `prek`, or `auto`)     |
 
 ## Usage
 

src/sync_pre_commit_lock/actions/install_hooks.py

@@ -7,23 +7,75 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar
 
+from sync_pre_commit_lock.config import HookRunner
+
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
     from sync_pre_commit_lock import Printer
 
 
-class SetupPreCommitHooks:
-    install_pre_commit_hooks_command: ClassVar[Sequence[str | bytes]] = ["pre-commit", "install"]
-    check_pre_commit_version_command: ClassVar[Sequence[str | bytes]] = ["pre-commit", "--version"]
+class ResolvedHookRunner:
+    """A resolved hook runner, bound to a concrete runner (never AUTO) and a command prefix."""
+
+    # Probe order for auto-detection: try prek first, then pre-commit
+    _AUTO_ORDER: ClassVar[tuple[HookRunner, ...]] = (HookRunner.PREK, HookRunner.PRE_COMMIT)
+
+    def __init__(self, runner: HookRunner, command_prefix: Sequence[str] = ()) -> None:
+        self.runner = runner
+        self.command_prefix = command_prefix
+
+    @property
+    def name(self) -> str:
+        return self.runner.value
+
+    def execute(self, *args: str) -> Sequence[str | bytes]:
+        return [*self.command_prefix, self.runner.value, *args]
+
+    def is_installed(self) -> bool:
+        """Check if this runner is installed by running its --version command."""
+        try:
+            output = subprocess.check_output(self.execute("--version")).decode()  # noqa: S603
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+        else:
+            return self.runner.value in output
+
+    @classmethod
+    def resolve(
+        cls,
+        hook_runner: HookRunner,
+        command_prefix: Sequence[str] = (),
+        printer: Printer | None = None,
+    ) -> ResolvedHookRunner | None:
+        """Resolve a HookRunner config to a concrete ResolvedHookRunner, or None if not found."""
+        candidates = cls._AUTO_ORDER if hook_runner is HookRunner.AUTO else [hook_runner]
+        for candidate in candidates:
+            runner = cls(candidate, command_prefix)
+            if runner.is_installed():
+                if hook_runner is HookRunner.AUTO and printer:
+                    printer.debug(f"Auto-detected hook runner: {candidate.value}")
+                return runner
+        return None
+
 
-    def __init__(self, printer: Printer, dry_run: bool = False) -> None:
+class SetupPreCommitHooks:
+    command_prefix: ClassVar[Sequence[str]] = ()
+
+    def __init__(
+        self,
+        printer: Printer,
+        dry_run: bool = False,
+        hook_runner: HookRunner = HookRunner.PRE_COMMIT,
+    ) -> None:
         self.printer = printer
         self.dry_run = dry_run
+        self.hook_runner = hook_runner
 
     def execute(self) -> None:
-        if not self._is_pre_commit_package_installed():
-            self.printer.debug("pre-commit package is not installed (or detected). Skipping.")
+        runner = ResolvedHookRunner.resolve(self.hook_runner, self.command_prefix, self.printer)
+        if runner is None:
+            self.printer.debug("No hook runner (pre-commit or prek) is installed (or detected). Skipping.")
             return
 
         git_root = self._get_git_directory_path()
@@ -39,36 +91,25 @@ def execute(self) -> None:
             self.printer.debug("Dry run, skipping pre-commit hook installation.")
             return
 
-        self._install_pre_commit_hooks()
+        self._install_hooks(runner)
 
-    def _install_pre_commit_hooks(self) -> None:
+    def _install_hooks(self, runner: ResolvedHookRunner) -> None:
         try:
-            self.printer.info("Installing pre-commit hooks...")
+            self.printer.info(f"Installing {runner.name} hooks...")
             return_code = subprocess.check_call(  # noqa: S603
-                self.install_pre_commit_hooks_command,
+                runner.execute("install"),
                 # XXX We probably want to see the output, at least in verbose mode or if it fails
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
             )
             if return_code == 0:
-                self.printer.info("pre-commit hooks successfully installed!")
+                self.printer.info(f"{runner.name} hooks successfully installed!")
             else:
-                self.printer.error("Failed to install pre-commit hooks")
+                self.printer.error(f"Failed to install {runner.name} hooks")
         except Exception as e:
-            self.printer.error("Failed to install pre-commit hooks due to an unexpected error")
+            self.printer.error(f"Failed to install {runner.name} hooks due to an unexpected error")
             self.printer.error(f"{e}")
 
-    def _is_pre_commit_package_installed(self) -> bool:
-        try:
-            # Try is `pre-commit --version` works
-            output = subprocess.check_output(  # noqa: S603
-                self.check_pre_commit_version_command,
-            ).decode()
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            return False
-        else:
-            return "pre-commit" in output
-
     @staticmethod
     def _are_pre_commit_hooks_installed(git_root: Path) -> bool:
         return (git_root / "hooks" / "pre-commit").exists()

src/sync_pre_commit_lock/config.py

@@ -2,6 +2,7 @@
 
 import os
 from dataclasses import dataclass, field
+from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, TypedDict
 
@@ -10,6 +11,15 @@
 if TYPE_CHECKING:
     from sync_pre_commit_lock.db import PackageRepoMapping
 
+
+class HookRunner(str, Enum):
+    """The hook runner to use for installing git hooks."""
+
+    PRE_COMMIT = "pre-commit"
+    PREK = "prek"
+    AUTO = "auto"
+
+
 ENV_PREFIX = "SYNC_PRE_COMMIT_LOCK"
 
 
@@ -74,6 +84,10 @@ class SyncPreCommitLockConfig:
         default_factory=dict,
         metadata=Metadata(toml="dependency-mapping"),
     )
+    hook_runner: HookRunner = field(
+        default=HookRunner.PRE_COMMIT,
+        metadata=Metadata(toml="hook-runner", env="HOOK_RUNNER", cast=HookRunner),
+    )
 
 
 def load_config(path: Path | None = None) -> SyncPreCommitLockConfig:

src/sync_pre_commit_lock/pdm_plugin.py

@@ -132,8 +132,7 @@ def register_pdm_plugin(core: Core) -> None:
 
 
 class PDMSetupPreCommitHooks(SetupPreCommitHooks):
-    install_pre_commit_hooks_command: ClassVar[Sequence[str | bytes]] = ["pdm", "run", "pre-commit", "install"]
-    check_pre_commit_version_command: ClassVar[Sequence[str | bytes]] = ["pdm", "run", "pre-commit", "--version"]
+    command_prefix: ClassVar[Sequence[str]] = ("pdm", "run")
 
 
 class PDMSyncPreCommitHooksVersion(SyncPreCommitHooksVersion):
@@ -150,7 +149,7 @@ def on_pdm_install_setup_pre_commit(project: Project, *, dry_run: bool, **_: Any
     if not plugin_config.automatically_install_hooks:
         printer.debug("Automatically installing pre-commit hooks is disabled. Skipping.")
         return
-    action = PDMSetupPreCommitHooks(printer, dry_run=dry_run)
+    action = PDMSetupPreCommitHooks(printer, dry_run=dry_run, hook_runner=plugin_config.hook_runner)
     file_path = project.root / plugin_config.pre_commit_config_file
     if not file_path.exists():
         printer.info("No pre-commit config file found, skipping pre-commit hook check")

src/sync_pre_commit_lock/poetry_plugin.py

@@ -136,8 +136,7 @@ def _format_additional_dependency(self, old: str, new: str, prefix: str, last: b
 
 
 class PoetrySetupPreCommitHooks(SetupPreCommitHooks):
-    install_pre_commit_hooks_command: ClassVar[Sequence[str | bytes]] = ["poetry", "run", "pre-commit", "install"]
-    check_pre_commit_version_command: ClassVar[Sequence[str | bytes]] = ["poetry", "run", "pre-commit", "--version"]
+    command_prefix: ClassVar[Sequence[str]] = ("poetry", "run")
 
 
 def run_sync_pre_commit_version(printer: PoetryPrinter, dry_run: bool, application: Application) -> None:
@@ -186,7 +185,8 @@ def _handle_post_command(
             return
 
         if any(isinstance(command, t) for t in [InstallCommand, AddCommand]):
-            PoetrySetupPreCommitHooks(printer, dry_run=dry_run).execute()
+            plugin_config = load_config(self.application.poetry.pyproject_path) if self.application else load_config()
+            PoetrySetupPreCommitHooks(printer, dry_run=dry_run, hook_runner=plugin_config.hook_runner).execute()
 
         if any(isinstance(command, t) for t in [InstallCommand, AddCommand, LockCommand, UpdateCommand]):
             if self.application is None: