feat(cli): Add install-hook subcommand 🔧

- introduce InstallHook command in CLI with repo_path argument

Signed-off-by: mingcheng <mingcheng@apache.org>

Author: mingcheng

src/cli.rs

@@ -13,11 +13,13 @@
  */
 
 use crate::built_info;
-use clap::Parser;
+use clap::{Parser, Subcommand};
 
 #[derive(Debug, Parser)]
 #[command(name = built_info::PKG_NAME, about = built_info::PKG_DESCRIPTION, version = built_info::PKG_VERSION, author = built_info::PKG_AUTHORS)]
 pub struct Cli {
+    #[command(subcommand)]
+    pub command: Option<Command>,
     #[arg(
         default_value = ".",
         help = r#"Specify the file path to repository directory.
@@ -110,5 +112,21 @@ If not specified, the current directory will be used"#,
     pub save: String,
 }
 
+#[derive(Debug, Subcommand)]
+pub enum Command {
+    #[command(
+        name = "install-hook",
+        about = "Install git hook script into the specified repository directory"
+    )]
+    InstallHook {
+        #[arg(
+            default_value = ".",
+            help = "Repository directory to install the git hook into",
+            required = false
+        )]
+        repo_path: String,
+    },
+}
+
 #[cfg(test)]
 mod tests {}

src/main.rs

@@ -13,7 +13,7 @@
  */
 
 use aigitcommit::built_info::{PKG_NAME, PKG_VERSION};
-use aigitcommit::cli::Cli;
+use aigitcommit::cli::{Cli, Command};
 use aigitcommit::git::message::GitMessage;
 use aigitcommit::git::repository::Repository;
 use aigitcommit::openai::OpenAI;
@@ -27,23 +27,35 @@ use std::io::Write;
 use std::path::Path;
 use tracing::{Level, debug, error, info, trace};
 
-use aigitcommit::utils::{OutputFormat, check_env_variables, env, save_to_file, should_signoff};
+use aigitcommit::utils::{
+    self, OutputFormat, check_env_variables, env, install_hook, save_to_file, should_signoff,
+};
 
 // Constants for better performance and maintainability
 const DEFAULT_MODEL: &str = "gpt-5";
 const DEFAULT_LOG_COUNT: usize = 5;
 const SYSTEM_PROMPT: &str = include_str!("../templates/system.txt");
 
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+// Constant for git hook installation
+const HOOK_NAME: &str = "prepare-commit-msg";
+const HOOK_CONTENT: &str = include_str!("../hooks/prepare-commit-msg");
 
 #[tokio::main]
-async fn main() -> Result<()> {
+async fn main() -> utils::Result<()> {
     // Parse command line arguments
     let cli = Cli::parse();
 
     // Initialize logging
     init_logging(cli.verbose);
 
+    // Handle subcommands early and exit
+    if let Some(Command::InstallHook { repo_path }) = &cli.command {
+        trace!("install-hook subcommand invoked");
+        install_hook(repo_path, HOOK_NAME, HOOK_CONTENT)?;
+        println!("git hook `{}` has been installed successfully.", HOOK_NAME);
+        return Ok(());
+    }
+
     // Get the specified model name from environment variable, default constant
     let model_name = env::get("OPENAI_MODEL_NAME", DEFAULT_MODEL);
 
@@ -197,7 +209,7 @@ fn init_logging(verbose: bool) {
 }
 
 /// Check if the model is available
-async fn check_model_availability(client: &OpenAI, model_name: &str) -> Result<()> {
+async fn check_model_availability(client: &OpenAI, model_name: &str) -> utils::Result<()> {
     client.check_model(model_name).await?;
     println!(
         "the model name `{}` is available, {} is ready for use!",

src/utils.rs

@@ -14,9 +14,14 @@
 
 use crate::git::message::GitMessage;
 use crate::git::repository::Repository;
+use std::fs;
 use std::io::Write;
+use tracing::trace;
 
-// Get environment variable with default value fallback
+/// Generic result type for utility functions
+pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+
+/// Get environment variable with default value fallback
 pub mod env {
     use std::env;
 
@@ -84,7 +89,7 @@ impl OutputFormat {
     }
 
     /// Write the message in the specified format
-    pub fn write(&self, message: &GitMessage) -> Result<(), Box<dyn std::error::Error>> {
+    pub fn write(&self, message: &GitMessage) -> Result<()> {
         match self {
             Self::Stdout => {
                 writeln!(std::io::stdout(), "{}", message)?;
@@ -149,10 +154,7 @@ pub fn format_openai_error(error: async_openai::error::OpenAIError) -> String {
 }
 
 /// Save content to a file
-pub fn save_to_file(
-    path: &str,
-    content: &dyn std::fmt::Display,
-) -> Result<(), Box<dyn std::error::Error>> {
+pub fn save_to_file(path: &str, content: &dyn std::fmt::Display) -> Result<()> {
     use std::fs::File;
     use std::io::Write;
 
@@ -162,6 +164,36 @@ pub fn save_to_file(
     Ok(())
 }
 
+/// Install the prepare-commit-msg git hook into the target repository.
+pub fn install_hook(path: &str, name: &str, content: &str) -> Result<()> {
+    let repo_dir =
+        fs::canonicalize(path).map_err(|e| format!("resolve repository path failed: {e}"))?;
+    let git_dir = repo_dir.join(".git");
+    if !git_dir.is_dir() {
+        return Err("not a git repository (missing .git directory)".into());
+    }
+
+    let hooks_dir = git_dir.join("hooks");
+    fs::create_dir_all(&hooks_dir).map_err(|e| format!("create hooks dir failed: {e}"))?;
+
+    let hook_path = hooks_dir.join(name);
+    fs::write(&hook_path, content).map_err(|e| format!("write hook file failed: {e}"))?;
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let mut perms = fs::metadata(&hook_path)
+            .map_err(|e| format!("get hook metadata failed: {e}"))?
+            .permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(&hook_path, perms)
+            .map_err(|e| format!("set executable permission failed: {e}"))?;
+    }
+
+    trace!("hook installed at {:?}", hook_path);
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -194,4 +226,10 @@ Signed-off-by: mingcheng <mingcheng@apache.org>
         let result = env::get("NONEXISTENT_VAR_XYZ", "default_value");
         assert_eq!(result, "default_value");
     }
+
+    #[test]
+    fn test_install_hook() {
+        let result = install_hook(".", "test-hook", "#!/bin/sh\necho 'Test Hook'");
+        assert!(result.is_ok());
+    }
 }