feat(try-repo): add support for builtin and meta repos

Add `try-repo builtin` and `try-repo meta` commands to test built-in
and meta hooks without needing a git repository.

Changes:
- Add strum crate for enum derives (EnumIter, EnumString, IntoStaticStr)
- Replace manual FromStr implementations with strum derives
- Add HookRegistry trait to abstract over BuiltinHooks and MetaHooks
- Implement try_special_repo<H: HookRegistry>() for generic handling
- Add case-insensitive matching for "builtin" and "meta" keywords
- Warn when --ref is used with special repos (ignored)
- Add empty hooks check to try_git_repo for consistency
- Add comprehensive integration tests for all new functionality

Author: shaanmajid

Cargo.lock

@@ -72,6 +72,7 @@ rustix = { version = "1.0.8", features = ["pty", "process", "fs", "termios"] }
 same-file = { version = "1.0.6" }
 semver = { version = "1.0.24", features = ["serde"] }
 serde = { version = "1.0.210", features = ["derive"] }
+strum = "0.26"
 serde_json = { version = "1.0.132", features = ["unbounded_depth"] }
 serde_stacker = { version = "0.1.12" }
 serde-saphyr = { version = "0.0.17", default-features = false }

Cargo.toml

@@ -79,6 +79,7 @@ serde_stacker = { workspace = true }
 serde-saphyr = { workspace = true, default-features = false }
 shlex = { workspace = true }
 smallvec = { workspace = true }
+strum = { workspace = true, features = ["derive"] }
 target-lexicon = { workspace = true }
 tempfile = { workspace = true }
 thiserror = { workspace = true }

crates/prek/Cargo.toml

@@ -2,7 +2,7 @@ use std::borrow::Cow;
 use std::fmt::Write;
 use std::path::{Path, PathBuf};
 
-use anyhow::{Context, Result};
+use anyhow::{Context, Result, bail};
 use itertools::Itertools;
 use owo_colors::OwoColorize;
 use tempfile::TempDir;
@@ -12,10 +12,21 @@ use crate::cli::run::Selectors;
 use crate::config;
 use crate::git;
 use crate::git::GIT_ROOT;
+use crate::hooks::{BuiltinHooks, HookRegistry, MetaHooks};
 use crate::printer::Printer;
 use crate::store::Store;
 use crate::warn_user;
 
