Speed up hook diff processing

Cargo.toml

@@ -25,35 +25,38 @@ name = "git-ai-hook"
 path = "src/bin/hook.rs"
 
 [dependencies]
-anyhow = { version = "1.0.86", default-features = false }
-async-openai = { version = "0.18.3", default-features = false }
-colored = "2.1.0"
-config = { version = "0.13.4", default-features = false, features = ["ini"] }
-console = { version = "0.15.8", default-features = false }
-ctrlc = "3.4.4"
+anyhow = { version = "1.0.95", default-features = false }
+async-openai = { version = "0.27.2", default-features = false }
+colored = "3.0.0"
+config = { version = "0.15.7", default-features = false, features = ["ini"] }
+console = { version = "0.15.10", default-features = false }
+ctrlc = "3.4.5"
 dotenv = "0.15.0"
-env_logger = { version = "0.10.2", default-features = false }
-git2 = { version = "0.18.3", default-features = false }
-home = "0.5.9"
-indicatif = { version = "0.17.8", default-features = false }
-lazy_static = "1.4.0"
-log = "0.4.21"
-reqwest = { version = "0.11.27", default-features = true }
+env_logger = { version = "0.11.6", default-features = false }
+git2 = { version = "0.20.0", default-features = false }
+home = "0.5.11"
+indicatif = { version = "0.17.11", default-features = false }
+lazy_static = "1.5.0"
+log = "0.4.25"
+reqwest = { version = "0.12.12", default-features = true }
 serde = { version = "1", default-features = false }
-serde_derive = "1.0.203"
+serde_derive = "1.0.217"
 serde_ini = "0.2.0"
-serde_json = "1.0.117"
+serde_json = "1.0.138"
 structopt = "0.3.26"
-thiserror = "1.0.61"
-tokio = { version = "1.38.0", features = ["rt-multi-thread"] }
-tiktoken-rs = { version = "0.5.9" }
-openssl-sys = { version = "0.9.102", features = ["vendored"] }
+thiserror = "2.0.11"
+tokio = { version = "1.43.0", features = ["rt-multi-thread"] }
+tiktoken-rs = { version = "0.6.0" }
+openssl-sys = { version = "0.9.105", features = ["vendored"] }
+rayon = "1.10.0"
+parking_lot = "0.12.3"
+num_cpus = "1.16.0"
 
 [dev-dependencies]
-tempfile = "3.10.1"
-anyhow = { version = "1.0.86", default-features = false }
-git2 = { version = "0.18.3", default-features = false }
-rand = { version = "0.8.5", default-features = false }
+tempfile = "3.16.0"
+anyhow = { version = "1.0.95", default-features = false }
+git2 = { version = "0.20.0", default-features = false }
+rand = { version = "0.9.0", default-features = false }
 
 [profile.release]
 codegen-units = 1

src/bin/hook.rs

@@ -105,7 +105,7 @@ impl Args {
       bail!("No changes to commit");
     }
 
-    let response = commit::generate(patch.to_string(), remaining_tokens, model).await?;
+    let response = commit::generate_commit_message(patch.to_string(), remaining_tokens, model).await?;
     std::fs::write(&self.commit_msg_file, response.response.trim())?;
     pb.finish_and_clear();
 
