fix(init): use prek when installing hooks if pre-commit is missing

cz init already treated prek as installed, but always ran
`pre-commit install`, which raised FileNotFoundError when only prek
was on PATH. Use the available installer, and ask when both exist.

Fixes #2018

Author: DSeaStar

commitizen/commands/init.py

@@ -128,13 +128,9 @@ def __call__(self) -> None:
             ) as config_file:
                 yaml.safe_dump(config_data, stream=config_file)
 
-            if not project_info.is_pre_commit_installed():
-                raise InitFailedError(
-                    "Failed to install pre-commit hook.\n"
-                    "pre-commit is not installed in current environment."
-                )
+            installer = self._ask_hook_installer()
 
-            cmd_args = ["pre-commit", "install"]
+            cmd_args = [installer, "install"]
             for ty in hook_types:
                 cmd_args.extend(["--hook-type", ty])
             c = cmd.run(cmd_args)
@@ -164,6 +160,29 @@ def __call__(self) -> None:
         out.info("\tcz bump\n")
         out.success("Configuration complete 🚀")
 
+    def _ask_hook_installer(self) -> str:
+        """Choose ``pre-commit`` or ``prek`` when installing Git hooks.
+
+        Detection already accepts either tool, but install used to
+        hard-code ``pre-commit``. Use the only available installer, or
+        ask when both are on PATH.
+        """
+        installers = project_info.available_hook_installers()
+        if not installers:
+            raise InitFailedError(
+                "Failed to install pre-commit hook.\n"
+                "Neither pre-commit nor prek is installed in the current environment."
+            )
+        if len(installers) == 1:
+            return installers[0]
+
+        installer: str = questionary.select(
+            "Which hook installer do you want to use?",
+            choices=installers,
+            style=self.cz.style,
+        ).unsafe_ask()
+        return installer
+
     def _ask_config_path(self) -> Path:
         filename: str = questionary.select(
             "Please choose a supported config file: ",

commitizen/project_info.py

@@ -4,9 +4,22 @@
 from pathlib import Path
 from typing import Literal
 
+_HOOK_INSTALLERS = ("pre-commit", "prek")
+
+
+def available_hook_installers() -> list[str]:
+    """Return hook installer CLIs found on PATH.
+
+    ``pre-commit`` and ``prek`` are interchangeable. ``pre-commit`` is
+    listed first when both are present so existing setups keep a stable
+    default unless the user is asked to choose.
+    """
+    return [tool for tool in _HOOK_INSTALLERS if shutil.which(tool)]
+
 
 def is_pre_commit_installed() -> bool:
-    return any(shutil.which(tool) for tool in ("pre-commit", "prek"))
+    """Return whether any supported hook installer is on PATH."""
+    return bool(available_hook_installers())
 
 
 def get_default_version_provider() -> Literal[

docs/commands/init.md

@@ -43,7 +43,7 @@ During the initialization process, you'll be prompted to configure the following
     - `pep440`: Python Package Versioning
 6. **Changelog Generation**: Configure whether to automatically generate changelog during version bumps
 7. **Alpha Versioning**: Option to keep major version at 0 for alpha/beta software
-8. **Pre-commit Hooks**: Set up Git pre-commit hooks for automated commit message validation
+8. **Pre-commit Hooks**: Set up Git hooks for automated commit message validation. If you choose to install hooks, Commitizen uses `pre-commit` or `prek` (whichever is on PATH). If both are installed, you are asked which one to use.
 
 See [Configuration Options][configuration_options] for more details.
 

tests/commands/test_init_command.py

@@ -121,10 +121,10 @@ def test_init_without_choosing_tag(
 
 @pytest.fixture
 def pre_commit_installed(mocker: MockFixture):
-    # Assume the `pre-commit` is installed
+    # Assume only `pre-commit` is installed
     mocker.patch(
-        "commitizen.project_info.is_pre_commit_installed",
-        return_value=True,
+        "commitizen.project_info.available_hook_installers",
+        return_value=["pre-commit"],
     )
     # And installation success (i.e. no exception raised)
     mocker.patch(
@@ -232,16 +232,117 @@ class TestNoPreCommitInstalled:
     def test_pre_commit_not_installed(
         self, mocker: MockFixture, config: BaseConfig, tmp_path, monkeypatch
     ):
-        # Assume `pre-commit` is not installed
+        # Assume neither `pre-commit` nor `prek` is installed
         mocker.patch(
-            "commitizen.project_info.is_pre_commit_installed",
-            return_value=False,
+            "commitizen.project_info.available_hook_installers",
+            return_value=[],
         )
         monkeypatch.chdir(tmp_path)
         with pytest.raises(InitFailedError):
             commands.Init(config)()
 
 
+def _init_hook_answers(mocker: MockFixture) -> None:
+    """Stub the interactive init prompts and select hook installation."""
+    mocker.patch(
+        "questionary.select",
+        side_effect=[
+            FakeQuestion("pyproject.toml"),
+            FakeQuestion("cz_conventional_commits"),
+            FakeQuestion("commitizen"),
+            FakeQuestion("semver"),
+        ],
+    )
+    mocker.patch("questionary.confirm", return_value=FakeQuestion(True))
+    mocker.patch("questionary.text", return_value=FakeQuestion("$version"))
+    mocker.patch(
+        "questionary.checkbox",
+        return_value=FakeQuestion(["commit-msg", "pre-push"]),
+    )
+
+
+class TestHookInstallerSelection:
+    def test_uses_prek_when_only_prek_is_installed(
+        self, mocker: MockFixture, config: BaseConfig, tmp_path, monkeypatch
+    ):
+        _init_hook_answers(mocker)
+        mocker.patch(
+            "commitizen.project_info.available_hook_installers",
+            return_value=["prek"],
+        )
+        run = mocker.patch(
+            "commitizen.cmd.run",
+            return_value=cmd.Command("", "", b"", b"", 0),
+        )
+        monkeypatch.chdir(tmp_path)
+
+        commands.Init(config)()
+
+        run.assert_any_call(
+            ["prek", "install", "--hook-type", "commit-msg", "--hook-type", "pre-push"]
+        )
+
+    def test_asks_when_both_installers_are_present(
+        self, mocker: MockFixture, config: BaseConfig, tmp_path, monkeypatch
+    ):
+        mocker.patch(
+            "questionary.select",
+            side_effect=[
+                FakeQuestion("pyproject.toml"),
+                FakeQuestion("cz_conventional_commits"),
+                FakeQuestion("commitizen"),
+                FakeQuestion("semver"),
+                FakeQuestion("prek"),
+            ],
+        )
+        mocker.patch("questionary.confirm", return_value=FakeQuestion(True))
+        mocker.patch("questionary.text", return_value=FakeQuestion("$version"))
+        mocker.patch(
+            "questionary.checkbox",
+            return_value=FakeQuestion(["commit-msg"]),
+        )
+        mocker.patch(
+            "commitizen.project_info.available_hook_installers",
+            return_value=["pre-commit", "prek"],
+        )
+        run = mocker.patch(
+            "commitizen.cmd.run",
+            return_value=cmd.Command("", "", b"", b"", 0),
+        )
+        monkeypatch.chdir(tmp_path)
+
+        commands.Init(config)()
+
+        run.assert_any_call(["prek", "install", "--hook-type", "commit-msg"])
+
+    def test_uses_pre_commit_when_only_pre_commit_is_installed(
+        self, mocker: MockFixture, config: BaseConfig, tmp_path, monkeypatch
+    ):
+        _init_hook_answers(mocker)
+        mocker.patch(
+            "commitizen.project_info.available_hook_installers",
+            return_value=["pre-commit"],
+        )
+        run = mocker.patch(
+            "commitizen.cmd.run",
+            return_value=cmd.Command("", "", b"", b"", 0),
+        )
+        monkeypatch.chdir(tmp_path)
+
+        commands.Init(config)()
+
+        run.assert_any_call(
+            [
+                "pre-commit",
+                "install",
+                "--hook-type",
+                "commit-msg",
+                "--hook-type",
+                "pre-push",
+            ]
+        )
+
+
 class TestAskTagFormat:
     def test_confirm_v_tag_format(self, mocker: MockFixture, config: BaseConfig):
         init = commands.Init(config)

tests/test_project_info.py

@@ -19,17 +19,26 @@ def _create_project_files(files: dict[str, str | None]) -> None:
 
 
 @pytest.mark.parametrize(
-    ("which_return", "expected"),
+    ("which_map", "expected"),
     [
-        ("/usr/local/bin/pre-commit", True),
-        ("/usr/local/bin/prek", True),
-        (None, False),
-        ("", False),
+        ({"pre-commit": "/usr/local/bin/pre-commit"}, ["pre-commit"]),
+        ({"prek": "/usr/local/bin/prek"}, ["prek"]),
+        (
+            {
+                "pre-commit": "/usr/local/bin/pre-commit",
+                "prek": "/usr/local/bin/prek",
+            },
+            ["pre-commit", "prek"],
+        ),
+        ({}, []),
+        ({"pre-commit": "", "prek": None}, []),
     ],
 )
-def test_is_pre_commit_installed(mocker, which_return, expected):
-    mocker.patch("shutil.which", return_value=which_return)
-    assert project_info.is_pre_commit_installed() is expected
+def test_available_hook_installers(mocker, which_map, expected):
+    mocker.patch("shutil.which", side_effect=lambda name: which_map.get(name))
+
+    assert project_info.available_hook_installers() == expected
+    assert project_info.is_pre_commit_installed() is bool(expected)
 
 
 @pytest.mark.parametrize(