+/// Categorizes the repo argument into different types.
+enum RepoType<'a> {
+    /// A git repository (local path or remote URL)
+    Git { repo: &'a str, rev: Option<&'a str> },
+    /// The special "builtin" keyword for builtin hooks
+    Builtin,
+    /// The special "meta" keyword for meta hooks
+    Meta,
+}
+
 async fn get_head_rev(repo: &Path) -> Result<String> {
     let head_rev = git::git_cmd("get head rev")?
         .arg("rev-parse")
@@ -148,51 +159,91 @@ pub(crate) async fn try_repo(
         warn_user!("`--config` option is ignored when using `try-repo`");
     }
 
-    let store = Store::from_settings()?;
-    let tmp_dir = TempDir::with_prefix_in("try-repo-", store.scratch_path())?;
+    // Categorize the repo argument (case-insensitive for special keywords)
+    let repo_type = if repo.eq_ignore_ascii_case("builtin") {
+        if rev.is_some() {
+            warn_user!("`--ref` option is ignored for `builtin` repo");
+        }
+        RepoType::Builtin
+    } else if repo.eq_ignore_ascii_case("meta") {
+        if rev.is_some() {
+            warn_user!("`--ref` option is ignored for `meta` repo");
+        }
+        RepoType::Meta
+    } else {
+        RepoType::Git {
+            repo: &repo,
+            rev: rev.as_deref(),
+        }
+    };
 
-    let (repo_path, rev) = prepare_repo_and_rev(&repo, rev.as_deref(), tmp_dir.path())
-        .await
-        .context("Failed to determine repository and revision")?;
+    match repo_type {
+        RepoType::Builtin => {
+            try_special_repo::<BuiltinHooks>(run_args, refresh, verbose, printer).await
+        }
+        RepoType::Meta => try_special_repo::<MetaHooks>(run_args, refresh, verbose, printer).await,
+        RepoType::Git { repo, rev } => {
+            try_git_repo(repo, rev, run_args, refresh, verbose, printer).await
+        }
+    }
+}
+
+/// Try hooks from a special repository (builtin or meta).
+async fn try_special_repo<H: HookRegistry>(
+    run_args: crate::cli::RunArgs,
+    refresh: bool,
+    verbose: bool,
+    printer: Printer,
+) -> Result<ExitStatus> {
+    let repo_name = H::REPO_NAME;
 
+    let store = Store::from_settings()?;
+    let tmp_dir = TempDir::with_prefix_in("try-repo-", store.scratch_path())?;
     let store = Store::from_path(tmp_dir.path()).init()?;
-    let repo_clone_path = store
-        .clone_repo(
-            &config::RemoteRepo::new(repo_path.to_string(), rev.clone(), vec![]),
-            None,
-        )
-        .await?;
 
     let selectors = Selectors::load(&run_args.includes, &run_args.skips, GIT_ROOT.as_ref()?)?;
 
-    let manifest = config::read_manifest(&repo_clone_path.join(prek_consts::MANIFEST_FILE))?;
-    let hooks_str = manifest
-        .hooks
-        .into_iter()
-        .filter(|hook| selectors.matches_hook_id(&hook.id))
-        .map(|hook| format!("{}- id: {}", " ".repeat(6), hook.id))
+    // Filter hook IDs based on selectors
+    let hook_ids: Vec<_> = H::all_ids()
+        .filter(|id| selectors.matches_hook_id(id))
+        .collect();
+
+    if hook_ids.is_empty() {
+        bail!("No hooks matched the specified selectors for repo `{repo_name}`");
+    }
+
+    let hooks_str = hook_ids
+        .iter()
+        .map(|id| format!("{}- id: {}", " ".repeat(6), id))
         .join("\n");
 
     let config_str = indoc::formatdoc! {r"
     repos:
-      - repo: {repo_path}
-        rev: {rev}
+      - repo: {repo_name}
         hooks:
     {hooks_str}
-    ",
-        repo_path = repo_path,
-        rev = rev,
-        hooks_str = hooks_str,
-    };
+    "};
 
     let config_file = tmp_dir.path().join(prek_consts::CONFIG_FILE);
     fs_err::tokio::write(&config_file, &config_str).await?;
 
     writeln!(printer.stdout(), "{}", "Using config:".cyan().bold())?;
     write!(printer.stdout(), "{}", config_str.dimmed())?;
 
+    invoke_run(&store, config_file, run_args, refresh, verbose, printer).await
+}
+
+/// Helper to call `crate::cli::run` with common arguments.
+async fn invoke_run(
+    store: &Store,
+    config_file: PathBuf,
+    run_args: crate::cli::RunArgs,
+    refresh: bool,
+    verbose: bool,
+    printer: Printer,
+) -> Result<ExitStatus> {
     crate::cli::run(
-        &store,
+        store,
         Some(config_file),
         vec![],
         vec![],
@@ -213,3 +264,63 @@ pub(crate) async fn try_repo(
     )
     .await
 }
+
+/// Try hooks from a git repository (local path or remote URL).
+async fn try_git_repo(
+    repo: &str,
+    rev: Option<&str>,
+    run_args: crate::cli::RunArgs,
+    refresh: bool,
+    verbose: bool,
+    printer: Printer,
+) -> Result<ExitStatus> {
+    let store = Store::from_settings()?;
+    let tmp_dir = TempDir::with_prefix_in("try-repo-", store.scratch_path())?;
+
+    let (repo_path, rev) = prepare_repo_and_rev(repo, rev, tmp_dir.path())
+        .await
+        .context("Failed to determine repository and revision")?;
+
+    let store = Store::from_path(tmp_dir.path()).init()?;
+    let repo_clone_path = store
+        .clone_repo(
+            &config::RemoteRepo::new(repo_path.to_string(), rev.clone(), vec![]),
+            None,
+        )
+        .await?;
+
+    let selectors = Selectors::load(&run_args.includes, &run_args.skips, GIT_ROOT.as_ref()?)?;
+
+    let manifest = config::read_manifest(&repo_clone_path.join(prek_consts::MANIFEST_FILE))?;
+    let hook_ids: Vec<_> = manifest
+        .hooks
+        .into_iter()
+        .filter(|hook| selectors.matches_hook_id(&hook.id))
+        .map(|hook| hook.id)
+        .collect();
+
+    if hook_ids.is_empty() {
+        bail!("No hooks matched the specified selectors for repo");
+    }
+
+    let hooks_str = hook_ids
+        .iter()
+        .map(|id| format!("{}- id: {}", " ".repeat(6), id))
+        .join("\n");
+
+    let config_str = indoc::formatdoc! {r"
+    repos:
+      - repo: {repo_path}
+        rev: {rev}
+        hooks:
+    {hooks_str}
+    "};
+
+    let config_file = tmp_dir.path().join(prek_consts::CONFIG_FILE);
+    fs_err::tokio::write(&config_file, &config_str).await?;
+
+    writeln!(printer.stdout(), "{}", "Using config:".cyan().bold())?;
+    write!(printer.stdout(), "{}", config_str.dimmed())?;
+
+    invoke_run(&store, config_file, run_args, refresh, verbose, printer).await
+}

crates/prek/src/cli/try_repo.rs

@@ -2,6 +2,7 @@ use std::path::Path;
 use std::str::FromStr;
 
 use anyhow::Result;
+use strum::{EnumIter, EnumString, IntoStaticStr};
 
 use crate::cli::reporter::HookRunReporter;
 use crate::config::{BuiltinHook, HookOptions, Stage};
@@ -11,9 +12,10 @@ use crate::store::Store;
 
 mod check_json5;
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, EnumIter, EnumString, IntoStaticStr)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[cfg_attr(feature = "schemars", schemars(rename_all = "kebab-case"))]
+#[strum(serialize_all = "kebab-case")]
 pub(crate) enum BuiltinHooks {
     CheckAddedLargeFiles,
     CheckCaseConflict,
@@ -33,32 +35,6 @@ pub(crate) enum BuiltinHooks {
     TrailingWhitespace,
 }
 
-impl FromStr for BuiltinHooks {
-    type Err = ();
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        match s {
-            "check-added-large-files" => Ok(Self::CheckAddedLargeFiles),
-            "check-case-conflict" => Ok(Self::CheckCaseConflict),
-            "check-executables-have-shebangs" => Ok(Self::CheckExecutablesHaveShebangs),
-            "check-json" => Ok(Self::CheckJson),
-            "check-json5" => Ok(Self::CheckJson5),
-            "check-merge-conflict" => Ok(Self::CheckMergeConflict),
-            "check-symlinks" => Ok(Self::CheckSymlinks),
-            "check-toml" => Ok(Self::CheckToml),
-            "check-xml" => Ok(Self::CheckXml),
-            "check-yaml" => Ok(Self::CheckYaml),
-            "detect-private-key" => Ok(Self::DetectPrivateKey),
-            "end-of-file-fixer" => Ok(Self::EndOfFileFixer),
-            "fix-byte-order-marker" => Ok(Self::FixByteOrderMarker),
-            "mixed-line-ending" => Ok(Self::MixedLineEnding),
-            "no-commit-to-branch" => Ok(Self::NoCommitToBranch),
-            "trailing-whitespace" => Ok(Self::TrailingWhitespace),
-            _ => Err(()),
-        }
-    }
-}
-
 impl BuiltinHooks {
     pub(crate) async fn run(
         self,
@@ -103,7 +79,7 @@ impl BuiltinHooks {
 
 impl BuiltinHook {
     pub(crate) fn from_id(id: &str) -> Result<Self, ()> {
-        let hook_id = BuiltinHooks::from_str(id)?;
+        let hook_id = BuiltinHooks::from_str(id).map_err(|_| ())?;
         Ok(match hook_id {
             BuiltinHooks::CheckAddedLargeFiles => BuiltinHook {
                 id: "check-added-large-files".to_string(),
@@ -298,3 +274,22 @@ impl BuiltinHook {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use strum::IntoEnumIterator;
+
+    #[test]
+    fn strum_derives_work() {
+        // Verify iteration produces the expected count
+        assert_eq!(BuiltinHooks::iter().count(), 16);
+
+        // Verify FromStr roundtrip works for all variants
+        for variant in BuiltinHooks::iter() {
+            let id: &'static str = variant.into();
+            let parsed = BuiltinHooks::from_str(id).expect("roundtrip should work");
+            assert_eq!(parsed, variant);
+        }
+    }
+}