style: improve code formatting and organization - standardize line breaks, enhance readability, and ensure consistent use of Rust idioms across multiple files

Author: san0808

src/cli.rs

@@ -84,7 +84,7 @@ mod tests {
         let args = vec!["prog", "setup"];
         let cli = Cli::parse_from(args);
         match cli.command {
-            Some(Commands::Setup) => {},
+            Some(Commands::Setup) => {}
             _ => panic!("Expected Setup command"),
         }
     }

src/config.rs

@@ -1,9 +1,9 @@
+use colored::*;
+use question::{Answer, Question};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::path::PathBuf;
 use std::fs;
-use question::{Question, Answer};
-use colored::*;
+use std::path::PathBuf;
 
 #[derive(Serialize, Deserialize, Debug, Default)]
 pub struct Config {
@@ -50,15 +50,17 @@ pub fn load_config() -> Result<Config, String> {
     let config_path = get_config_path()?.join("config.toml");
     if !config_path.exists() {
         println!("{}", "Configuration file not found.".yellow());
-        println!("Please run '{}' to get started.", "commitcraft setup".bold().cyan());
+        println!(
+            "Please run '{}' to get started.",
+            "commitcraft setup".bold().cyan()
+        );
         return Err("Config not found".to_string());
     }
 
     let content = fs::read_to_string(&config_path)
         .map_err(|e| format!("Failed to read config file: {}", e))?;
 
-    toml::from_str(&content)
-        .map_err(|e| format!("Failed to parse config file: {}", e))
+    toml::from_str(&content).map_err(|e| format!("Failed to parse config file: {}", e))
 }
 
 pub fn run_setup() -> Result<(), String> {
@@ -68,30 +70,36 @@ pub fn run_setup() -> Result<(), String> {
     let mut config = load_config().unwrap_or_default();
 
     // Ask for default provider
-    let provider_answer = Question::new("Which AI provider do you want to use by default? (gemini, openai, anthropic)")
-        .ask().ok_or("Failed to ask question".to_string())?;
+    let provider_answer = Question::new(
+        "Which AI provider do you want to use by default? (gemini, openai, anthropic)",
+    )
+    .ask()
+    .ok_or("Failed to ask question".to_string())?;
     let provider_choice = match provider_answer {
         Answer::RESPONSE(s) => s,
         _ => return Err("Invalid answer type for provider choice".to_string()),
-    }.to_lowercase();
-    
+    }
+    .to_lowercase();
+
     config.default_provider = Some(provider_choice.clone());
 
     println!("\nNow, let's add API keys. You can leave any of them blank.");
-    
+
     // Ask for API keys
     let openai_key_answer = Question::new("Enter your OpenAI API key (starts with 'sk-'):")
-        .ask().ok_or("Failed to ask question".to_string())?;
+        .ask()
+        .ok_or("Failed to ask question".to_string())?;
     let openai_key = match openai_key_answer {
         Answer::RESPONSE(s) => s,
         _ => String::new(), // Default to empty if not a string response, or handle error
     };
     if !openai_key.is_empty() {
         config.api_keys.openai = Some(openai_key);
     }
-    
+
     let gemini_key_answer = Question::new("Enter your Google AI (Gemini) API key:")
-        .ask().ok_or("Failed to ask question".to_string())?;
+        .ask()
+        .ok_or("Failed to ask question".to_string())?;
     let gemini_key = match gemini_key_answer {
         Answer::RESPONSE(s) => s,
         _ => String::new(),
@@ -101,7 +109,8 @@ pub fn run_setup() -> Result<(), String> {
     }
 
     let anthropic_key_answer = Question::new("Enter your Anthropic (Claude) API key:")
-        .ask().ok_or("Failed to ask question".to_string())?;
+        .ask()
+        .ok_or("Failed to ask question".to_string())?;
     let anthropic_key = match anthropic_key_answer {
         Answer::RESPONSE(s) => s,
         _ => String::new(),
@@ -111,50 +120,64 @@ pub fn run_setup() -> Result<(), String> {
     }
 
     // Setup aliases
-    let setup_aliases = Question::new("Do you want to set up model aliases? (e.g., 'fast' -> 'gemini-1.5-flash-latest')")
-        .yes_no()
-        .default(Answer::YES)
-        .ask().ok_or("Failed to ask question".to_string())?;
+    let setup_aliases = Question::new(
+        "Do you want to set up model aliases? (e.g., 'fast' -> 'gemini-1.5-flash-latest')",
+    )
+    .yes_no()
+    .default(Answer::YES)
+    .ask()
+    .ok_or("Failed to ask question".to_string())?;
 
     if let Answer::YES = setup_aliases {
-        config.aliases.insert("fast".to_string(), "gemini-1.5-flash-latest".to_string());
-        config.aliases.insert("smart".to_string(), "gpt-4o".to_string());
+        config
+            .aliases
+            .insert("fast".to_string(), "gemini-1.5-flash-latest".to_string());
+        config
+            .aliases
+            .insert("smart".to_string(), "gpt-4o".to_string());
         println!("Default aliases 'fast' and 'smart' have been added.");
     }
-    
+
     save_config(&config)?;
-    
-    println!("\n{}", "Setup complete! Your configuration has been saved.".bold().green());
+
+    println!(
+        "\n{}",
+        "Setup complete! Your configuration has been saved."
+            .bold()
+            .green()
+    );
     Ok(())
 }
 
 fn save_config(config: &Config) -> Result<(), String> {
     let config_path = get_config_path()?.join("config.toml");
     let config_dir = config_path.parent().unwrap();
-    
+
     fs::create_dir_all(config_dir)
         .map_err(|e| format!("Failed to create config directory: {}", e))?;
 
-    let toml_string = toml::to_string_pretty(config)
-        .map_err(|e| format!("Failed to serialize config: {}", e))?;
-    
-    fs::write(&config_path, toml_string)
-        .map_err(|e| format!("Failed to write config file: {}", e))
+    let toml_string =
+        toml::to_string_pretty(config).map_err(|e| format!("Failed to serialize config: {}", e))?;
+
+    fs::write(&config_path, toml_string).map_err(|e| format!("Failed to write config file: {}", e))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::collections::HashMap;
     use std::fs;
     use std::path::PathBuf;
-    use std::collections::HashMap;
 
     #[test]
     fn test_models_default() {
         let models = Models::default();
         assert_eq!(models.openai, Some("gpt-4o-mini".to_string()));
         assert_eq!(models.gemini, Some("gemini-1.5-flash-latest".to_string()));
-        assert_eq!(models.anthropic, Some("claude-3-haiku-20240307".to_string()));
+        assert_eq!(
+            models.anthropic,
+            Some("claude-3-haiku-20240307".to_string())
+        );
     }
 
     #[test]
@@ -176,13 +199,18 @@ mod tests {
         config.default_provider = Some("openai".to_string());
         config.api_keys.openai = Some("sk-test".to_string());
         config.models.openai = Some("gpt-4".to_string());
-        config.aliases.insert("fast".to_string(), "gpt-4o-mini".to_string());
+        config
+            .aliases
+            .insert("fast".to_string(), "gpt-4o-mini".to_string());
         let toml = toml::to_string(&config).unwrap();
         let deserialized: Config = toml::from_str(&toml).unwrap();
         assert_eq!(deserialized.default_provider, Some("openai".to_string()));
         assert_eq!(deserialized.api_keys.openai, Some("sk-test".to_string()));
         assert_eq!(deserialized.models.openai, Some("gpt-4".to_string()));
-        assert_eq!(deserialized.aliases.get("fast"), Some(&"gpt-4o-mini".to_string()));
+        assert_eq!(
+            deserialized.aliases.get("fast"),
+            Some(&"gpt-4o-mini".to_string())
+        );
     }
 
     #[test]

src/git.rs

@@ -1,6 +1,6 @@
+use colored::*;
 use std::process::{Command, Stdio};
 use std::str;
-use colored::*;
 
 /// Checks if the current directory is a Git repository.
 pub fn is_git_repository() -> bool {
@@ -48,7 +48,10 @@ pub fn get_staged_files() -> Result<Vec<String>, String> {
 
     if !output.status.success() {
         let stderr = str::from_utf8(&output.stderr).unwrap_or("Unknown git error");
-        return Err(format!("'git diff --staged --name-only' failed: {}", stderr));
+        return Err(format!(
+            "'git diff --staged --name-only' failed: {}",
+            stderr
+        ));
     }
 
     let files = str::from_utf8(&output.stdout)