@@ -124,7 +124,7 @@ impl Args {
           .clone()
           .unwrap_or("gpt-4o".to_string())
           .into();
-        let used_tokens = commit::token_used(&model)?;
+        let used_tokens = commit::get_instruction_token_count(&model)?;
         let max_tokens = config::APP.max_tokens.unwrap_or(model.context_size());
         let remaining_tokens = max_tokens.saturating_sub(used_tokens);
 

src/commit.rs

@@ -1,42 +1,84 @@
 use anyhow::{bail, Result};
 
-use crate::{config, openai};
+use crate::{config, openai, profile};
 use crate::model::Model;
 
-fn instruction() -> String {
-  format!("You are an AI assistant that generates concise and meaningful git commit messages based on provided diffs. Please adhere to the following guidelines:
+const INSTRUCTION_TEMPLATE: &str = r#"You are an AI assistant that generates concise and meaningful git commit messages based on provided diffs. Please adhere to the following guidelines:
 
-  - Structure: Begin with a clear, present-tense summary.
-  - Content: Emphasize the changes and their rationale, excluding irrelevant details.
-  - Consistency: Maintain uniformity in tense, punctuation, and capitalization.
-  - Accuracy: Ensure the message accurately reflects the changes and their purpose.
-  - Present tense, imperative mood. (e.g., 'Add x to y' instead of 'Added x to y')
-  - Max {} chars in the output
+- Structure: Begin with a clear, present-tense summary.
+- Content: Emphasize the changes and their rationale, excluding irrelevant details.
+- Consistency: Maintain uniformity in tense, punctuation, and capitalization.
+- Accuracy: Ensure the message accurately reflects the changes and their purpose.
+- Present tense, imperative mood. (e.g., 'Add x to y' instead of 'Added x to y')
+- Max {} chars in the output
 
-  ## Output:
+## Output:
 
-  Your output should be a commit message generated from the input diff and nothing else.
+Your output should be a commit message generated from the input diff and nothing else.
 
-  ## Input:
+## Input:
 
-  INPUT:", config::APP.max_commit_length.unwrap_or(72))
-}
+INPUT:"#;
 
-pub fn token_used(model: &Model) -> Result<usize> {
-  model.count_tokens(&instruction())
+/// Returns the instruction template for the AI model.
+/// This template guides the model in generating appropriate commit messages.
+fn get_instruction_template() -> String {
+  profile!("Generate instruction template");
+  INSTRUCTION_TEMPLATE.replace("{}", &config::APP.max_commit_length.unwrap_or(72).to_string())
 }
 
-pub async fn generate(diff: String, max_tokens: usize, model: Model) -> Result<openai::Response> {
-  if max_tokens == 0 {
-    bail!("Max can't be zero (2)")
-  }
+/// Calculates the number of tokens used by the instruction template.
+///
+/// # Arguments
+/// * `model` - The AI model to use for token counting
+///
+/// # Returns
+/// * `Result<usize>` - The number of tokens used or an error
+pub fn get_instruction_token_count(model: &Model) -> Result<usize> {
+  profile!("Calculate instruction tokens");
+  model.count_tokens(&get_instruction_template())
+}
 
-  let request = openai::Request {
-    system: instruction(),
+/// Creates an OpenAI request for commit message generation.
+///
+/// # Arguments
+/// * `diff` - The git diff to generate a commit message for
+/// * `max_tokens` - Maximum number of tokens allowed for the response
+/// * `model` - The AI model to use for generation
+///
+/// # Returns
+/// * `openai::Request` - The prepared request
+fn create_commit_request(diff: String, max_tokens: usize, model: Model) -> openai::Request {
+  profile!("Prepare OpenAI request");
+  openai::Request {
+    system: get_instruction_template(),
     prompt: diff,
     max_tokens: max_tokens.try_into().unwrap_or(u16::MAX),
     model
-  };
+  }
+}
+
+/// Generates a commit message using the AI model.
+///
+/// # Arguments
+/// * `diff` - The git diff to generate a commit message for
+/// * `max_tokens` - Maximum number of tokens allowed for the response
+/// * `model` - The AI model to use for generation
+///
+/// # Returns
+/// * `Result<openai::Response>` - The generated commit message or an error
+///
+/// # Errors
+/// Returns an error if:
+/// - max_tokens is 0
+/// - OpenAI API call fails
+pub async fn generate_commit_message(diff: String, max_tokens: usize, model: Model) -> Result<openai::Response> {
+  profile!("Generate commit message");
+
+  if max_tokens == 0 {
+    bail!("Maximum token count must be greater than zero")
+  }
 
+  let request = create_commit_request(diff, max_tokens, model);
   openai::call(request).await
 }

src/config.rs

@@ -8,6 +8,13 @@ use anyhow::{Context, Result};
 use lazy_static::lazy_static;
 use console::Emoji;
 
+// Constants
+const DEFAULT_TIMEOUT: i64 = 30;
+const DEFAULT_MAX_COMMIT_LENGTH: i64 = 72;
+const DEFAULT_MAX_TOKENS: i64 = 2024;
+const DEFAULT_MODEL: &str = "gpt-4o-mini";
+const DEFAULT_API_KEY: &str = "<PLACE HOLDER FOR YOUR API KEY>";
+
 #[derive(Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
 pub struct App {
   pub openai_api_key:    Option<String>,
@@ -17,40 +24,51 @@ pub struct App {
   pub timeout:           Option<usize>
 }
 
-impl App {
-  #[allow(dead_code)]
-  pub fn duration(&self) -> std::time::Duration {
-    std::time::Duration::from_secs(self.timeout.unwrap_or(30) as u64)
-  }
+#[derive(Debug)]
+pub struct ConfigPaths {
+  pub dir:  PathBuf,
+  pub file: PathBuf
 }
 
 lazy_static! {
-    pub static ref CONFIG_DIR: PathBuf = home::home_dir().unwrap().join(".config/git-ai");
-    #[derive(Debug)]
-    pub static ref APP: App = App::new().expect("Failed to load config");
-    pub static ref CONFIG_PATH: PathBuf = CONFIG_DIR.join("config.ini");
+  static ref PATHS: ConfigPaths = ConfigPaths::new();
+  pub static ref APP: App = App::new().expect("Failed to load config");
+}
+
+impl ConfigPaths {
+  fn new() -> Self {
+    let dir = home::home_dir()
+      .expect("Failed to determine home directory")
+      .join(".config/git-ai");
+    let file = dir.join("config.ini");
+    Self { dir, file }
+  }
+
+  fn ensure_exists(&self) -> Result<()> {
+    if !self.dir.exists() {
+      std::fs::create_dir_all(&self.dir).with_context(|| format!("Failed to create config directory at {:?}", self.dir))?;
+    }
+    if !self.file.exists() {
+      File::create(&self.file).with_context(|| format!("Failed to create config file at {:?}", self.file))?;
+    }
+    Ok(())
+  }
 }
 
 impl App {
   pub fn new() -> Result<Self> {
     dotenv::dotenv().ok();
-
-    if !CONFIG_DIR.exists() {
-      std::fs::create_dir_all(CONFIG_DIR.to_str().unwrap()).context("Failed to create config directory")?;
-      File::create(CONFIG_PATH.to_str().unwrap()).context("Failed to create config file")?;
-    } else if !CONFIG_PATH.exists() {
-      File::create(CONFIG_PATH.to_str().unwrap()).context("Failed to create config file")?;
-    }
+    PATHS.ensure_exists()?;
 
     let config = Config::builder()
       .add_source(config::Environment::with_prefix("APP").try_parsing(true))
-      .add_source(config::File::new(CONFIG_PATH.to_str().unwrap(), FileFormat::Ini))
+      .add_source(config::File::new(PATHS.file.to_string_lossy().as_ref(), FileFormat::Ini))
       .set_default("language", "en")?
-      .set_default("timeout", 30)?
-      .set_default("max_commit_length", 72)?
-      .set_default("max_tokens", 2024)?
-      .set_default("model", "gpt-4o")?
-      .set_default("openai_api_key", "<PLACE HOLDER FOR YOUR API KEY>")?
+      .set_default("timeout", DEFAULT_TIMEOUT)?
+      .set_default("max_commit_length", DEFAULT_MAX_COMMIT_LENGTH)?
+      .set_default("max_tokens", DEFAULT_MAX_TOKENS)?
+      .set_default("model", DEFAULT_MODEL)?
+      .set_default("openai_api_key", DEFAULT_API_KEY)?
       .build()?;
 
     config
@@ -60,48 +78,62 @@ impl App {
 
   pub fn save(&self) -> Result<()> {
     let contents = serde_ini::to_string(&self).context(format!("Failed to serialize config: {:?}", self))?;
-    let mut file = File::create(CONFIG_PATH.to_str().unwrap()).context("Failed to create config file")?;
+    let mut file = File::create(&PATHS.file).with_context(|| format!("Failed to create config file at {:?}", PATHS.file))?;
     file
       .write_all(contents.as_bytes())
       .context("Failed to write config file")
   }
+
+  pub fn update_model(&mut self, value: String) -> Result<()> {
+    self.model = Some(value);
+    self.save_with_message("model")
+  }
+
+  pub fn update_max_tokens(&mut self, value: usize) -> Result<()> {
+    self.max_tokens = Some(value);
+    self.save_with_message("max-tokens")
+  }
+
+  pub fn update_max_commit_length(&mut self, value: usize) -> Result<()> {
+    self.max_commit_length = Some(value);
+    self.save_with_message("max-commit-length")
+  }
+
+  pub fn update_openai_api_key(&mut self, value: String) -> Result<()> {
+    self.openai_api_key = Some(value);
+    self.save_with_message("openai-api-key")
+  }
+
+  fn save_with_message(&self, option: &str) -> Result<()> {
+    println!("{} Configuration option {} updated!", Emoji("✨", ":-)"), option);
+    self.save()
+  }
 }
 
+// Public interface functions
 pub fn run_model(value: String) -> Result<()> {
-  let mut app = App::new()?;
-  app.model = value.into();
-  println!("{} Configuration option model updated!", Emoji("✨", ":-)"));
-  app.save()
+  App::new()?.update_model(value)
 }
 
 pub fn run_max_tokens(max_tokens: usize) -> Result<()> {
-  let mut app = App::new()?;
-  app.max_tokens = max_tokens.into();
-  println!("{} Configuration option max-tokens updated!", Emoji("✨", ":-)"));
-  app.save()
+  App::new()?.update_max_tokens(max_tokens)
 }
 
 pub fn run_max_commit_length(max_commit_length: usize) -> Result<()> {
-  let mut app = App::new()?;
-  app.max_commit_length = max_commit_length.into();
-  println!("{} Configuration option max-commit-length updated!", Emoji("✨", ":-)"));
-  app.save()
+  App::new()?.update_max_commit_length(max_commit_length)
 }
 
 pub fn run_openai_api_key(value: String) -> Result<()> {
-  let mut app = App::new()?;
-  app.openai_api_key = Some(value);
-  println!("{} Configuration option openai-api-key updated!", Emoji("✨", ":-)"));
-  app.save()
+  App::new()?.update_openai_api_key(value)
 }
 
 pub fn run_reset() -> Result<()> {
-  if !CONFIG_PATH.exists() {
+  if !PATHS.file.exists() {
     eprintln!("{} Configuration file does not exist!", Emoji("🤷", ":-)"));
     return Ok(());
   }
 
-  std::fs::remove_file(CONFIG_PATH.to_str().unwrap()).context("Failed to remove config file")?;
+  std::fs::remove_file(PATHS.file.to_str().unwrap()).context("Failed to remove config file")?;
   println!("{} Configuration reset!", Emoji("✨", ":-)"));
   Ok(())
 }