style: 格式化代码并优化导入顺序

build.rs

@@ -1,10 +1,11 @@
 use std::env;
 
-
 fn main() {
     // Only generate completions when explicitly requested
     if env::var("GENERATE_COMPLETIONS").is_ok() {
-        println!("cargo:warning=To generate shell completions, run: cargo run --bin quicommit -- completions");
+        println!(
+            "cargo:warning=To generate shell completions, run: cargo run --bin quicommit -- completions"
+        );
     }
 
     // Rerun if build.rs changes

src/commands/changelog.rs

@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use chrono::Utc;
 use clap::Parser;
 use colored::Colorize;
@@ -8,7 +8,7 @@ use std::path::PathBuf;
 use crate::config::{Language, manager::ConfigManager};
 use crate::generator::ContentGenerator;
 use crate::git::find_repo;
-use crate::git::{changelog::*, CommitInfo};
+use crate::git::{CommitInfo, changelog::*};
 use crate::i18n::{Messages, translate_changelog_category};
 
 /// Generate changelog
@@ -78,7 +78,9 @@ impl ChangelogCommand {
 
         // Initialize changelog if requested
         if self.init {
-            let path = self.output.clone()
+            let path = self
+                .output
+                .clone()
                 .unwrap_or_else(|| PathBuf::from(&config.changelog.path));
 
             init_changelog(&path)?;
@@ -87,7 +89,9 @@ impl ChangelogCommand {
         }
 
         // Determine output path
-        let output_path = self.output.clone()
+        let output_path = self
+            .output
+            .clone()
             .unwrap_or_else(|| PathBuf::from(&config.changelog.path));
 
         // Determine format
@@ -96,7 +100,10 @@ impl ChangelogCommand {
             Some("keep") | Some("keep-a-changelog") => ChangelogFormat::KeepAChangelog,
             Some("custom") => ChangelogFormat::Custom,
             None => ChangelogFormat::KeepAChangelog,
-            Some(f) => bail!("Unknown format: {}. Use: keep-a-changelog, github-releases", f),
+            Some(f) => bail!(
+                "Unknown format: {}. Use: keep-a-changelog, github-releases",
+                f
+            ),
         };
 
         // Get version
@@ -211,7 +218,9 @@ impl ChangelogCommand {
         println!("{}", messages.ai_generating_changelog());
 
         let generator = ContentGenerator::new_with_think(&manager, self.think).await?;
-        generator.generate_changelog_entry(version, commits, language).await
+        generator
+            .generate_changelog_entry(version, commits, language)
+            .await
     }
 
     fn generate_with_template(
@@ -239,13 +248,13 @@ impl ChangelogCommand {
     }
 
     fn translate_changelog_categories(&self, changelog: &str, language: Language) -> String {
-        
         changelog
             .lines()
             .map(|line| {
                 if line.starts_with("## ") || line.starts_with("### ") {
                     let category = line.trim_start_matches("## ").trim_start_matches("### ");
-                    let translated_category = translate_changelog_category(category, language, false);
+                    let translated_category =
+                        translate_changelog_category(category, language, false);
                     if line.starts_with("## ") {
                         format!("## {}", translated_category)
                     } else {

src/commands/commit.rs

@@ -1,14 +1,14 @@
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use clap::Parser;
 use colored::Colorize;
 use dialoguer::{Confirm, Input, Select};
 use std::path::PathBuf;
 
-use crate::config::{Language, manager::ConfigManager};
 use crate::config::CommitFormat;
+use crate::config::{Language, manager::ConfigManager};
 use crate::generator::ContentGenerator;
-use crate::git::{find_repo, GitRepo};
 use crate::git::commit::{CommitBuilder, create_date_commit_message};
+use crate::git::{GitRepo, find_repo};
 use crate::i18n::Messages;
 use crate::utils::validators::get_commit_types;
 
@@ -183,14 +183,22 @@ impl CommitCommand {
 
         let result = if self.amend {
             if self.dry_run {
-                println!("\n{} {}", messages.dry_run(), "- commit not amended.".yellow());
+                println!(
+                    "\n{} {}",
+                    messages.dry_run(),
+                    "- commit not amended.".yellow()
+                );
                 return Ok(());
             }
             self.amend_commit(&repo, &commit_message)?;
             None
         } else {
             if self.dry_run {
-                println!("\n{} {}", messages.dry_run(), "- commit not created.".yellow());
+                println!(
+                    "\n{} {}",
+                    messages.dry_run(),
+                    "- commit not created.".yellow()
+                );
                 return Ok(());
             }
             CommitBuilder::new()
@@ -200,7 +208,11 @@ impl CommitCommand {
         };
 
         if let Some(commit_oid) = result {
-            println!("{} {}", messages.commit_created().green().bold(), commit_oid.to_string()[..8].to_string().cyan());
+            println!(
+                "{} {}",
+                messages.commit_created().green().bold(),
+                commit_oid.to_string()[..8].to_string().cyan()
+            );
         } else {
             println!("{} successfully", messages.commit_amended().green().bold());
         }
@@ -232,8 +244,9 @@ impl CommitCommand {
     }
 
     fn create_manual_commit(&self, format: CommitFormat) -> Result<String> {
-        let description = self.message.clone()
+        let description = self.message.clone().ok_or_else(|| {
-            .ok_or_else(|| anyhow::anyhow!("Description required for manual commit. Use -m <message>"))?;
+            anyhow::anyhow!("Description required for manual commit. Use -m <message>")
+        })?;
 
         // Try to extract commit type from message if not provided
         let commit_type = if let Some(ref ct) = self.commit_type {
@@ -259,10 +272,16 @@ impl CommitCommand {
         builder.build_message()
     }
 
-    async fn generate_commit(&self, repo: &GitRepo, format: CommitFormat, messages: &Messages) -> Result<String> {
+    async fn generate_commit(
+        &self,
+        repo: &GitRepo,
+        format: CommitFormat,
+        messages: &Messages,
+    ) -> Result<String> {
         let manager = ConfigManager::new()?;
 
-        let generator = ContentGenerator::new_with_think(&manager, self.think).await
+        let generator = ContentGenerator::new_with_think(&manager, self.think)
+            .await
             .context("Failed to initialize LLM. Use --manual for manual commit.")?;
 
         println!("{}", messages.ai_analyzing());
@@ -270,15 +289,23 @@ impl CommitCommand {
         let language = manager.get_language().unwrap_or(Language::English);
 
         let generated = if self.yes {
-            generator.generate_commit_from_repo(repo, format, language).await?
+            generator
+                .generate_commit_from_repo(repo, format, language)
+                .await?
         } else {
-            generator.generate_commit_interactive(repo, format, language).await?
+            generator
+                .generate_commit_interactive(repo, format, language)
+                .await?
         };
 
         Ok(generated.to_conventional())
     }
 
-    async fn create_interactive_commit(&self, format: CommitFormat, messages: &Messages) -> Result<String> {
+    async fn create_interactive_commit(
+        &self,
+        format: CommitFormat,
+        messages: &Messages,
+    ) -> Result<String> {
         let types = get_commit_types(format == CommitFormat::Commitlint);
 
         // Select type
@@ -362,7 +389,8 @@ impl CommitCommand {
                     "GPG signing failed. Please check:\n\
                      1. GPG signing key is configured (git config --get user.signingkey)\n\
                      2. GPG agent is running\n\
-                     3. You can sign commits manually (try: git commit --amend -S)".to_string()
+                     3. You can sign commits manually (try: git commit --amend -S)"
+                        .to_string()
                 } else {
                     stdout.to_string()
                 }

src/commands/config.rs

@@ -1,13 +1,15 @@
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use clap::{Parser, Subcommand};
 use colored::Colorize;
-use dialoguer::{Confirm, Input, Select, Password};
+use dialoguer::{Confirm, Input, Password, Select};
 use std::path::PathBuf;
 
-use crate::config::{Language, manager::ConfigManager, ExportData, EncryptedPat};
 use crate::config::CommitFormat;
-use crate::utils::keyring::{get_supported_providers, get_default_model, get_default_base_url, provider_needs_api_key};
+use crate::config::{EncryptedPat, ExportData, Language, manager::ConfigManager};
-use crate::utils::crypto::{encrypt, decrypt};
+use crate::utils::crypto::{decrypt, encrypt};
+use crate::utils::keyring::{
+    get_default_base_url, get_default_model, get_supported_providers, provider_needs_api_key,
+};
 
 /// Mask API key with asterisks for security
 fn mask_api_key(key: Option<&str>) -> String {
@@ -167,22 +169,55 @@ impl ConfigCommand {
             Some(ConfigSubcommand::Show) => self.show_config(&config_path).await,
             Some(ConfigSubcommand::List) => self.list_config(&config_path).await,
             Some(ConfigSubcommand::Edit) => self.edit_config(&config_path).await,
-            Some(ConfigSubcommand::Set { key, value }) => self.set_value(key, value, &config_path).await,
+            Some(ConfigSubcommand::Set { key, value }) => {
+                self.set_value(key, value, &config_path).await
+            }
             Some(ConfigSubcommand::Get { key }) => self.get_value(key, &config_path).await,
-            Some(ConfigSubcommand::SetLlm { provider, model, base_url, api_key }) => {
+            Some(ConfigSubcommand::SetLlm {
-                self.set_llm(provider.as_deref(), model.as_deref(), base_url.as_deref(), api_key.as_deref(), &config_path).await
+                provider,
+                model,
+                base_url,
+                api_key,
+            }) => {
+                self.set_llm(
+                    provider.as_deref(),
+                    model.as_deref(),
+                    base_url.as_deref(),
+                    api_key.as_deref(),
+                    &config_path,
+                )
+                .await
             }
             Some(ConfigSubcommand::SetApiKey { key }) => self.set_api_key(key, &config_path).await,
             Some(ConfigSubcommand::DeleteApiKey) => self.delete_api_key(&config_path).await,
-            Some(ConfigSubcommand::SetCommitFormat { format }) => self.set_commit_format(format, &config_path).await,
+            Some(ConfigSubcommand::SetCommitFormat { format }) => {
-            Some(ConfigSubcommand::SetVersionPrefix { prefix }) => self.set_version_prefix(prefix, &config_path).await,
+                self.set_commit_format(format, &config_path).await
-            Some(ConfigSubcommand::SetChangelogPath { path }) => self.set_changelog_path(path, &config_path).await,
+            }
-            Some(ConfigSubcommand::SetLanguage { language }) => self.set_language(language.as_deref(), &config_path).await,
+            Some(ConfigSubcommand::SetVersionPrefix { prefix }) => {
-            Some(ConfigSubcommand::SetKeepTypesEnglish { keep }) => self.set_keep_types_english(*keep, &config_path).await,
+                self.set_version_prefix(prefix, &config_path).await
-            Some(ConfigSubcommand::SetKeepChangelogTypesEnglish { keep }) => self.set_keep_changelog_types_english(*keep, &config_path).await,
+            }
+            Some(ConfigSubcommand::SetChangelogPath { path }) => {
+                self.set_changelog_path(path, &config_path).await
+            }
+            Some(ConfigSubcommand::SetLanguage { language }) => {
+                self.set_language(language.as_deref(), &config_path).await
+            }
+            Some(ConfigSubcommand::SetKeepTypesEnglish { keep }) => {
+                self.set_keep_types_english(*keep, &config_path).await
+            }
+            Some(ConfigSubcommand::SetKeepChangelogTypesEnglish { keep }) => {
+                self.set_keep_changelog_types_english(*keep, &config_path)
+                    .await
+            }
             Some(ConfigSubcommand::Reset { force }) => self.reset(*force, &config_path).await,
-            Some(ConfigSubcommand::Export { output, password }) => self.export_config(output.as_deref(), password.as_deref(), &config_path).await,
+            Some(ConfigSubcommand::Export { output, password }) => {
-            Some(ConfigSubcommand::Import { file, password }) => self.import_config(file, password.as_deref(), &config_path).await,
+                self.export_config(output.as_deref(), password.as_deref(), &config_path)
+                    .await
+            }
+            Some(ConfigSubcommand::Import { file, password }) => {
+                self.import_config(file, password.as_deref(), &config_path)
+                    .await
+            }
             Some(ConfigSubcommand::ListModels) => self.list_models(&config_path).await,
             Some(ConfigSubcommand::TestLlm) => self.test_llm(&config_path).await,
             Some(ConfigSubcommand::Path) => self.show_path(&config_path).await,
@@ -246,8 +281,10 @@ impl ConfigCommand {
 
         println!("\n{}", "General:".bold());
         println!("  Config file: {}", manager.path().display());
-        println!("  Default profile: {}", 
+        println!(
-            config.default_profile.as_deref().unwrap_or("(none)").cyan());
+            "  Default profile: {}",
+            config.default_profile.as_deref().unwrap_or("(none)").cyan()
+        );
         println!("  Profiles: {}", config.profiles.len());
 
         println!("\n{}", "LLM Configuration:".bold());
@@ -266,28 +303,105 @@ impl ConfigCommand {
 
         println!("\n{}", "Commit Configuration:".bold());
         println!("  Format: {}", config.commit.format.to_string().cyan());
-        println!("  Auto-generate: {}", if config.commit.auto_generate { "yes".green() } else { "no".red() });
+        println!(
-        println!("  GPG sign: {}", if config.commit.gpg_sign { "yes".green() } else { "no".red() });
+            "  Auto-generate: {}",
+            if config.commit.auto_generate {
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
+        println!(
+            "  GPG sign: {}",
+            if config.commit.gpg_sign {
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
         println!("  Max subject length: {}", config.commit.max_subject_length);
 
         println!("\n{}", "Tag Configuration:".bold());
         println!("  Version prefix: '{}'", config.tag.version_prefix);
-        println!("  Auto-generate: {}", if config.tag.auto_generate { "yes".green() } else { "no".red() });
+        println!(
-        println!("  GPG sign: {}", if config.tag.gpg_sign { "yes".green() } else { "no".red() });
+            "  Auto-generate: {}",
-        println!("  Include changelog: {}", if config.tag.include_changelog { "yes".green() } else { "no".red() });
+            if config.tag.auto_generate {
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
+        println!(
+            "  GPG sign: {}",
+            if config.tag.gpg_sign {
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
+        println!(
+            "  Include changelog: {}",
+            if config.tag.include_changelog {
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
 
         println!("\n{}", "Language Configuration:".bold());
         let language = manager.get_language().unwrap_or(Language::English);
         println!("  Output language: {}", language.display_name().cyan());
-        println!("  Keep commit types in English: {}", if manager.keep_types_english() { "yes".green() } else { "no".red() });
+        println!(
-        println!("  Keep changelog types in English: {}", if manager.keep_changelog_types_english() { "yes".green() } else { "no".red() });
+            "  Keep commit types in English: {}",
+            if manager.keep_types_english() {
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
+        println!(
+            "  Keep changelog types in English: {}",
+            if manager.keep_changelog_types_english() {
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
 
         println!("\n{}", "Changelog Configuration:".bold());
         println!("  Path: {}", config.changelog.path);
-        println!("  Auto-generate: {}", if config.changelog.auto_generate { "yes".green() } else { "no".red() });
+        println!(
-        println!("  Include hashes: {}", if config.changelog.include_hashes { "yes".green() } else { "no".red() });
+            "  Auto-generate: {}",
-        println!("  Include authors: {}", if config.changelog.include_authors { "yes".green() } else { "no".red() });
+            if config.changelog.auto_generate {
-        println!("  Group by type: {}", if config.changelog.group_by_type { "yes".green() } else { "no".red() });
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
+        println!(
+            "  Include hashes: {}",
+            if config.changelog.include_hashes {
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
+        println!(
+            "  Include authors: {}",
+            if config.changelog.include_authors {
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
+        println!(
+            "  Group by type: {}",
+            if config.changelog.group_by_type {
+                "yes".green()
+            } else {
+                "no".red()
+            }
+        );
 
         Ok(())
     }
@@ -301,58 +415,196 @@ impl ConfigCommand {
 
         println!("\n{}", "📁 General Configuration:".bold().blue());
         println!("  Config file: {}", manager.path().display());
-        println!("  Default profile: {}", 
+        println!(
-            config.default_profile.as_deref().unwrap_or("(none)").cyan());
+            "  Default profile: {}",
+            config.default_profile.as_deref().unwrap_or("(none)").cyan()
+        );
         println!("  Profiles: {} profile(s)", config.profiles.len());
-        println!("  Repository mappings: {} mapping(s)", config.repo_profiles.len());
+        println!(
+            "  Repository mappings: {} mapping(s)",
+            config.repo_profiles.len()
+        );
 
         println!("\n{}", "🤖 LLM Configuration:".bold().blue());
         println!("  Provider: {}", config.llm.provider.cyan());
         println!("  Model: {}", config.llm.model.cyan());
         println!("  Base URL: {}", manager.llm_base_url());
-        println!("  API Key: {}", mask_api_key(manager.get_api_key().as_deref()));
+        println!(
+            "  API Key: {}",
+            mask_api_key(manager.get_api_key().as_deref())
+        );
         println!("  Max tokens: {}", config.llm.max_tokens);
         println!("  Temperature: {}", config.llm.temperature);
         println!("  Timeout: {}s", config.llm.timeout);
 
         println!("\n{}", "📝 Commit Configuration:".bold().blue());
         println!("  Format: {}", config.commit.format.to_string().cyan());
-        println!("  Auto-generate: {}", if config.commit.auto_generate { "✓ yes".green() } else { "✗ no".red() });
+        println!(
-        println!("  Allow empty: {}", if config.commit.allow_empty { "✓ yes".green() } else { "✗ no".red() });
+            "  Auto-generate: {}",
-        println!("  GPG sign: {}", if config.commit.gpg_sign { "✓ yes".green() } else { "✗ no".red() });
+            if config.commit.auto_generate {
-        println!("  Default scope: {}", config.commit.default_scope.as_deref().unwrap_or("(none)").cyan());
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
+        println!(
+            "  Allow empty: {}",
+            if config.commit.allow_empty {
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
+        println!(
+            "  GPG sign: {}",
+            if config.commit.gpg_sign {
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
+        println!(
+            "  Default scope: {}",
+            config
+                .commit
+                .default_scope
+                .as_deref()
+                .unwrap_or("(none)")
+                .cyan()
+        );
         println!("  Max subject length: {}", config.commit.max_subject_length);
-        println!("  Require scope: {}", if config.commit.require_scope { "✓ yes".green() } else { "✗ no".red() });
+        println!(
-        println!("  Require body: {}", if config.commit.require_body { "✓ yes".green() } else { "✗ no".red() });
+            "  Require scope: {}",
+            if config.commit.require_scope {
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
+        println!(
+            "  Require body: {}",
+            if config.commit.require_body {
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
         if !config.commit.body_required_types.is_empty() {
-            println!("  Body required types: {}", config.commit.body_required_types.join(", ").cyan());
+            println!(
+                "  Body required types: {}",
+                config.commit.body_required_types.join(", ").cyan()
+            );
         }
 
         println!("\n{}", "🏷️  Tag Configuration:".bold().blue());
         println!("  Version prefix: '{}'", config.tag.version_prefix.cyan());
-        println!("  Auto-generate: {}", if config.tag.auto_generate { "✓ yes".green() } else { "✗ no".red() });
+        println!(
-        println!("  GPG sign: {}", if config.tag.gpg_sign { "✓ yes".green() } else { "✗ no".red() });
+            "  Auto-generate: {}",
-        println!("  Include changelog: {}", if config.tag.include_changelog { "✓ yes".green() } else { "✗ no".red() });
+            if config.tag.auto_generate {
-        println!("  Annotation template: {}", config.tag.annotation_template.as_deref().unwrap_or("(none)").cyan());
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
+        println!(
+            "  GPG sign: {}",
+            if config.tag.gpg_sign {
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
+        println!(
+            "  Include changelog: {}",
+            if config.tag.include_changelog {
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
+        println!(
+            "  Annotation template: {}",
+            config
+                .tag
+                .annotation_template
+                .as_deref()
+                .unwrap_or("(none)")
+                .cyan()
+        );
 
         println!("\n{}", "📋 Changelog Configuration:".bold().blue());
         println!("  Path: {}", config.changelog.path);
-        println!("  Auto-generate: {}", if config.changelog.auto_generate { "✓ yes".green() } else { "✗ no".red() });
+        println!(
-        println!("  Format: {}", format!("{:?}", config.changelog.format).cyan());
+            "  Auto-generate: {}",
-        println!("  Include hashes: {}", if config.changelog.include_hashes { "✓ yes".green() } else { "✗ no".red() });
+            if config.changelog.auto_generate {
-        println!("  Include authors: {}", if config.changelog.include_authors { "✓ yes".green() } else { "✗ no".red() });
+                "✓ yes".green()
-        println!("  Group by type: {}", if config.changelog.group_by_type { "✓ yes".green() } else { "✗ no".red() });
+            } else {
+                "✗ no".red()
+            }
+        );
+        println!(
+            "  Format: {}",
+            format!("{:?}", config.changelog.format).cyan()
+        );
+        println!(
+            "  Include hashes: {}",
+            if config.changelog.include_hashes {
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
+        println!(
+            "  Include authors: {}",
+            if config.changelog.include_authors {
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
+        println!(
+            "  Group by type: {}",
+            if config.changelog.group_by_type {
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
         if !config.changelog.custom_categories.is_empty() {
-            println!("  Custom categories: {} category(ies)", config.changelog.custom_categories.len());
+            println!(
+                "  Custom categories: {} category(ies)",
+                config.changelog.custom_categories.len()
+            );
         }
 
         println!("\n{}", "🎨 Theme Configuration:".bold().blue());
-        println!("  Colors: {}", if config.theme.colors { "✓ enabled".green() } else { "✗ disabled".red() });
+        println!(
-        println!("  Icons: {}", if config.theme.icons { "✓ enabled".green() } else { "✗ disabled".red() });
+            "  Colors: {}",
+            if config.theme.colors {
+                "✓ enabled".green()
+            } else {
+                "✗ disabled".red()
+            }
+        );
+        println!(
+            "  Icons: {}",
+            if config.theme.icons {
+                "✓ enabled".green()
+            } else {
+                "✗ disabled".red()
+            }
+        );
         println!("  Date format: {}", config.theme.date_format.cyan());
 
         println!("\n{}", "🔒 Security:".bold().blue());
-        println!("  Encrypt sensitive: {}", if config.encrypt_sensitive { "✓ yes".green() } else { "✗ no".red() });
+        println!(
+            "  Encrypt sensitive: {}",
+            if config.encrypt_sensitive {
+                "✓ yes".green()
+            } else {
+                "✗ no".red()
+            }
+        );
 
         println!("\n{}", "🔑 Keyring:".bold().blue());
         let keyring = manager.keyring();
@@ -441,7 +693,11 @@ impl ConfigCommand {
             "llm.temperature" => config.llm.temperature.to_string(),
             "llm.timeout" => config.llm.timeout.to_string(),
             "llm.thinking_enabled" => config.llm.thinking_enabled.to_string(),
-            "llm.thinking_budget_tokens" => config.llm.thinking_budget_tokens.map(|v| v.to_string()).unwrap_or_else(|| "none".to_string()),
+            "llm.thinking_budget_tokens" => config
+                .llm
+                .thinking_budget_tokens
+                .map(|v| v.to_string())
+                .unwrap_or_else(|| "none".to_string()),
             "llm.api_key_storage" => config.llm.api_key_storage.clone(),
             "commit.format" => config.commit.format.to_string(),
             "commit.auto_generate" => config.commit.auto_generate.to_string(),
@@ -454,13 +710,24 @@ impl ConfigCommand {
         Ok(())
     }
 
-    async fn set_llm(&self, provider: Option<&str>, model: Option<&str>, base_url: Option<&str>, api_key: Option<&str>, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn set_llm(
+        &self,
+        provider: Option<&str>,
+        model: Option<&str>,
+        base_url: Option<&str>,
+        api_key: Option<&str>,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         let mut manager = self.get_manager(config_path)?;
 
         let selected_provider = if let Some(p) = provider {
             let providers = get_supported_providers();
             if !providers.contains(&p) {
-                bail!("Invalid provider: {}. Valid options: {}", p, providers.join(", "));
+                bail!(
+                    "Invalid provider: {}. Valid options: {}",
+                    p,
+                    providers.join(", ")
+                );
             }
             p.to_string()
         } else {
@@ -471,7 +738,7 @@ impl ConfigCommand {
                 "Anthropic Claude",
                 "Kimi (Moonshot AI)",
                 "DeepSeek",
-                "OpenRouter"
+                "OpenRouter",
             ];
 
             let provider_idx = Select::new()
@@ -487,7 +754,10 @@ impl ConfigCommand {
         let keyring_available = keyring.is_available();
 
         if !keyring_available && provider_needs_api_key(&selected_provider) {
-            println!("\n{}", "⚠ Keyring is not available on this system.".yellow());
+            println!(
+                "\n{}",
+                "⚠ Keyring is not available on this system.".yellow()
+            );
             println!("{}", keyring.get_status_message().yellow());
         }
 
@@ -539,21 +809,20 @@ impl ConfigCommand {
                         .interact()?;
 
                     if overwrite {
-                        let key: String = Input::new()
+                        let key: String = Input::new().with_prompt("API key").interact_text()?;
-                            .with_prompt("API key")
-                            .interact_text()?;
                         Some(key)
                     } else {
                         None
                     }
                 } else {
-                    let key: String = Input::new()
+                    let key: String = Input::new().with_prompt("API key").interact_text()?;
-                        .with_prompt("API key")
-                        .interact_text()?;
                     Some(key)
                 }
             } else {
-                println!("\n{}", "Please set the QUICOMMIT_API_KEY environment variable.".yellow());
+                println!(
+                    "\n{}",
+                    "Please set the QUICOMMIT_API_KEY environment variable.".yellow()
+                );
                 None
             }
         } else {
@@ -566,7 +835,10 @@ impl ConfigCommand {
 
         if let Some(key) = selected_api_key {
             manager.set_api_key(&key)?;
-            println!("\n{} API key stored securely in system keyring", "✓".green());
+            println!(
+                "\n{} API key stored securely in system keyring",
+                "✓".green()
+            );
         }
 
         manager.save()?;
@@ -593,22 +865,38 @@ impl ConfigCommand {
         match storage_method.as_str() {
             "keyring" => {
                 if !manager.keyring().is_available() {
-                    bail!("Keyring is not available. Set QUICOMMIT_API_KEY environment variable instead or change api_key_storage to 'config'.");
+                    bail!(
+                        "Keyring is not available. Set QUICOMMIT_API_KEY environment variable instead or change api_key_storage to 'config'."
+                    );
                 }
 
                 manager.set_api_key(key)?;
-                println!("{} API key stored securely in system keyring for {}", "✓".green(), provider.cyan());
+                println!(
-            },
+                    "{} API key stored securely in system keyring for {}",
+                    "✓".green(),
+                    provider.cyan()
+                );
+            }
             "config" => {
                 // Store API key directly in config file
                 manager.config_mut().llm.api_key = Some(key.to_string());
                 manager.save()?;
-                println!("{} API key stored in configuration file for {}", "✓".green(), provider.cyan());
+                println!(
-                println!("{} Note: API key is stored in plain text. Consider using 'keyring' storage for better security.", "⚠".yellow());
+                    "{} API key stored in configuration file for {}",
-            },
+                    "✓".green(),
+                    provider.cyan()
+                );
+                println!(
+                    "{} Note: API key is stored in plain text. Consider using 'keyring' storage for better security.",
+                    "⚠".yellow()
+                );
+            }
             "environment" => {
-                bail!("API key storage set to 'environment'. Please set QUICOMMIT_{}_API_KEY environment variable.", provider.to_uppercase());
+                bail!(
-            },
+                    "API key storage set to 'environment'. Please set QUICOMMIT_{}_API_KEY environment variable.",
+                    provider.to_uppercase()
+                );
+            }
             _ => {
                 bail!("Invalid API key storage method: {}", storage_method);
             }
@@ -630,17 +918,29 @@ impl ConfigCommand {
                 }
 
                 manager.delete_api_key()?;
-                println!("{} API key deleted from system keyring for {}", "✓".green(), provider.cyan());
+                println!(
-            },
+                    "{} API key deleted from system keyring for {}",
+                    "✓".green(),
+                    provider.cyan()
+                );
+            }
             "config" => {
                 // Remove API key from config file
                 manager.config_mut().llm.api_key = None;
                 manager.save()?;
-                println!("{} API key deleted from configuration file for {}", "✓".green(), provider.cyan());
+                println!(
-            },
+                    "{} API key deleted from configuration file for {}",
+                    "✓".green(),
+                    provider.cyan()
+                );
+            }
             "environment" => {
-                println!("{} API key storage set to 'environment'. Please remove QUICOMMIT_{}_API_KEY environment variable manually.", "ℹ".blue(), provider.to_uppercase());
+                println!(
-            },
+                    "{} API key storage set to 'environment'. Please remove QUICOMMIT_{}_API_KEY environment variable manually.",
+                    "ℹ".blue(),
+                    provider.to_uppercase()
+                );
+            }
             _ => {
                 bail!("Invalid API key storage method: {}", storage_method);
             }
@@ -661,7 +961,11 @@ impl ConfigCommand {
         manager.set_commit_format(format);
         manager.save()?;
 
-        println!("{} Commit format set to {}", "✓".green(), format.to_string().cyan());
+        println!(
+            "{} Commit format set to {}",
+            "✓".green(),
+            format.to_string().cyan()
+        );
         Ok(())
     }
 
@@ -683,26 +987,29 @@ impl ConfigCommand {
         Ok(())
     }
 
-    async fn set_language(&self, language: Option<&str>, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn set_language(
+        &self,
+        language: Option<&str>,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         let mut manager = self.get_manager(config_path)?;
 
         let lang_code = if let Some(l) = language {
             l.to_string()
         } else {
             println!("{}", "Select Output Language:".bold());
-            let languages = [("en", "English"),
+            let languages = [
+                ("en", "English"),
                 ("zh", "中文"),
                 ("ja", "日本語"),
                 ("ko", "한국어"),
                 ("es", "Español"),
                 ("fr", "Français"),
-                ("de", "Deutsch")];
+                ("de", "Deutsch"),
+            ];
 
             let lang_names: Vec<&str> = languages.iter().map(|(_, n)| *n).collect();
-            let idx = Select::new()
+            let idx = Select::new().items(&lang_names).default(0).interact()?;
-                .items(&lang_names)
-                .default(0)
-                .interact()?;
 
             languages[idx].0.to_string()
         };
@@ -710,25 +1017,45 @@ impl ConfigCommand {
         manager.set_output_language(lang_code.clone());
         manager.save()?;
 
-        println!("{} Output language set to {}", "✓".green(), lang_code.cyan());
+        println!(
+            "{} Output language set to {}",
+            "✓".green(),
+            lang_code.cyan()
+        );
         Ok(())
     }
 
-    async fn set_keep_types_english(&self, keep: bool, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn set_keep_types_english(
+        &self,
+        keep: bool,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         let mut manager = self.get_manager(config_path)?;
         manager.set_keep_types_english(keep);
         manager.save()?;
 
-        println!("{} Keep commit types in English: {}", "✓".green(), keep.to_string().cyan());
+        println!(
+            "{} Keep commit types in English: {}",
+            "✓".green(),
+            keep.to_string().cyan()
+        );
         Ok(())
     }
 
-    async fn set_keep_changelog_types_english(&self, keep: bool, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn set_keep_changelog_types_english(
+        &self,
+        keep: bool,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         let mut manager = self.get_manager(config_path)?;
         manager.set_keep_changelog_types_english(keep);
         manager.save()?;
 
-        println!("{} Keep changelog types in English: {}", "✓".green(), keep.to_string().cyan());
+        println!(
+            "{} Keep changelog types in English: {}",
+            "✓".green(),
+            keep.to_string().cyan()
+        );
         Ok(())
     }
 
@@ -753,7 +1080,12 @@ impl ConfigCommand {
         Ok(())
     }
 
-    async fn export_config(&self, output: Option<&str>, password: Option<&str>, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn export_config(
+        &self,
+        output: Option<&str>,
+        password: Option<&str>,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         let manager = self.get_manager(config_path)?;
         let toml = manager.export()?;
 
@@ -795,9 +1127,20 @@ impl ConfigCommand {
                 }
 
                 if has_pats {
-                    println!("{} {}", "⚠".yellow(), "WARNING: Exporting without encryption.".bold());
+                    println!(
-                    println!("  {}", "Personal Access Tokens (PATs) stored in keyring will NOT be exported.".yellow());
+                        "{} {}",
-                    println!("  {}", "To export PATs securely, please enable encryption.".yellow());
+                        "⚠".yellow(),
+                        "WARNING: Exporting without encryption.".bold()
+                    );
+                    println!(
+                        "  {}",
+                        "Personal Access Tokens (PATs) stored in keyring will NOT be exported."
+                            .yellow()
+                    );
+                    println!(
+                        "  {}",
+                        "To export PATs securely, please enable encryption.".yellow()
+                    );
                     println!();
                 }
 
@@ -807,7 +1150,9 @@ impl ConfigCommand {
 
                 for (profile_name, profile) in manager.config().profiles.iter() {
                     for service in profile.tokens.keys() {
-                        if let Ok(Some(pat_value)) = manager.get_pat_for_profile(profile_name, service) {
+                        if let Ok(Some(pat_value)) =
+                            manager.get_pat_for_profile(profile_name, service)
+                        {
                             let encrypted_token = encrypt(pat_value.as_bytes(), &pwd)?;
                             encrypted_pats.push(EncryptedPat {
                                 profile_name: profile_name.clone(),
@@ -833,7 +1178,11 @@ impl ConfigCommand {
             Some(path) => {
                 std::fs::write(path, &export_content)?;
                 if export_content.starts_with("ENCRYPTED:") {
-                    println!("{} Configuration encrypted and exported to {}", "✓".green(), path);
+                    println!(
+                        "{} Configuration encrypted and exported to {}",
+                        "✓".green(),
+                        path
+                    );
                 } else {
                     println!("{} Configuration exported to {}", "✓".green(), path);
                 }
@@ -846,7 +1195,12 @@ impl ConfigCommand {
         Ok(())
     }
 
-    async fn import_config(&self, file: &str, password: Option<&str>, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn import_config(
+        &self,
+        file: &str,
+        password: Option<&str>,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         let content = std::fs::read_to_string(file)?;
 
         let (config_content, encrypted_pats, pwd) = if content.starts_with("ENCRYPTED:") {
@@ -863,7 +1217,10 @@ impl ConfigCommand {
             let decrypted = match decrypt(encrypted_data, &pwd) {
                 Ok(d) => d,
                 Err(e) => {
-                    bail!("Failed to decrypt configuration: {}. Please check your password.", e);
+                    bail!(
+                        "Failed to decrypt configuration: {}. Please check your password.",
+                        e
+                    );
                 }
             };
 
@@ -871,12 +1228,12 @@ impl ConfigCommand {
                 .map_err(|e| anyhow::anyhow!("Invalid UTF-8 in decrypted content: {}", e))?;
 
             match serde_json::from_str::<ExportData>(&decrypted_str) {
-                Ok(export_data) => {
+                Ok(export_data) => (
-                    (export_data.config, Some(export_data.encrypted_pats), Some(pwd))
+                    export_data.config,
-                }
+                    Some(export_data.encrypted_pats),
-                Err(_) => {
+                    Some(pwd),
-                    (decrypted_str, None, Some(pwd))
+                ),
-                }
+                Err(_) => (decrypted_str, None, Some(pwd)),
             }
         } else {
             (content, None, None)
@@ -887,7 +1244,8 @@ impl ConfigCommand {
         manager.save()?;
 
         if let (Some(pats), Some(pwd)) = (encrypted_pats, pwd)
-            && !pats.is_empty() {
+            && !pats.is_empty()
+        {
             println!();
             println!("{}", "Importing Personal Access Tokens...".bold());
 
@@ -896,55 +1254,63 @@ impl ConfigCommand {
 
             for pat in pats {
                 match decrypt(&pat.encrypted_token, &pwd) {
-                        Ok(token_bytes) => {
+                    Ok(token_bytes) => match String::from_utf8(token_bytes) {
-                            match String::from_utf8(token_bytes) {
                         Ok(token_value) => {
                             if manager.keyring().is_available() {
                                 match manager.store_pat_for_profile(
                                     &pat.profile_name,
                                     &pat.service,
-                                            &token_value
+                                    &token_value,
                                 ) {
                                     Ok(_) => {
-                                                println!("  {} Token for {} ({}) imported to keyring", 
+                                        println!(
+                                            "  {} Token for {} ({}) imported to keyring",
                                             "✓".green(),
                                             pat.profile_name.cyan(),
-                                                    pat.service.yellow());
+                                            pat.service.yellow()
+                                        );
                                         imported_count += 1;
                                     }
                                     Err(e) => {
-                                                println!("  {} Failed to store token for {} ({}): {}", 
+                                        println!(
+                                            "  {} Failed to store token for {} ({}): {}",
                                             "✗".red(),
                                             pat.profile_name,
                                             pat.service,
-                                                    e);
+                                            e
+                                        );
                                         failed_count += 1;
                                     }
                                 }
                             } else {
-                                        println!("  {} Keyring not available, cannot store token for {} ({})", 
+                                println!(
+                                    "  {} Keyring not available, cannot store token for {} ({})",
                                     "⚠".yellow(),
                                     pat.profile_name,
-                                            pat.service);
+                                    pat.service
+                                );
                                 failed_count += 1;
                             }
                         }
                         Err(e) => {
-                                    println!("  {} Invalid token format for {} ({}): {}", 
+                            println!(
+                                "  {} Invalid token format for {} ({}): {}",
                                 "✗".red(),
                                 pat.profile_name,
                                 pat.service,
-                                        e);
+                                e
+                            );
                             failed_count += 1;
                         }
-                            }
+                    },
-                        }
                     Err(e) => {
-                            println!("  {} Failed to decrypt token for {} ({}): {}", 
+                        println!(
+                            "  {} Failed to decrypt token for {} ({}): {}",
                             "✗".red(),
                             pat.profile_name,
                             pat.service,
-                                e);
+                            e
+                        );
                         failed_count += 1;
                     }
                 }
@@ -952,10 +1318,18 @@ impl ConfigCommand {
 
             println!();
             if imported_count > 0 {
-                    println!("{} {} token(s) imported to keyring", "✓".green(), imported_count);
+                println!(
+                    "{} {} token(s) imported to keyring",
+                    "✓".green(),
+                    imported_count
+                );
             }
             if failed_count > 0 {
-                    println!("{} {} token(s) failed to import", "⚠".yellow(), failed_count);
+                println!(
+                    "{} {} token(s) failed to import",
+                    "⚠".yellow(),
+                    failed_count
+                );
             }
         }
 
@@ -987,14 +1361,20 @@ impl ConfigCommand {
             }
             "anthropic" => {
                 println!("Anthropic Claude models:");
-                println!("  Claude 4 (thinking): claude-opus-4-7, claude-sonnet-4-6, claude-haiku-4-5");
+                println!(
-                println!("  Claude 3.5: claude-3-opus-20240229, claude-3-sonnet-20240229, claude-3-haiku-20240307");
+                    "  Claude 4 (thinking): claude-opus-4-7, claude-sonnet-4-6, claude-haiku-4-5"
+                );
+                println!(
+                    "  Claude 3.5: claude-3-opus-20240229, claude-3-sonnet-20240229, claude-3-haiku-20240307"
+                );
                 println!("  Legacy: claude-2.1, claude-2.0, claude-instant-1.2");
                 println!("\nUse --think/-t with Claude 4 models for extended thinking.");
             }
             "kimi" => {
                 println!("Kimi (Moonshot AI) models:");
-                println!("  K2 (thinking): kimi-k2.6, kimi-k2.5, kimi-k2-thinking, kimi-k2-thinking-turbo");
+                println!(
+                    "  K2 (thinking): kimi-k2.6, kimi-k2.5, kimi-k2-thinking, kimi-k2-thinking-turbo"
+                );
                 println!("  K2 instruct: kimi-k2-instruct, kimi-k2-instruct-0905");
                 println!("  Legacy: moonshot-v1-8k, moonshot-v1-32k, moonshot-v1-128k");
                 println!("\nUse --think/-t with K2 models for thinking mode.");
@@ -1033,7 +1413,14 @@ impl ConfigCommand {
 
         let has_key = manager.has_api_key();
         if provider_needs_api_key(manager.llm_provider()) {
-            println!("  API Key: {}", if has_key { "✓ configured".green() } else { "✗ not set".red() });
+            println!(
+                "  API Key: {}",
+                if has_key {
+                    "✓ configured".green()
+                } else {
+                    "✗ not set".red()
+                }
+            );
         }
 
         println!("\n{}", "Sending test request...".dimmed());

src/commands/init.rs

@@ -4,11 +4,11 @@ use colored::Colorize;
 use dialoguer::{Confirm, Input, Select};
 use std::path::PathBuf;
 
-use crate::config::{GitProfile, Language};
 use crate::config::manager::ConfigManager;
 use crate::config::profile::{GpgConfig, SshConfig};
+use crate::config::{GitProfile, Language};
 use crate::i18n::Messages;
-use crate::utils::keyring::{get_supported_providers, get_default_model, provider_needs_api_key};
+use crate::utils::keyring::{get_default_model, get_supported_providers, provider_needs_api_key};
 use crate::utils::validators::validate_email;
 
 /// Initialize quicommit configuration
@@ -28,9 +28,8 @@ impl InitCommand {
         let messages = Messages::new(Language::English);
         println!("{}", messages.initializing().bold().cyan());
 
-        let config_path = config_path.unwrap_or_else(|| {
+        let config_path =
-            crate::config::AppConfig::default_path().unwrap()
+            config_path.unwrap_or_else(|| crate::config::AppConfig::default_path().unwrap());
-        });
 
         if config_path.exists() && !self.reset {
             if !self.yes {
@@ -44,7 +43,10 @@ impl InitCommand {
                     return Ok(());
                 }
             } else {
-                println!("{}", "Configuration already exists. Use --reset to overwrite.".yellow());
+                println!(
+                    "{}",
+                    "Configuration already exists. Use --reset to overwrite.".yellow()
+                );
                 return Ok(());
             }
         }
@@ -80,14 +82,14 @@ impl InitCommand {
     async fn quick_setup(&self, manager: &mut ConfigManager) -> Result<()> {
         let git_config = git2::Config::open_default()?;
 
-        let user_name = git_config.get_string("user.name").unwrap_or_else(|_| "User".to_string());
+        let user_name = git_config
-        let user_email = git_config.get_string("user.email").unwrap_or_else(|_| "user@example.com".to_string());
+            .get_string("user.name")
+            .unwrap_or_else(|_| "User".to_string());
+        let user_email = git_config
+            .get_string("user.email")
+            .unwrap_or_else(|_| "user@example.com".to_string());
 
-        let profile = GitProfile::new(
+        let profile = GitProfile::new("default".to_string(), user_name, user_email);
-            "default".to_string(),
-            user_name,
-            user_email,
-        );
 
         manager.add_profile("default".to_string(), profile)?;
         manager.set_default_profile(Some("default".to_string()))?;
@@ -102,18 +104,20 @@ impl InitCommand {
         println!("\n{}", messages.setup_profile().bold());
 
         println!("\n{}", messages.select_output_language().bold());
-        let languages = [Language::English,
+        let languages = [
+            Language::English,
             Language::Chinese,
             Language::Japanese,
             Language::Korean,
             Language::Spanish,
             Language::French,
-            Language::German];
+            Language::German,
-        let language_names: Vec<String> = languages.iter().map(|l| l.display_name().to_string()).collect();
+        ];
-        let language_idx = Select::new()
+        let language_names: Vec<String> = languages
-            .items(&language_names)
+            .iter()
-            .default(0)
+            .map(|l| l.display_name().to_string())
-            .interact()?;
+            .collect();
+        let language_idx = Select::new().items(&language_names).default(0).interact()?;
 
         let selected_language = languages[language_idx];
         manager.set_output_language(selected_language.to_code().to_string());
@@ -127,11 +131,13 @@ impl InitCommand {
 
         let git_config = git2::Config::open_default().ok();
 
-        let default_name = git_config.as_ref()
+        let default_name = git_config
+            .as_ref()
             .and_then(|c| c.get_string("user.name").ok())
             .unwrap_or_default();
 
-        let default_email = git_config.as_ref()
+        let default_email = git_config
+            .as_ref()
             .and_then(|c| c.get_string("user.email").ok())
             .unwrap_or_default();
 
@@ -143,9 +149,7 @@ impl InitCommand {
         let user_email: String = Input::new()
             .with_prompt(messages.git_user_email())
             .default(default_email)
-            .validate_with(|input: &String| {
+            .validate_with(|input: &String| validate_email(input).map_err(|e| e.to_string()))
-                validate_email(input).map_err(|e| e.to_string())
-            })
             .interact_text()?;
 
         let description: String = Input::new()
@@ -159,9 +163,11 @@ impl InitCommand {
             .interact()?;
 
         let organization = if is_work {
-            Some(Input::new()
+            Some(
+                Input::new()
                     .with_prompt(messages.organization_name())
-                .interact_text()?)
+                    .interact_text()?,
+            )
         } else {
             None
         };
@@ -188,11 +194,7 @@ impl InitCommand {
             None
         };
 
-        let mut profile = GitProfile::new(
+        let mut profile = GitProfile::new(profile_name.clone(), user_name, user_email);
-            profile_name.clone(),
-            user_name,
-            user_email,
-        );
 
         if !description.is_empty() {
             profile.description = Some(description);
@@ -214,7 +216,7 @@ impl InitCommand {
             "Anthropic Claude",
             "Kimi (Moonshot AI)",
             "DeepSeek",
-            "OpenRouter"
+            "OpenRouter",
         ];
 
         let provider_idx = Select::new()
@@ -229,17 +231,26 @@ impl InitCommand {
         let keyring_available = keyring.is_available();
 
         if !keyring_available {
-            println!("\n{}", "⚠ Keyring is not available on this system.".yellow());
+            println!(
+                "\n{}",
+                "⚠ Keyring is not available on this system.".yellow()
+            );
             println!("{}", keyring.get_status_message().yellow());
         }
 
         let api_key = if provider_needs_api_key(&provider) {
             let env_key = std::env::var("QUICOMMIT_API_KEY")
-                .or_else(|_| std::env::var(format!("QUICOMMIT_{}_API_KEY", provider.to_uppercase())))
+                .or_else(|_| {
+                    std::env::var(format!("QUICOMMIT_{}_API_KEY", provider.to_uppercase()))
+                })
                 .ok();
 
             if let Some(_key) = env_key {
-                println!("\n{} {}", "✓".green(), "Found API key in environment variable.".green());
+                println!(
+                    "\n{} {}",
+                    "✓".green(),
+                    "Found API key in environment variable.".green()
+                );
                 None
             } else if keyring_available {
                 let prompt = match provider.as_str() {
@@ -251,12 +262,13 @@ impl InitCommand {
                     _ => "API Key",
                 };
 
-                let key: String = Input::new()
+                let key: String = Input::new().with_prompt(prompt).interact_text()?;
-                    .with_prompt(prompt)
-                    .interact_text()?;
                 Some(key)
             } else {
-                println!("\n{}", "Please set the QUICOMMIT_API_KEY environment variable.".yellow());
+                println!(
+                    "\n{}",
+                    "Please set the QUICOMMIT_API_KEY environment variable.".yellow()
+                );
                 None
             }
         } else {
@@ -282,9 +294,7 @@ impl InitCommand {
                 .interact()?;
 
             if use_custom_url {
-                let url: String = Input::new()
+                let url: String = Input::new().with_prompt("Base URL").interact_text()?;
-                    .with_prompt("Base URL")
-                    .interact_text()?;
                 Some(url)
             } else {
                 None
@@ -296,9 +306,14 @@ impl InitCommand {
         manager.set_llm_base_url(base_url);
 
         if let Some(key) = api_key
-            && provider_needs_api_key(&provider) {
+            && provider_needs_api_key(&provider)
+        {
             manager.set_api_key(&key)?;
-                println!("\n{} {}", "✓".green(), "API key stored securely in system keyring.".green());
+            println!(
+                "\n{} {}",
+                "✓".green(),
+                "API key stored securely in system keyring.".green()
+            );
         }
 
         Ok(())

src/commands/profile.rs

@@ -1,12 +1,12 @@
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use clap::{Parser, Subcommand};
 use colored::Colorize;
 use dialoguer::{Confirm, Input, Select};
 use std::path::PathBuf;
 
 use crate::config::manager::ConfigManager;
-use crate::config::{GitProfile, TokenConfig, TokenType};
 use crate::config::profile::{GpgConfig, SshConfig};
+use crate::config::{GitProfile, TokenConfig, TokenType};
 use crate::git::find_repo;
 use crate::utils::validators::validate_profile_name;
 
@@ -127,18 +127,35 @@ impl ProfileCommand {
     pub async fn execute(&self, config_path: Option<PathBuf>) -> Result<()> {
         match &self.command {
             Some(ProfileSubcommand::Add) => self.add_profile(&config_path).await,
-            Some(ProfileSubcommand::Remove { name }) => self.remove_profile(name, &config_path).await,
+            Some(ProfileSubcommand::Remove { name }) => {
+                self.remove_profile(name, &config_path).await
+            }
             Some(ProfileSubcommand::List) => self.list_profiles(&config_path).await,
-            Some(ProfileSubcommand::Show { name }) => self.show_profile(name.as_deref(), &config_path).await,
+            Some(ProfileSubcommand::Show { name }) => {
+                self.show_profile(name.as_deref(), &config_path).await
+            }
             Some(ProfileSubcommand::Edit { name }) => self.edit_profile(name, &config_path).await,
-            Some(ProfileSubcommand::SetDefault { name }) => self.set_default(name, &config_path).await,
+            Some(ProfileSubcommand::SetDefault { name }) => {
+                self.set_default(name, &config_path).await
+            }
             Some(ProfileSubcommand::SetRepo { name }) => self.set_repo(name, &config_path).await,
-            Some(ProfileSubcommand::Apply { name, global }) => self.apply_profile(name.as_deref(), *global, &config_path).await,
+            Some(ProfileSubcommand::Apply { name, global }) => {
+                self.apply_profile(name.as_deref(), *global, &config_path)
+                    .await
+            }
             Some(ProfileSubcommand::Switch) => self.switch_profile(&config_path).await,
-            Some(ProfileSubcommand::Copy { from, to }) => self.copy_profile(from, to, &config_path).await,
+            Some(ProfileSubcommand::Copy { from, to }) => {
-            Some(ProfileSubcommand::Token { token_command }) => self.handle_token_command(token_command, &config_path).await,
+                self.copy_profile(from, to, &config_path).await
-            Some(ProfileSubcommand::Check { name }) => self.check_profile(name.as_deref(), &config_path).await,
+            }
-            Some(ProfileSubcommand::Stats { name }) => self.show_stats(name.as_deref(), &config_path).await,
+            Some(ProfileSubcommand::Token { token_command }) => {
+                self.handle_token_command(token_command, &config_path).await
+            }
+            Some(ProfileSubcommand::Check { name }) => {
+                self.check_profile(name.as_deref(), &config_path).await
+            }
+            Some(ProfileSubcommand::Stats { name }) => {
+                self.show_stats(name.as_deref(), &config_path).await
+            }
             None => self.list_profiles(&config_path).await,
         }
     }
@@ -158,18 +175,14 @@ impl ProfileCommand {
 
         let name: String = Input::new()
             .with_prompt("Profile name")
-            .validate_with(|input: &String| {
+            .validate_with(|input: &String| validate_profile_name(input).map_err(|e| e.to_string()))
-                validate_profile_name(input).map_err(|e| e.to_string())
-            })
             .interact_text()?;
 
         if manager.has_profile(&name) {
             bail!("Profile '{}' already exists", name);
         }
 
-        let user_name: String = Input::new()
+        let user_name: String = Input::new().with_prompt("Git user name").interact_text()?;
-            .with_prompt("Git user name")
-            .interact_text()?;
 
         let user_email: String = Input::new()
             .with_prompt("Git user email")
@@ -189,9 +202,7 @@ impl ProfileCommand {
             .interact()?;
 
         let organization = if is_work {
-            Some(Input::new()
+            Some(Input::new().with_prompt("Organization").interact_text()?)
-                .with_prompt("Organization")
-                .interact_text()?)
         } else {
             None
         };
@@ -234,7 +245,11 @@ impl ProfileCommand {
         manager.add_profile(name.clone(), profile)?;
         manager.save()?;
 
-        println!("{} Profile '{}' added successfully", "✓".green(), name.cyan());
+        println!(
+            "{} Profile '{}' added successfully",
+            "✓".green(),
+            name.cyan()
+        );
 
         if manager.default_profile().is_none() {
             let set_default = Confirm::new()
@@ -260,7 +275,10 @@ impl ProfileCommand {
         }
 
         let confirm = Confirm::new()
-            .with_prompt(format!("Are you sure you want to remove profile '{}'?", name))
+            .with_prompt(format!(
+                "Are you sure you want to remove profile '{}'?",
+                name
+            ))
             .default(false)
             .interact()?;
 
@@ -274,7 +292,11 @@ impl ProfileCommand {
         manager.remove_profile(name)?;
         manager.save()?;
 
-        println!("{} Profile '{}' removed (including all stored tokens)", "✓".green(), name);
+        println!(
+            "{} Profile '{}' removed (including all stored tokens)",
+            "✓".green(),
+            name
+        );
 
         Ok(())
     }
@@ -299,8 +321,16 @@ impl ProfileCommand {
             let profile = manager.get_profile(name).unwrap();
             let is_default = default.map(|d| d == name).unwrap_or(false);
 
-            let marker = if is_default { "●".green() } else { "○".dimmed() };
+            let marker = if is_default {
-            let work_marker = if profile.is_work { " [work]".yellow() } else { "".normal() };
+                "●".green()
+            } else {
+                "○".dimmed()
+            };
+            let work_marker = if profile.is_work {
+                " [work]".yellow()
+            } else {
+                "".normal()
+            };
 
             println!("{} {}{}", marker, name.cyan().bold(), work_marker);
             println!("   {} <{}>", profile.user_name, profile.user_email);
@@ -316,11 +346,19 @@ impl ProfileCommand {
                 println!("   {} GPG configured", "🔒".to_string().dimmed());
             }
             if profile.has_tokens() {
-                println!("   {} {} token(s)", "🔐".to_string().dimmed(), profile.tokens.len());
+                println!(
+                    "   {} {} token(s)",
+                    "🔐".to_string().dimmed(),
+                    profile.tokens.len()
+                );
             }
 
             if let Some(ref usage) = profile.usage.last_used {
-                println!("   {} Last used: {}", "📊".to_string().dimmed(), usage.dimmed());
+                println!(
+                    "   {} Last used: {}",
+                    "📊".to_string().dimmed(),
+                    usage.dimmed()
+                );
             }
 
             println!();
@@ -333,16 +371,17 @@ impl ProfileCommand {
         let manager = self.get_manager(config_path)?;
 
         match find_repo(std::env::current_dir()?.as_path()) {
-            Ok(repo) => {
+            Ok(repo) => self.show_repo_status(&repo, &manager, name).await,
-                self.show_repo_status(&repo, &manager, name).await
+            Err(_) => self.show_global_status(&manager, name).await,
-            }
-            Err(_) => {
-                self.show_global_status(&manager, name).await
-            }
         }
     }
 
-    async fn show_repo_status(&self, repo: &crate::git::GitRepo, manager: &ConfigManager, name: Option<&str>) -> Result<()> {
+    async fn show_repo_status(
+        &self,
+        repo: &crate::git::GitRepo,
+        manager: &ConfigManager,
+        name: Option<&str>,
+    ) -> Result<()> {
         use crate::git::MergedUserConfig;
 
         let merged_config = MergedUserConfig::from_repo(repo.inner())?;
@@ -352,7 +391,10 @@ impl ProfileCommand {
         println!("{}", "─".repeat(60));
         println!("Repository: {}", repo_path.cyan());
 
-        println!("\n{}", "Git User Configuration (merged local/global):".bold());
+        println!(
+            "\n{}",
+            "Git User Configuration (merged local/global):".bold()
+        );
         println!("{}", "─".repeat(60));
 
         self.print_config_entry("User name", &merged_config.name);
@@ -375,19 +417,41 @@ impl ProfileCommand {
         match (&matching_profile, repo_profile_name) {
             (Some(profile), Some(mapped_name)) => {
                 if profile.name == *mapped_name {
-                    println!("{} Profile '{}' is mapped to this repository", "✓".green(), profile.name.cyan());
+                    println!(
+                        "{} Profile '{}' is mapped to this repository",
+                        "✓".green(),
+                        profile.name.cyan()
+                    );
                     println!("  This repository's git config matches the saved profile.");
                 } else {
-                    println!("{} Profile '{}' matches current config", "✓".green(), profile.name.cyan());
+                    println!(
-                    println!("  But repository is mapped to different profile: {}", mapped_name.yellow());
+                        "{} Profile '{}' matches current config",
+                        "✓".green(),
+                        profile.name.cyan()
+                    );
+                    println!(
+                        "  But repository is mapped to different profile: {}",
+                        mapped_name.yellow()
+                    );
                 }
             }
             (Some(profile), None) => {
-                println!("{} Profile '{}' matches current config", "✓".green(), profile.name.cyan());
+                println!(
-                println!("  {} This repository is not mapped to any profile.", "ℹ".yellow());
+                    "{} Profile '{}' matches current config",
+                    "✓".green(),
+                    profile.name.cyan()
+                );
+                println!(
+                    "  {} This repository is not mapped to any profile.",
+                    "ℹ".yellow()
+                );
             }
             (None, Some(mapped_name)) => {
-                println!("{} Repository is mapped to profile '{}'", "⚠".yellow(), mapped_name.cyan());
+                println!(
+                    "{} Repository is mapped to profile '{}'",
+                    "⚠".yellow(),
+                    mapped_name.cyan()
+                );
                 println!("  But current git config does not match this profile!");
 
                 if let Some(mapped_profile) = manager.get_profile(mapped_name) {
@@ -417,14 +481,18 @@ impl ProfileCommand {
                 }
 
                 if merged_config.is_complete() {
-                    println!("\n  {} Would you like to save this identity as a new profile?", "💡".yellow());
+                    println!(
+                        "\n  {} Would you like to save this identity as a new profile?",
+                        "💡".yellow()
+                    );
                     let save = Confirm::new()
                         .with_prompt("Save current git identity as new profile?")
                         .default(true)
                         .interact()?;
 
                     if save {
-                        self.save_current_identity_as_profile(&merged_config, manager).await?;
+                        self.save_current_identity_as_profile(&merged_config, manager)
+                            .await?;
                     }
                 }
             }
@@ -432,7 +500,10 @@ impl ProfileCommand {
 
         if let Some(profile_name) = name {
             if let Some(profile) = manager.get_profile(profile_name) {
-                println!("\n{}", format!("Requested Profile: {}", profile_name).bold());
+                println!(
+                    "\n{}",
+                    format!("Requested Profile: {}", profile_name).bold()
+                );
                 println!("{}", "─".repeat(60));
                 self.print_profile_details(profile);
             } else {
@@ -486,8 +557,16 @@ impl ProfileCommand {
             Some(value) => {
                 println!("{} {}: {}", source_indicator, label, value);
                 if entry.local_value.is_some() && entry.global_value.is_some() {
-                    println!("    {} local: {}", "├".dimmed(), entry.local_value.as_ref().unwrap());
+                    println!(
-                    println!("    {} global: {}", "└".dimmed(), entry.global_value.as_ref().unwrap());
+                        "    {} local: {}",
+                        "├".dimmed(),
+                        entry.local_value.as_ref().unwrap()
+                    );
+                    println!(
+                        "    {} global: {}",
+                        "└".dimmed(),
+                        entry.global_value.as_ref().unwrap()
+                    );
                 }
             }
             None => {
@@ -504,7 +583,14 @@ impl ProfileCommand {
             println!("Description: {}", desc);
         }
 
-        println!("Work profile: {}", if profile.is_work { "yes".yellow() } else { "no".normal() });
+        println!(
+            "Work profile: {}",
+            if profile.is_work {
+                "yes".yellow()
+            } else {
+                "no".normal()
+            }
+        );
 
         if let Some(ref org) = profile.organization {
             println!("Organization: {}", org);
@@ -543,7 +629,11 @@ impl ProfileCommand {
         }
     }
 
-    async fn save_current_identity_as_profile(&self, merged_config: &crate::git::MergedUserConfig, manager: &ConfigManager) -> Result<()> {
+    async fn save_current_identity_as_profile(
+        &self,
+        merged_config: &crate::git::MergedUserConfig,
+        manager: &ConfigManager,
+    ) -> Result<()> {
         let config_path = manager.path().to_path_buf();
         let mut manager = ConfigManager::with_path(&config_path)?;
 
@@ -557,14 +647,15 @@ impl ProfileCommand {
         let profile_name: String = Input::new()
             .with_prompt("Profile name")
             .default(default_name)
-            .validate_with(|input: &String| {
+            .validate_with(|input: &String| validate_profile_name(input).map_err(|e| e.to_string()))
-                validate_profile_name(input).map_err(|e| e.to_string())
-            })
             .interact_text()?;
 
         if manager.has_profile(&profile_name) {
             let overwrite = Confirm::new()
-                .with_prompt(format!("Profile '{}' already exists. Overwrite?", profile_name))
+                .with_prompt(format!(
+                    "Profile '{}' already exists. Overwrite?",
+                    profile_name
+                ))
                 .default(false)
                 .interact()?;
             if !overwrite {
@@ -585,9 +676,7 @@ impl ProfileCommand {
             .interact()?;
 
         let organization = if is_work {
-            Some(Input::new()
+            Some(Input::new().with_prompt("Organization").interact_text()?)
-                .with_prompt("Organization")
-                .interact_text()?)
         } else {
             None
         };
@@ -635,7 +724,11 @@ impl ProfileCommand {
         manager.add_profile(profile_name.clone(), profile)?;
         manager.save()?;
 
-        println!("{} Profile '{}' saved successfully", "✓".green(), profile_name.cyan());
+        println!(
+            "{} Profile '{}' saved successfully",
+            "✓".green(),
+            profile_name.cyan()
+        );
 
         let set_default = Confirm::new()
             .with_prompt("Set as default profile?")
@@ -645,7 +738,11 @@ impl ProfileCommand {
         if set_default {
             manager.set_default_profile(Some(profile_name.clone()))?;
             manager.save()?;
-            println!("{} Set '{}' as default profile", "✓".green(), profile_name.cyan());
+            println!(
+                "{} Set '{}' as default profile",
+                "✓".green(),
+                profile_name.cyan()
+            );
         }
 
         Ok(())
@@ -654,7 +751,8 @@ impl ProfileCommand {
     async fn edit_profile(&self, name: &str, config_path: &Option<PathBuf>) -> Result<()> {
         let mut manager = self.get_manager(config_path)?;
 
-        let profile = manager.get_profile(name)
+        let profile = manager
+            .get_profile(name)
             .ok_or_else(|| anyhow::anyhow!("Profile '{}' not found", name))?
             .clone();
 
@@ -711,31 +809,47 @@ impl ProfileCommand {
         manager.set_repo_profile(repo_path.clone(), name.to_string())?;
 
         // Get the profile and apply it to the repository
-        let profile = manager.get_profile(name)
+        let profile = manager
+            .get_profile(name)
             .ok_or_else(|| anyhow::anyhow!("Profile '{}' not found", name))?;
 
         profile.apply_to_repo(repo.inner())?;
         manager.record_profile_usage(name, Some(repo_path))?;
         manager.save()?;
 
-        println!("{} Set '{}' for current repository", "✓".green(), name.cyan());
+        println!(
-        println!("{} Applied profile '{}' to current repository", "✓".green(), name.cyan());
+            "{} Set '{}' for current repository",
+            "✓".green(),
+            name.cyan()
+        );
+        println!(
+            "{} Applied profile '{}' to current repository",
+            "✓".green(),
+            name.cyan()
+        );
 
         Ok(())
     }
 
-    async fn apply_profile(&self, name: Option<&str>, global: bool, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn apply_profile(
+        &self,
+        name: Option<&str>,
+        global: bool,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         let mut manager = self.get_manager(config_path)?;
 
         let profile_name = if let Some(n) = name {
             n.to_string()
         } else {
-            manager.default_profile_name()
+            manager
+                .default_profile_name()
                 .ok_or_else(|| anyhow::anyhow!("No default profile set"))?
                 .clone()
         };
 
-        let profile = manager.get_profile(&profile_name)
+        let profile = manager
+            .get_profile(&profile_name)
             .ok_or_else(|| anyhow::anyhow!("Profile '{}' not found", profile_name))?
             .clone();
 
@@ -748,11 +862,19 @@ impl ProfileCommand {
 
         if global {
             profile.apply_global()?;
-            println!("{} Applied profile '{}' globally", "✓".green(), profile.name.cyan());
+            println!(
+                "{} Applied profile '{}' globally",
+                "✓".green(),
+                profile.name.cyan()
+            );
         } else {
             let repo = find_repo(std::env::current_dir()?.as_path())?;
             profile.apply_to_repo(repo.inner())?;
-            println!("{} Applied profile '{}' to current repository", "✓".green(), profile.name.cyan());
+            println!(
+                "{} Applied profile '{}' to current repository",
+                "✓".green(),
+                profile.name.cyan()
+            );
         }
 
         manager.record_profile_usage(&profile_name, repo_path)?;
@@ -764,7 +886,8 @@ impl ProfileCommand {
     async fn switch_profile(&self, config_path: &Option<PathBuf>) -> Result<()> {
         let mut manager = self.get_manager(config_path)?;
 
-        let profiles: Vec<String> = manager.list_profiles()
+        let profiles: Vec<String> = manager
+            .list_profiles()
             .into_iter()
             .map(|s| s.to_string())
             .collect();
@@ -798,17 +921,24 @@ impl ProfileCommand {
                 .interact()?;
 
             if apply {
-                self.apply_profile(Some(selected), false, config_path).await?;
+                self.apply_profile(Some(selected), false, config_path)
+                    .await?;
             }
         }
 
         Ok(())
     }
 
-    async fn copy_profile(&self, from: &str, to: &str, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn copy_profile(
+        &self,
+        from: &str,
+        to: &str,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         let mut manager = self.get_manager(config_path)?;
 
-        let source = manager.get_profile(from)
+        let source = manager
+            .get_profile(from)
             .ok_or_else(|| anyhow::anyhow!("Profile '{}' not found", from))?
             .clone();
 
@@ -821,20 +951,38 @@ impl ProfileCommand {
         manager.add_profile(to.to_string(), new_profile)?;
         manager.save()?;
 
-        println!("{} Copied profile '{}' to '{}'", "✓".green(), from, to.cyan());
+        println!(
+            "{} Copied profile '{}' to '{}'",
+            "✓".green(),
+            from,
+            to.cyan()
+        );
 
         Ok(())
     }
 
-    async fn handle_token_command(&self, cmd: &TokenSubcommand, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn handle_token_command(
+        &self,
+        cmd: &TokenSubcommand,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         match cmd {
-            TokenSubcommand::Add { profile, service } => self.add_token(profile, service, config_path).await,
+            TokenSubcommand::Add { profile, service } => {
-            TokenSubcommand::Remove { profile, service } => self.remove_token(profile, service, config_path).await,
+                self.add_token(profile, service, config_path).await
+            }
+            TokenSubcommand::Remove { profile, service } => {
+                self.remove_token(profile, service, config_path).await
+            }
             TokenSubcommand::List { profile } => self.list_tokens(profile, config_path).await,
         }
     }
 
-    async fn add_token(&self, profile_name: &str, service: &str, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn add_token(
+        &self,
+        profile_name: &str,
+        service: &str,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         let mut manager = self.get_manager(config_path)?;
 
         if !manager.has_profile(profile_name) {
@@ -842,10 +990,15 @@ impl ProfileCommand {
         }
 
         if !manager.keyring().is_available() {
-            bail!("Keyring is not available. Cannot store PAT securely. Please ensure your system keyring is accessible.");
+            bail!(
+                "Keyring is not available. Cannot store PAT securely. Please ensure your system keyring is accessible."
+            );
         }
 
-        println!("{}", format!("\nAdd token to profile '{}'", profile_name).bold());
+        println!(
+            "{}",
+            format!("\nAdd token to profile '{}'", profile_name).bold()
+        );
         println!("{}", "─".repeat(40));
 
         let token_value: String = Input::new()
@@ -882,12 +1035,22 @@ impl ProfileCommand {
         manager.add_token_to_profile(profile_name, service.to_string(), token)?;
         manager.save()?;
 
-        println!("{} Token for '{}' added to profile '{}' (stored securely in keyring)", "✓".green(), service.cyan(), profile_name);
+        println!(
+            "{} Token for '{}' added to profile '{}' (stored securely in keyring)",
+            "✓".green(),
+            service.cyan(),
+            profile_name
+        );
 
         Ok(())
     }
 
-    async fn remove_token(&self, profile_name: &str, service: &str, config_path: &Option<PathBuf>) -> Result<()> {
+    async fn remove_token(
+        &self,
+        profile_name: &str,
+        service: &str,
+        config_path: &Option<PathBuf>,
+    ) -> Result<()> {
         let mut manager = self.get_manager(config_path)?;
 
         if !manager.has_profile(profile_name) {
@@ -895,7 +1058,10 @@ impl ProfileCommand {
         }
 
         let confirm = Confirm::new()
-            .with_prompt(format!("Remove token '{}' from profile '{}'?", service, profile_name))
+            .with_prompt(format!(
+                "Remove token '{}' from profile '{}'?",
+                service, profile_name
+            ))
             .default(false)
             .interact()?;
 
@@ -907,7 +1073,12 @@ impl ProfileCommand {
         manager.remove_token_from_profile(profile_name, service)?;
         manager.save()?;
 
-        println!("{} Token '{}' removed from profile '{}' (deleted from keyring)", "✓".green(), service, profile_name);
+        println!(
+            "{} Token '{}' removed from profile '{}' (deleted from keyring)",
+            "✓".green(),
+            service,
+            profile_name
+        );
 
         Ok(())
     }
@@ -915,15 +1086,23 @@ impl ProfileCommand {
     async fn list_tokens(&self, profile_name: &str, config_path: &Option<PathBuf>) -> Result<()> {
         let manager = self.get_manager(config_path)?;
 
-        let profile = manager.get_profile(profile_name)
+        let profile = manager
+            .get_profile(profile_name)
             .ok_or_else(|| anyhow::anyhow!("Profile '{}' not found", profile_name))?;
 
         if profile.tokens.is_empty() {
-            println!("{} No tokens configured for profile '{}'", "ℹ".yellow(), profile_name);
+            println!(
+                "{} No tokens configured for profile '{}'",
+                "ℹ".yellow(),
+                profile_name
+            );
             return Ok(());
         }
 
-        println!("{}", format!("\nTokens for profile '{}':", profile_name).bold());
+        println!(
+            "{}",
+            format!("\nTokens for profile '{}':", profile_name).bold()
+        );
         println!("{}", "─".repeat(40));
 
         for (service, token) in &profile.tokens {
@@ -934,7 +1113,12 @@ impl ProfileCommand {
                 format!("[{}]", "not stored".yellow())
             };
 
-            println!("{} {} ({})", service.cyan().bold(), status, token.token_type);
+            println!(
+                "{} {} ({})",
+                service.cyan().bold(),
+                status,
+                token.token_type
+            );
             if let Some(ref desc) = token.description {
                 println!("  {}", desc);
             }
@@ -952,7 +1136,8 @@ impl ProfileCommand {
         let profile_name = if let Some(n) = name {
             n.to_string()
         } else {
-            manager.default_profile_name()
+            manager
+                .default_profile_name()
                 .ok_or_else(|| anyhow::anyhow!("No default profile set"))?
                 .clone()
         };
@@ -960,13 +1145,26 @@ impl ProfileCommand {
         let repo = find_repo(std::env::current_dir()?.as_path())?;
         let comparison = manager.check_profile_config(&profile_name, repo.inner())?;
 
-        println!("{}", format!("\nChecking profile '{}' against git configuration", profile_name).bold());
+        println!(
+            "{}",
+            format!(
+                "\nChecking profile '{}' against git configuration",
+                profile_name
+            )
+            .bold()
+        );
         println!("{}", "─".repeat(60));
 
         if comparison.matches {
-            println!("{} Profile configuration matches git settings", "✓".green().bold());
+            println!(
+                "{} Profile configuration matches git settings",
+                "✓".green().bold()
+            );
         } else {
-            println!("{} Profile configuration differs from git settings", "✗".red().bold());
+            println!(
+                "{} Profile configuration differs from git settings",
+                "✗".red().bold()
+            );
             println!("\n{}", "Differences:".bold());
 
             for diff in &comparison.differences {
@@ -983,7 +1181,8 @@ impl ProfileCommand {
         let manager = self.get_manager(config_path)?;
 
         if let Some(n) = name {
-            let profile = manager.get_profile(n)
+            let profile = manager
+                .get_profile(n)
                 .ok_or_else(|| anyhow::anyhow!("Profile '{}' not found", n))?;
 
             self.show_single_profile_stats(profile);
@@ -1048,9 +1247,7 @@ impl ProfileCommand {
     }
 
     async fn setup_gpg_interactive(&self) -> Result<GpgConfig> {
-        let key_id: String = Input::new()
+        let key_id: String = Input::new().with_prompt("GPG key ID").interact_text()?;
-            .with_prompt("GPG key ID")
-            .interact_text()?;
 
         Ok(GpgConfig {
             key_id,
@@ -1061,9 +1258,16 @@ impl ProfileCommand {
         })
     }
 
-    async fn setup_token_interactive(&self, profile: &mut GitProfile, manager: &ConfigManager) -> Result<()> {
+    async fn setup_token_interactive(
+        &self,
+        profile: &mut GitProfile,
+        manager: &ConfigManager,
+    ) -> Result<()> {
         if !manager.keyring().is_available() {
-            println!("{} Keyring is not available. Cannot store PAT securely.", "⚠".yellow());
+            println!(
+                "{} Keyring is not available. Cannot store PAT securely.",
+                "⚠".yellow()
+            );
             let continue_anyway = Confirm::new()
                 .with_prompt("Continue without secure token storage?")
                 .default(false)
@@ -1077,9 +1281,7 @@ impl ProfileCommand {
             .with_prompt("Service name (e.g., github, gitlab)")
             .interact_text()?;
 
-        let token_value: String = Input::new()
+        let token_value: String = Input::new().with_prompt("Token value").interact_text()?;
-            .with_prompt("Token value")
-            .interact_text()?;
 
         let token = TokenConfig::new(TokenType::Personal);
 

src/commands/tag.rs

@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use clap::Parser;
 use colored::Colorize;
 use dialoguer::{Confirm, Input, Select};
@@ -6,11 +6,11 @@ use semver::Version;
 use std::path::PathBuf;
 
 use crate::config::{Language, manager::ConfigManager};
-use crate::git::{find_repo, GitRepo};
 use crate::generator::ContentGenerator;
 use crate::git::tag::{
-    bump_version, get_latest_version, suggest_version_bump, TagBuilder, VersionBump,
+    TagBuilder, VersionBump, bump_version, get_latest_version, suggest_version_bump,
 };
+use crate::git::{GitRepo, find_repo};
 use crate::i18n::Messages;
 
 /// Generate and create Git tags
@@ -83,8 +83,8 @@ impl TagCommand {
         } else if let Some(bump_str) = &self.bump {
             // Calculate bumped version
             let prefix = &config.tag.version_prefix;
-            let latest = get_latest_version(&repo, prefix)?
+            let latest =
-                .unwrap_or_else(|| Version::new(0, 0, 0));
+                get_latest_version(&repo, prefix)?.unwrap_or_else(|| Version::new(0, 0, 0));
 
             let bump = VersionBump::from_str(bump_str)?;
             let new_version = bump_version(&latest, bump, None);
@@ -92,11 +92,18 @@ impl TagCommand {
             format!("{}{}", prefix, new_version)
         } else {
             // Interactive mode
-            self.select_version_interactive(&repo, &config.tag.version_prefix, &messages).await?
+            self.select_version_interactive(&repo, &config.tag.version_prefix, &messages)
+                .await?
         };
 
         // Validate tag name (if it looks like a version)
-        if tag_name.starts_with('v') || tag_name.chars().next().map(|c| c.is_ascii_digit()).unwrap_or(false) {
+        if tag_name.starts_with('v')
+            || tag_name
+                .chars()
+                .next()
+                .map(|c| c.is_ascii_digit())
+                .unwrap_or(false)
+        {
             let version_str = tag_name.trim_start_matches('v');
             if let Err(e) = crate::utils::validators::validate_semver(version_str) {
                 println!("{}: {}", "Warning".yellow(), e);
@@ -120,7 +127,10 @@ impl TagCommand {
         } else if let Some(msg) = &self.message {
             Some(msg.clone())
         } else if self.generate || (config.tag.auto_generate && !self.yes) {
-            Some(self.generate_tag_message(&repo, &tag_name, &messages).await?)
+            Some(
+                self.generate_tag_message(&repo, &tag_name, &messages)
+                    .await?,
+            )
         } else if !self.yes {
             Some(self.input_message_interactive(&tag_name, &messages)?)
         } else {
@@ -188,7 +198,12 @@ impl TagCommand {
         Ok(())
     }
 
-    async fn select_version_interactive(&self, repo: &GitRepo, prefix: &str, messages: &Messages) -> Result<String> {
+    async fn select_version_interactive(
+        &self,
+        repo: &GitRepo,
+        prefix: &str,
+        messages: &Messages,
+    ) -> Result<String> {
         loop {
             let latest = get_latest_version(repo, prefix)?;
 
@@ -220,11 +235,18 @@ impl TagCommand {
                     // Auto-detect
                     let commits = repo.get_commits(50)?;
                     let bump = suggest_version_bump(&commits);
-                    let version = latest.as_ref()
+                    let version = latest
+                        .as_ref()
                         .map(|v| bump_version(v, bump, None))
                         .unwrap_or_else(|| Version::new(0, 1, 0));
 
-                    println!("{} {:?} → {}{}", messages.suggested_bump(), bump, prefix, version);
+                    println!(
+                        "{} {:?} → {}{}",
+                        messages.suggested_bump(),
+                        bump,
+                        prefix,
+                        version
+                    );
 
                     let confirm = Confirm::new()
                         .with_prompt(messages.use_this_version())
@@ -237,19 +259,22 @@ impl TagCommand {
                     // User rejected, continue the loop
                 }
                 1 => {
-                    let version = latest.as_ref()
+                    let version = latest
+                        .as_ref()
                         .map(|v| bump_version(v, VersionBump::Major, None))
                         .unwrap_or_else(|| Version::new(1, 0, 0));
                     return Ok(format!("{}{}", prefix, version));
                 }
                 2 => {
-                    let version = latest.as_ref()
+                    let version = latest
+                        .as_ref()
                         .map(|v| bump_version(v, VersionBump::Minor, None))
                         .unwrap_or_else(|| Version::new(0, 1, 0));
                     return Ok(format!("{}{}", prefix, version));
                 }
                 3 => {
-                    let version = latest.as_ref()
+                    let version = latest
+                        .as_ref()
                         .map(|v| bump_version(v, VersionBump::Patch, None))
                         .unwrap_or_else(|| Version::new(0, 0, 1));
                     return Ok(format!("{}{}", prefix, version));
@@ -272,7 +297,12 @@ impl TagCommand {
         }
     }
 
-    async fn generate_tag_message(&self, repo: &GitRepo, version: &str, messages: &Messages) -> Result<String> {
+    async fn generate_tag_message(
+        &self,
+        repo: &GitRepo,
+        version: &str,
+        messages: &Messages,
+    ) -> Result<String> {
         let manager = ConfigManager::new()?;
         let language = manager.get_language().unwrap_or(Language::English);
 
@@ -290,7 +320,9 @@ impl TagCommand {
         println!("{}", messages.ai_generating_tag(commits.len()));
 
         let generator = ContentGenerator::new_with_think(&manager, self.think).await?;
-        generator.generate_tag_message(version, &commits, language).await
+        generator
+            .generate_tag_message(version, &commits, language)
+            .await
     }
 
     fn input_message_interactive(&self, version: &str, messages: &Messages) -> Result<String> {

src/config/manager.rs

@@ -1,6 +1,8 @@
 use super::{AppConfig, GitProfile, TokenConfig};
-use crate::utils::keyring::{KeyringManager, get_default_base_url, get_default_model, provider_needs_api_key};
+use crate::utils::keyring::{
-use anyhow::{bail, Context, Result};
+    KeyringManager, get_default_base_url, get_default_model, provider_needs_api_key,
+};
+use anyhow::{Context, Result, bail};
 // use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
@@ -137,7 +139,8 @@ impl ConfigManager {
     /// Set default profile
     pub fn set_default_profile(&mut self, name: Option<String>) -> Result<()> {
         if let Some(ref n) = name
-            && !self.config.profiles.contains_key(n) {
+            && !self.config.profiles.contains_key(n)
+        {
             bail!("Profile '{}' does not exist", n);
         }
         self.config.default_profile = name;
@@ -177,7 +180,12 @@ impl ConfigManager {
     // Token management
 
     /// Add a token to a profile (stores token in keyring)
-    pub fn add_token_to_profile(&mut self, profile_name: &str, service: String, token: TokenConfig) -> Result<()> {
+    pub fn add_token_to_profile(
+        &mut self,
+        profile_name: &str,
+        service: String,
+        token: TokenConfig,
+    ) -> Result<()> {
         if !self.config.profiles.contains_key(profile_name) {
             bail!("Profile '{}' does not exist", profile_name);
         }
@@ -191,18 +199,26 @@ impl ConfigManager {
     }
 
     /// Store a PAT token in keyring for a profile
-    pub fn store_pat_for_profile(&self, profile_name: &str, service: &str, token_value: &str) -> Result<()> {
+    pub fn store_pat_for_profile(
-        let profile = self.get_profile(profile_name)
+        &self,
+        profile_name: &str,
+        service: &str,
+        token_value: &str,
+    ) -> Result<()> {
+        let profile = self
+            .get_profile(profile_name)
             .ok_or_else(|| anyhow::anyhow!("Profile '{}' not found", profile_name))?;
 
         let user_email = &profile.user_email;
 
-        self.keyring.store_pat(profile_name, user_email, service, token_value)
+        self.keyring
+            .store_pat(profile_name, user_email, service, token_value)
     }
 
     /// Get a PAT token from keyring for a profile
     pub fn get_pat_for_profile(&self, profile_name: &str, service: &str) -> Result<Option<String>> {
-        let profile = self.get_profile(profile_name)
+        let profile = self
+            .get_profile(profile_name)
             .ok_or_else(|| anyhow::anyhow!("Profile '{}' not found", profile_name))?;
 
         let user_email = &profile.user_email;
@@ -226,14 +242,33 @@ impl ConfigManager {
             bail!("Profile '{}' does not exist", profile_name);
         }
 
-        let user_email = self.config.profiles.get(profile_name).unwrap().user_email.clone();
+        let user_email = self
-        let services: Vec<String> = self.config.profiles.get(profile_name).unwrap().tokens.keys().cloned().collect();
+            .config
+            .profiles
+            .get(profile_name)
+            .unwrap()
+            .user_email
+            .clone();
+        let services: Vec<String> = self
+            .config
+            .profiles
+            .get(profile_name)
+            .unwrap()
+            .tokens
+            .keys()
+            .cloned()
+            .collect();
 
         if !services.contains(&service.to_string()) {
-            bail!("Token for service '{}' not found in profile '{}'", service, profile_name);
+            bail!(
+                "Token for service '{}' not found in profile '{}'",
+                service,
+                profile_name
+            );
         }
 
-        self.keyring.delete_pat(profile_name, &user_email, service)?;
+        self.keyring
+            .delete_pat(profile_name, &user_email, service)?;
 
         if let Some(profile) = self.config.profiles.get_mut(profile_name) {
             profile.remove_token(service);
@@ -249,7 +284,8 @@ impl ConfigManager {
             let user_email = &profile.user_email;
             let services: Vec<String> = profile.tokens.keys().cloned().collect();
 
-            self.keyring.delete_all_pats_for_profile(profile_name, user_email, &services)?;
+            self.keyring
+                .delete_all_pats_for_profile(profile_name, user_email, &services)?;
         }
         Ok(())
     }
@@ -301,14 +337,24 @@ impl ConfigManager {
     // }
 
     /// Check and compare profile with git configuration
-    pub fn check_profile_config(&self, profile_name: &str, repo: &git2::Repository) -> Result<super::ProfileComparison> {
+    pub fn check_profile_config(
-        let profile = self.get_profile(profile_name)
+        &self,
+        profile_name: &str,
+        repo: &git2::Repository,
+    ) -> Result<super::ProfileComparison> {
+        let profile = self
+            .get_profile(profile_name)
             .ok_or_else(|| anyhow::anyhow!("Profile '{}' not found", profile_name))?;
         profile.compare_with_git_config(repo)
     }
 
     /// Find a profile that matches the given user config (name, email, signing_key)
-    pub fn find_matching_profile(&self, user_name: &str, user_email: &str, signing_key: Option<&str>) -> Option<&GitProfile> {
+    pub fn find_matching_profile(
+        &self,
+        user_name: &str,
+        user_email: &str,
+        signing_key: Option<&str>,
+    ) -> Option<&GitProfile> {
         for profile in self.config.profiles.values() {
             let name_match = profile.user_name == user_name;
             let email_match = profile.user_email == user_email;
@@ -328,7 +374,9 @@ impl ConfigManager {
 
     /// Find profiles that partially match (same name or same email)
     pub fn find_partial_matches(&self, user_name: &str, user_email: &str) -> Vec<&GitProfile> {
-        self.config.profiles.values()
+        self.config
+            .profiles
+            .values()
             .filter(|p| p.user_name == user_name || p.user_email == user_email)
             .collect()
     }
@@ -383,7 +431,11 @@ impl ConfigManager {
     /// Get API key from configured storage method
     pub fn get_api_key(&self) -> Option<String> {
         // First try environment variables (always checked)
-        if let Some(key) = self.keyring.get_api_key(&self.config.llm.provider).unwrap_or(None) {
+        if let Some(key) = self
+            .keyring
+            .get_api_key(&self.config.llm.provider)
+            .unwrap_or(None)
+        {
             return Some(key);
         }
 
@@ -400,20 +452,29 @@ impl ConfigManager {
         match self.config.llm.api_key_storage.as_str() {
             "keyring" => {
                 if !self.keyring.is_available() {
-                    bail!("Keyring is not available. Set QUICOMMIT_API_KEY environment variable instead or change api_key_storage to 'config'.");
+                    bail!(
+                        "Keyring is not available. Set QUICOMMIT_API_KEY environment variable instead or change api_key_storage to 'config'."
+                    );
+                }
+                self.keyring
+                    .store_api_key(&self.config.llm.provider, api_key)
             }
-                self.keyring.store_api_key(&self.config.llm.provider, api_key)
-            },
             "config" => {
                 // We can't modify self.config here since self is immutable
                 // This will be handled by the caller updating the config
                 Ok(())
-            },
+            }
             "environment" => {
-                bail!("API key storage set to 'environment'. Please set QUICOMMIT_{}_API_KEY environment variable.", self.config.llm.provider.to_uppercase());
+                bail!(
-            },
+                    "API key storage set to 'environment'. Please set QUICOMMIT_{}_API_KEY environment variable.",
+                    self.config.llm.provider.to_uppercase()
+                );
+            }
             _ => {
-                bail!("Invalid API key storage method: {}", self.config.llm.api_key_storage);
+                bail!(
+                    "Invalid API key storage method: {}",
+                    self.config.llm.api_key_storage
+                );
             }
         }
     }
@@ -425,16 +486,19 @@ impl ConfigManager {
                 if self.keyring.is_available() {
                     self.keyring.delete_api_key(&self.config.llm.provider)?;
                 }
-            },
+            }
             "config" => {
                 // We can't modify self.config here since self is immutable
                 // This will be handled by the caller updating the config
-            },
+            }
             "environment" => {
                 // Environment variables are not managed by the app
-            },
+            }
             _ => {
-                bail!("Invalid API key storage method: {}", self.config.llm.api_key_storage);
+                bail!(
+                    "Invalid API key storage method: {}",
+                    self.config.llm.api_key_storage
+                );
             }
         }
         Ok(())
@@ -447,7 +511,12 @@ impl ConfigManager {
         }
 
         // Check environment variables
-        if self.keyring.get_api_key(&self.config.llm.provider).unwrap_or(None).is_some() {
+        if self
+            .keyring
+            .get_api_key(&self.config.llm.provider)
+            .unwrap_or(None)
+            .is_some()
+        {
             return true;
         }
 
@@ -575,14 +644,12 @@ impl ConfigManager {
 
     /// Export configuration to TOML string
     pub fn export(&self) -> Result<String> {
-        toml::to_string_pretty(&self.config)
+        toml::to_string_pretty(&self.config).context("Failed to serialize config")
-            .context("Failed to serialize config")
     }
 
     /// Import configuration from TOML string
     pub fn import(&mut self, toml_str: &str) -> Result<()> {
-        self.config = toml::from_str(toml_str)
+        self.config = toml::from_str(toml_str).context("Failed to parse config")?;
-            .context("Failed to parse config")?;
         self.modified = true;
         Ok(())
     }

src/config/mod.rs

@@ -7,10 +7,7 @@ use std::path::{Path, PathBuf};
 pub mod manager;
 pub mod profile;
 
-pub use profile::{
+pub use profile::{GitProfile, ProfileComparison, TokenConfig, TokenType};
-    GitProfile, TokenConfig, TokenType,
-    ProfileComparison
-};
 
 /// Application configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -494,8 +491,7 @@ impl AppConfig {
 
     /// Save configuration to file
     pub fn save(&self, path: &Path) -> Result<()> {
-        let content = toml::to_string_pretty(self)
+        let content = toml::to_string_pretty(self).context("Failed to serialize config")?;
-            .context("Failed to serialize config")?;
 
         if let Some(parent) = path.parent() {
             fs::create_dir_all(parent)
@@ -510,8 +506,7 @@ impl AppConfig {
 
     /// Get default config path
     pub fn default_path() -> Result<PathBuf> {
-        let config_dir = dirs::config_dir()
+        let config_dir = dirs::config_dir().context("Could not find config directory")?;
-            .context("Could not find config directory")?;
         Ok(config_dir.join("quicommit").join("config.toml"))
     }
 

src/config/profile.rs

@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
@@ -119,7 +119,8 @@ impl GitProfile {
 
     /// Get signing key (from GPG config or direct)
     pub fn signing_key(&self) -> Option<&str> {
-        self.signing_key.as_deref()
+        self.signing_key
+            .as_deref()
             .or_else(|| self.gpg.as_ref().map(|g| g.key_id.as_str()))
     }
 
@@ -174,17 +175,19 @@ impl GitProfile {
         }
 
         if let Some(ref ssh) = self.ssh
-            && let Some(ref key_path) = ssh.private_key_path {
+            && let Some(ref key_path) = ssh.private_key_path
+        {
             let path_str = key_path.display().to_string();
             #[cfg(target_os = "windows")]
             {
-                    config.set_str("core.sshCommand", 
+                config.set_str(
-                        &format!("ssh -i \"{}\"", path_str.replace('\\', "/")))?;
+                    "core.sshCommand",
+                    &format!("ssh -i \"{}\"", path_str.replace('\\', "/")),
+                )?;
             }
             #[cfg(not(target_os = "windows"))]
             {
-                    config.set_str("core.sshCommand", 
+                config.set_str("core.sshCommand", &format!("ssh -i '{}'", path_str))?;
-                        &format!("ssh -i '{}'", path_str))?;
             }
         }
 
@@ -211,17 +214,19 @@ impl GitProfile {
         }
 
         if let Some(ref ssh) = self.ssh
-            && let Some(ref key_path) = ssh.private_key_path {
+            && let Some(ref key_path) = ssh.private_key_path
+        {
             let path_str = key_path.display().to_string();
             #[cfg(target_os = "windows")]
             {
-                    config.set_str("core.sshCommand", 
+                config.set_str(
-                        &format!("ssh -i \"{}\"", path_str.replace('\\', "/")))?;
+                    "core.sshCommand",
+                    &format!("ssh -i \"{}\"", path_str.replace('\\', "/")),
+                )?;
             }
             #[cfg(not(target_os = "windows"))]
             {
-                    config.set_str("core.sshCommand", 
+                config.set_str("core.sshCommand", &format!("ssh -i '{}'", path_str))?;
-                        &format!("ssh -i '{}'", path_str))?;
             }
         }
 
@@ -261,7 +266,8 @@ impl GitProfile {
         }
 
         if let Some(profile_key) = self.signing_key()
-            && git_signing_key.as_deref() != Some(profile_key) {
+            && git_signing_key.as_deref() != Some(profile_key)
+        {
             comparison.matches = false;
             comparison.differences.push(ConfigDifference {
                 key: "user.signingkey".to_string(),
@@ -275,8 +281,7 @@ impl GitProfile {
 }
 
 /// Profile settings
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-#[derive(Default)]
 pub struct ProfileSettings {
     /// Automatically sign commits
     #[serde(default)]
@@ -303,7 +308,6 @@ pub struct ProfileSettings {
     pub commit_template: Option<String>,
 }
 
-
 /// SSH configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SshConfig {
@@ -334,12 +338,14 @@ impl SshConfig {
     /// Validate SSH configuration
     pub fn validate(&self) -> Result<()> {
         if let Some(ref path) = self.private_key_path
-            && !path.exists() {
+            && !path.exists()
+        {
             bail!("SSH private key does not exist: {:?}", path);
         }
 
         if let Some(ref path) = self.public_key_path
-            && !path.exists() {
+            && !path.exists()
+        {
             bail!("SSH public key does not exist: {:?}", path);
         }
 
@@ -487,7 +493,6 @@ pub enum TokenType {
     App,
 }
 
-
 impl std::fmt::Display for TokenType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -617,9 +622,15 @@ impl GitProfileBuilder {
     }
 
     pub fn build(self) -> Result<GitProfile> {
-        let name = self.name.ok_or_else(|| anyhow::anyhow!("Name is required"))?;
+        let name = self
-        let user_name = self.user_name.ok_or_else(|| anyhow::anyhow!("User name is required"))?;
+            .name
-        let user_email = self.user_email.ok_or_else(|| anyhow::anyhow!("User email is required"))?;
+            .ok_or_else(|| anyhow::anyhow!("Name is required"))?;
+        let user_name = self
+            .user_name
+            .ok_or_else(|| anyhow::anyhow!("User name is required"))?;
+        let user_email = self
+            .user_email
+            .ok_or_else(|| anyhow::anyhow!("User email is required"))?;
 
         Ok(GitProfile {
             name,

src/generator/mod.rs

@@ -1,5 +1,5 @@
-use crate::config::{CommitFormat, Language};
 use crate::config::manager::ConfigManager;
+use crate::config::{CommitFormat, Language};
 use crate::git::{CommitInfo, GitRepo};
 use crate::llm::{GeneratedCommit, LlmClient};
 use anyhow::{Context, Result};
@@ -65,7 +65,9 @@ impl ContentGenerator {
             diff.to_string()
         };
 
-        self.llm_client.generate_commit_message(&truncated_diff, format, language).await
+        self.llm_client
+            .generate_commit_message(&truncated_diff, format, language)
+            .await
     }
 
     /// Generate commit message from repository changes
@@ -75,7 +77,8 @@ impl ContentGenerator {
         format: CommitFormat,
         language: Language,
     ) -> Result<GeneratedCommit> {
-        let diff = repo.get_staged_diff_sorted()
+        let diff = repo
+            .get_staged_diff_sorted()
             .context("Failed to get staged diff")?;
 
         if diff.is_empty() {
@@ -92,12 +95,12 @@ impl ContentGenerator {
         commits: &[CommitInfo],
         language: Language,
     ) -> Result<String> {
-        let commit_messages: Vec<String> = commits
+        let commit_messages: Vec<String> =
-            .iter()
+            commits.iter().map(|c| c.subject().to_string()).collect();
-            .map(|c| c.subject().to_string())
-            .collect();
 
-        self.llm_client.generate_tag_message(version, &commit_messages, language).await
+        self.llm_client
+            .generate_tag_message(version, &commit_messages, language)
+            .await
     }
 
     /// Generate changelog entry
@@ -115,7 +118,9 @@ impl ContentGenerator {
             })
             .collect();
 
-        self.llm_client.generate_changelog_entry(version, &typed_commits, language).await
+        self.llm_client
+            .generate_changelog_entry(version, &typed_commits, language)
+            .await
     }
 
     /// Generate changelog from repository
@@ -132,7 +137,8 @@ impl ContentGenerator {
             repo.get_commits(50)?
         };
 
-        self.generate_changelog_entry(version, &commits, language).await
+        self.generate_changelog_entry(version, &commits, language)
+            .await
     }
 
     /// Interactive commit generation with user feedback
@@ -159,7 +165,9 @@ impl ContentGenerator {
 
         // Generate initial commit
         println!("\nGenerating commit message...");
-        let mut generated = self.generate_commit_message(&diff, format, language).await?;
+        let mut generated = self
+            .generate_commit_message(&diff, format, language)
+            .await?;
 
         loop {
             println!("\n{}", "─".repeat(60));
@@ -185,7 +193,9 @@ impl ContentGenerator {
                 0 => return Ok(generated),
                 1 => {
                     println!("Regenerating...");
-                    generated = self.generate_commit_message(&diff, format, language).await?;
+                    generated = self
+                        .generate_commit_message(&diff, format, language)
+                        .await?;
                 }
                 2 => {
                     let edited = crate::utils::editor::edit_content(&generated.to_conventional())?;
@@ -237,9 +247,13 @@ pub mod fallback {
             f.ends_with(".rs") || f.ends_with(".py") || f.ends_with(".js") || f.ends_with(".ts")
         });
 
-        let has_docs = files.iter().any(|f| f.ends_with(".md") || f.contains("README"));
+        let has_docs = files
+            .iter()
+            .any(|f| f.ends_with(".md") || f.contains("README"));
 
-        let has_tests = files.iter().any(|f| f.contains("test") || f.contains("spec"));
+        let has_tests = files
+            .iter()
+            .any(|f| f.contains("test") || f.contains("spec"));
 
         if has_tests {
             "test: update tests".to_string()

src/git/changelog.rs

@@ -95,9 +95,7 @@ impl ChangelogGenerator {
             ChangelogFormat::GitHubReleases => {
                 self.generate_github_releases(version, date, commits)
             }
-            ChangelogFormat::Custom => {
+            ChangelogFormat::Custom => self.generate_custom(version, date, commits),
-                self.generate_custom(version, date, commits)
-            }
         }
     }
 
@@ -357,7 +355,12 @@ impl ChangelogGenerator {
     }
 
     fn format_commit_github(&self, commit: &CommitInfo) -> String {
-        format!("- {} by @{} in {}\n", commit.subject(), commit.author, &commit.short_id)
+        format!(
+            "- {} by @{} in {}\n",
+            commit.subject(),
+            commit.author,
+            &commit.short_id
+        )
     }
 
     fn group_commits<'a>(&self, commits: &'a [CommitInfo]) -> HashMap<String, Vec<&'a CommitInfo>> {
@@ -380,8 +383,7 @@ impl Default for ChangelogGenerator {
 
 /// Read existing changelog
 pub fn read_changelog(path: &Path) -> Result<String> {
-    fs::read_to_string(path)
+    fs::read_to_string(path).with_context(|| format!("Failed to read changelog: {:?}", path))
-        .with_context(|| format!("Failed to read changelog: {:?}", path))
 }
 
 /// Initialize new changelog file
@@ -413,11 +415,7 @@ pub fn generate_from_history(
 }
 
 /// Update version links in changelog
-pub fn update_version_links(
+pub fn update_version_links(changelog: &str, version: &str, compare_url: &str) -> String {
-    changelog: &str,
-    version: &str,
-    compare_url: &str,
-) -> String {
     // Add version link at the end of changelog
     format!("{}\n[{}]: {}\n", changelog, version, compare_url)
 }
@@ -429,10 +427,12 @@ pub fn parse_versions(changelog: &str) -> Vec<(String, String)> {
     for line in changelog.lines() {
         if line.starts_with("## [")
             && let Some(start) = line.find('[')
-                && let Some(end) = line.find(']') {
+            && let Some(end) = line.find(']')
+        {
             let version = &line[start + 1..end];
             if version != "Unreleased"
-                        && let Some(date_start) = line.find(" - ") {
+                && let Some(date_start) = line.find(" - ")
+            {
                 let date = &line[date_start + 3..].trim();
                 versions.push((version.to_string(), date.to_string()));
             }

src/git/commit.rs

@@ -1,5 +1,5 @@
 use super::GitRepo;
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use chrono::Local;
 
 /// Commit builder for creating commits
@@ -119,10 +119,14 @@ impl CommitBuilder {
             return Ok(msg.clone());
         }
 
-        let commit_type = self.commit_type.as_ref()
+        let commit_type = self
+            .commit_type
+            .as_ref()
             .ok_or_else(|| anyhow::anyhow!("Commit type is required"))?;
 
-        let description = self.description.as_ref()
+        let description = self
+            .description
+            .as_ref()
             .ok_or_else(|| anyhow::anyhow!("Description is required"))?;
 
         let message = match self.format {
@@ -194,7 +198,8 @@ impl CommitBuilder {
                     "GPG signing failed. Please check:\n\
                      1. GPG signing key is configured (git config --get user.signingkey)\n\
                      2. GPG agent is running\n\
-                     3. You can sign commits manually (try: git commit --amend -S)".to_string()
+                     3. You can sign commits manually (try: git commit --amend -S)"
+                        .to_string()
                 } else {
                     stdout.to_string()
                 }
@@ -241,12 +246,19 @@ pub fn suggest_commit_type(diff: &str) -> Vec<&'static str> {
     }
 
     // Check for configuration files
-    if diff.contains("config") || diff.contains(".json") || diff.contains(".yaml") || diff.contains(".toml") {
+    if diff.contains("config")
+        || diff.contains(".json")
+        || diff.contains(".yaml")
+        || diff.contains(".toml")
+    {
         suggestions.push("chore");
     }
 
     // Check for dependencies
-    if diff.contains("Cargo.toml") || diff.contains("package.json") || diff.contains("requirements.txt") {
+    if diff.contains("Cargo.toml")
+        || diff.contains("package.json")
+        || diff.contains("requirements.txt")
+    {
         suggestions.push("build");
     }
 
@@ -303,11 +315,12 @@ pub fn parse_commit_message(message: &str) -> ParsedCommit {
                 continue;
             }
 
-            if line.starts_with("BREAKING CHANGE:") || 
+            if line.starts_with("BREAKING CHANGE:")
-               line.starts_with("Closes") || 
+                || line.starts_with("Closes")
-               line.starts_with("Fixes") ||
+                || line.starts_with("Fixes")
-               line.starts_with("Refs") ||
+                || line.starts_with("Refs")
-               line.starts_with("Co-authored-by:") {
+                || line.starts_with("Co-authored-by:")
+            {
                 in_footer = true;
             }
 
@@ -322,8 +335,16 @@ pub fn parse_commit_message(message: &str) -> ParsedCommit {
             commit_type,
             scope,
             description: Some(description.to_string()),
-            body: if body_lines.is_empty() { None } else { Some(body_lines.join("\n")) },
+            body: if body_lines.is_empty() {
-            footer: if footer_lines.is_empty() { None } else { Some(footer_lines.join("\n")) },
+                None
+            } else {
+                Some(body_lines.join("\n"))
+            },
+            footer: if footer_lines.is_empty() {
+                None
+            } else {
+                Some(footer_lines.join("\n"))
+            },
             breaking,
         };
     }

src/git/mod.rs

@@ -1,13 +1,12 @@
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
-use git2::{Repository, Signature, StatusOptions, Config, Oid, ObjectType};
+use git2::{Config, ObjectType, Oid, Repository, Signature, StatusOptions};
-use std::path::{Path, PathBuf, Component};
 use std::collections::HashMap;
+use std::path::{Component, Path, PathBuf};
 
 pub mod changelog;
 pub mod commit;
 pub mod tag;
 
-
 fn normalize_path_for_git2(path: &Path) -> PathBuf {
     let mut normalized = path.to_path_buf();
 
@@ -15,11 +14,13 @@ fn normalize_path_for_git2(path: &Path) -> PathBuf {
     {
         let path_str = path.to_string_lossy();
         if path_str.starts_with(r"\\?\")
-            && let Some(stripped) = path_str.strip_prefix(r"\\?\") {
+            && let Some(stripped) = path_str.strip_prefix(r"\\?\")
+        {
             normalized = PathBuf::from(stripped);
         }
         if path_str.starts_with(r"\\?\UNC\")
-            && let Some(stripped) = path_str.strip_prefix(r"\\?\UNC\") {
+            && let Some(stripped) = path_str.strip_prefix(r"\\?\UNC\")
+        {
             normalized = PathBuf::from(format!(r"\\{}", stripped));
         }
     }
@@ -34,8 +35,7 @@ fn get_absolute_path<P: AsRef<Path>>(path: P) -> Result<PathBuf> {
         return Ok(normalize_path_for_git2(path));
     }
 
-    let current_dir = std::env::current_dir()
+    let current_dir = std::env::current_dir().with_context(|| "Failed to get current directory")?;
-        .with_context(|| "Failed to get current directory")?;
 
     let absolute = current_dir.join(path);
     Ok(normalize_path_for_git2(&absolute))
@@ -176,10 +176,8 @@ impl GitRepo {
         let absolute_path = get_absolute_path(path)?;
         let resolved_path = resolve_path_without_canonicalize(&absolute_path);
 
-        let repo = try_open_repo_with_git2(&resolved_path)
+        let repo = try_open_repo_with_git2(&resolved_path).or_else(|git2_err| {
-            .or_else(|git2_err| {
+            try_open_repo_with_git_cli(&resolved_path).map_err(|cli_err| {
-                try_open_repo_with_git_cli(&resolved_path)
-                    .map_err(|cli_err| {
                 let diagnosis = diagnose_repo_issue(&resolved_path);
                 anyhow::anyhow!(
                     "Failed to open git repository:\n\
@@ -195,12 +193,15 @@ impl GitRepo {
                             2. Run: git status (to verify git works)\n\
                             3. Run: git config --global --add safe.directory \"*\"\n\
                             4. Check file permissions",
-                            git2_err, cli_err, diagnosis
+                    git2_err,
+                    cli_err,
+                    diagnosis
                 )
             })
         })?;
 
-        let repo_path = repo.workdir()
+        let repo_path = repo
+            .workdir()
             .map(|p| p.to_path_buf())
             .unwrap_or_else(|| resolved_path.clone());
 
@@ -246,7 +247,11 @@ impl GitRepo {
     pub fn get_user_name(&self) -> Result<String> {
         self.get_config("user.name")?
             .or_else(|| std::env::var("GIT_AUTHOR_NAME").ok())
-            .ok_or_else(|| anyhow::anyhow!("User name not configured. Set it with: git config user.name \"Your Name\""))
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "User name not configured. Set it with: git config user.name \"Your Name\""
+                )
+            })
     }
 
     /// Get the configured user email
@@ -258,7 +263,8 @@ impl GitRepo {
 
     /// Get the configured GPG signing key
     pub fn get_signing_key(&self) -> Result<Option<String>> {
-        Ok(self.get_config("user.signingkey")?
+        Ok(self
+            .get_config("user.signingkey")?
             .or_else(|| std::env::var("GIT_SIGNING_KEY").ok()))
     }
 
@@ -286,11 +292,7 @@ impl GitRepo {
             return Ok(program);
         }
 
-        let default_gpg = if cfg!(windows) {
+        let default_gpg = if cfg!(windows) { "gpg.exe" } else { "gpg" };
-            "gpg.exe"
-        } else {
-            "gpg"
-        };
 
         Ok(default_gpg.to_string())
     }
@@ -299,10 +301,13 @@ impl GitRepo {
     pub fn create_signature(&self) -> Result<Signature<'_>> {
         let name = self.get_user_name()?;
         let email = self.get_user_email()?;
-        let time = git2::Time::new(std::time::SystemTime::now()
+        let time = git2::Time::new(
+            std::time::SystemTime::now()
                 .duration_since(std::time::UNIX_EPOCH)
                 .unwrap()
-            .as_secs() as i64, 0);
+                .as_secs() as i64,
+            0,
+        );
         Signature::new(&name, &email, &time).map_err(Into::into)
     }
 
@@ -382,9 +387,7 @@ impl GitRepo {
         });
 
         // Combine sorted diffs
-        let sorted_diff: String = file_diffs.into_iter()
+        let sorted_diff: String = file_diffs.into_iter().map(|(_, diff)| diff).collect();
-            .map(|(_, diff)| diff)
-            .collect();
 
         Ok(sorted_diff)
     }
@@ -412,20 +415,31 @@ fn extract_file_from_diff_line(line: &str) -> String {
 fn file_importance_score(filename: &str) -> i32 {
     // Priority list for important file types
     let important_extensions = [
-        ".rs", ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".java", ".cpp", ".c", ".rust",
+        ".rs", ".py", ".js", ".ts", ".tsx", ".jsx", ".go", ".java", ".cpp", ".c", ".rust", ".vue",
-        ".vue", ".svelte", ".html", ".css", ".scss", ".sass", ".less",
+        ".svelte", ".html", ".css", ".scss", ".sass", ".less",
     ];
 
     // Config files that are important but less than source code
     let config_files = [
-        "Cargo.toml", "package.json", "go.mod", "go.sum", "pom.xml",
+        "Cargo.toml",
-        "Makefile", "CMakeLists.txt", "build.gradle", "gradle.properties",
+        "package.json",
+        "go.mod",
+        "go.sum",
+        "pom.xml",
+        "Makefile",
+        "CMakeLists.txt",
+        "build.gradle",
+        "gradle.properties",
     ];
 
     // Lock files - lowest priority
     let lock_files = [
-        "Cargo.lock", "package-lock.json", "yarn.lock", "pnpm-lock.yaml",
+        "Cargo.lock",
-        "Gemfile.lock", "composer.lock",
+        "package-lock.json",
+        "yarn.lock",
+        "pnpm-lock.yaml",
+        "Gemfile.lock",
+        "composer.lock",
     ];
 
     // Check lock files first (lowest priority)
@@ -498,16 +512,20 @@ impl GitRepo {
 
     /// Get list of staged files
     pub fn get_staged_files(&self) -> Result<Vec<String>> {
-        let statuses = self.repo.statuses(Some(
+        let statuses = self
-            StatusOptions::new()
+            .repo
-                .include_untracked(false),
+            .statuses(Some(StatusOptions::new().include_untracked(false)))?;
-        ))?;
 
         let mut files = vec![];
         for entry in statuses.iter() {
             let status = entry.status();
-            if (status.is_index_new() || status.is_index_modified() || status.is_index_deleted() || status.is_index_renamed() || status.is_index_typechange())
+            if (status.is_index_new()
-                && let Some(path) = entry.path() {
+                || status.is_index_modified()
+                || status.is_index_deleted()
+                || status.is_index_renamed()
+                || status.is_index_typechange())
+                && let Some(path) = entry.path()
+            {
                 files.push(path.to_string());
             }
         }
@@ -635,7 +653,8 @@ impl GitRepo {
                     "GPG signing failed. Please check:\n\
                      1. GPG signing key is configured (git config --get user.signingkey)\n\
                      2. GPG agent is running\n\
-                     3. You can sign commits manually (try: git commit -S -m 'test')".to_string()
+                     3. You can sign commits manually (try: git commit -S -m 'test')"
+                        .to_string()
                 } else {
                     stdout.to_string()
                 }
@@ -655,7 +674,8 @@ impl GitRepo {
         let head = self.repo.head()?;
 
         if head.is_branch() {
-            let name = head.shorthand()
+            let name = head
+                .shorthand()
                 .ok_or_else(|| anyhow::anyhow!("Invalid branch name"))?;
             Ok(name.to_string())
         } else {
@@ -666,7 +686,8 @@ impl GitRepo {
     /// Get current commit hash (short)
     pub fn current_commit_short(&self) -> Result<String> {
         let head = self.repo.head()?;
-        let oid = head.target()
+        let oid = head
+            .target()
             .ok_or_else(|| anyhow::anyhow!("No target for HEAD"))?;
         Ok(oid.to_string()[..8].to_string())
     }
@@ -674,7 +695,8 @@ impl GitRepo {
     /// Get current commit hash (full)
     pub fn current_commit(&self) -> Result<String> {
         let head = self.repo.head()?;
-        let oid = head.target()
+        let oid = head
+            .target()
             .ok_or_else(|| anyhow::anyhow!("No target for HEAD"))?;
         Ok(oid.to_string())
     }
@@ -773,13 +795,7 @@ impl GitRepo {
             if sign {
                 self.create_signed_tag_with_git2(name, msg, &sig, target.id())?;
             } else {
-                self.repo.tag(
+                self.repo.tag(name, target.as_object(), &sig, msg, false)?;
-                    name,
-                    target.as_object(),
-                    &sig,
-                    msg,
-                    false,
-                )?;
             }
         } else {
             self.repo.tag(
@@ -795,7 +811,13 @@ impl GitRepo {
     }
 
     /// Create signed tag using git CLI
-    fn create_signed_tag_with_git2(&self, name: &str, message: &str, _signature: &Signature, _target_id: Oid) -> Result<()> {
+    fn create_signed_tag_with_git2(
+        &self,
+        name: &str,
+        message: &str,
+        _signature: &Signature,
+        _target_id: Oid,
+    ) -> Result<()> {
         let output = std::process::Command::new("git")
             .args(["tag", "-s", name, "-m", message])
             .current_dir(&self.path)
@@ -810,7 +832,12 @@ impl GitRepo {
     }
 
     /// Create GPG signature for arbitrary content
-    fn create_gpg_signature_for_content(&self, _content: &str, _gpg_program: &str, _signing_key: &str) -> Result<String> {
+    fn create_gpg_signature_for_content(
+        &self,
+        _content: &str,
+        _gpg_program: &str,
+        _signing_key: &str,
+    ) -> Result<String> {
         Ok(String::new())
     }
 
@@ -838,7 +865,8 @@ impl GitRepo {
     /// Get remote URL
     pub fn get_remote_url(&self, remote: &str) -> Result<String> {
         let remote_obj = self.repo.find_remote(remote)?;
-        let url = remote_obj.url()
+        let url = remote_obj
+            .url()
             .ok_or_else(|| anyhow::anyhow!("Remote has no URL"))?;
         Ok(url.to_string())
     }
@@ -889,9 +917,10 @@ impl GitRepo {
                 }
 
                 // Conflicted files (both columns are U or DD, AA, etc.)
-                if (index_status == 'U' || worktree_status == 'U') ||
+                if (index_status == 'U' || worktree_status == 'U')
-                   (index_status == 'A' && worktree_status == 'A') ||
+                    || (index_status == 'A' && worktree_status == 'A')
-                   (index_status == 'D' && worktree_status == 'D') {
+                    || (index_status == 'D' && worktree_status == 'D')
+                {
                     conflicted += 1;
                 }
             }
@@ -1014,11 +1043,13 @@ pub fn find_repo<P: AsRef<Path>>(start_path: P) -> Result<GitRepo> {
         .args(["rev-parse", "--show-toplevel"])
         .current_dir(&resolved_start)
         .output()
-        && output.status.success() {
+        && output.status.success()
+    {
         let stdout = String::from_utf8_lossy(&output.stdout);
         let git_root = stdout.trim();
         if !git_root.is_empty()
-                && let Ok(repo) = GitRepo::open(git_root) {
+            && let Ok(repo) = GitRepo::open(git_root)
+        {
             return Ok(repo);
         }
     }
@@ -1238,7 +1269,10 @@ impl MergedUserConfig {
     }
 
     pub fn has_local_overrides(&self) -> bool {
-        self.name.is_local() || self.email.is_local() || self.signing_key.is_local() || self.ssh_command.is_local()
+        self.name.is_local()
+            || self.email.is_local()
+            || self.signing_key.is_local()
+            || self.ssh_command.is_local()
     }
 }
 
@@ -1265,23 +1299,38 @@ impl UserConfig {
             diffs.push(ConfigDiff {
                 key: "user.name".to_string(),
                 left: self.name.clone().unwrap_or_else(|| "<not set>".to_string()),
-                right: other.name.clone().unwrap_or_else(|| "<not set>".to_string()),
+                right: other
+                    .name
+                    .clone()
+                    .unwrap_or_else(|| "<not set>".to_string()),
             });
         }
 
         if self.email != other.email {
             diffs.push(ConfigDiff {
                 key: "user.email".to_string(),
-                left: self.email.clone().unwrap_or_else(|| "<not set>".to_string()),
+                left: self
-                right: other.email.clone().unwrap_or_else(|| "<not set>".to_string()),
+                    .email
+                    .clone()
+                    .unwrap_or_else(|| "<not set>".to_string()),
+                right: other
+                    .email
+                    .clone()
+                    .unwrap_or_else(|| "<not set>".to_string()),
             });
         }
 
         if self.signing_key != other.signing_key {
             diffs.push(ConfigDiff {
                 key: "user.signingkey".to_string(),
-                left: self.signing_key.clone().unwrap_or_else(|| "<not set>".to_string()),
+                left: self
-                right: other.signing_key.clone().unwrap_or_else(|| "<not set>".to_string()),
+                    .signing_key
+                    .clone()
+                    .unwrap_or_else(|| "<not set>".to_string()),
+                right: other
+                    .signing_key
+                    .clone()
+                    .unwrap_or_else(|| "<not set>".to_string()),
             });
         }
 

src/git/tag.rs

@@ -1,5 +1,5 @@
 use super::GitRepo;
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use semver::Version;
 
 /// Tag builder for creating tags
@@ -69,9 +69,7 @@ impl TagBuilder {
 
     /// Build tag message
     pub fn build_message(&self) -> Result<String> {
-        let message = self.message.as_ref()
+        let message = self.message.as_ref().cloned().unwrap_or_else(|| {
-            .cloned()
-            .unwrap_or_else(|| {
             let name = self.name.as_deref().unwrap_or("unknown");
             format!("Release {}", name)
         });
@@ -81,7 +79,9 @@ impl TagBuilder {
 
     /// Execute tag creation
     pub fn execute(&self, repo: &GitRepo) -> Result<()> {
-        let name = self.name.as_ref()
+        let name = self
+            .name
+            .as_ref()
             .ok_or_else(|| anyhow::anyhow!("Tag name is required"))?;
 
         if !self.force {
@@ -136,7 +136,10 @@ impl VersionBump {
             "minor" => Ok(Self::Minor),
             "patch" => Ok(Self::Patch),
             "prerelease" | "pre" => Ok(Self::Prerelease),
-            _ => bail!("Invalid version bump: {}. Use: major, minor, patch, prerelease", s),
+            _ => bail!(
+                "Invalid version bump: {}. Use: major, minor, patch, prerelease",
+                s
+            ),
         }
     }
 
@@ -187,7 +190,10 @@ pub fn suggest_version_bump(commits: &[super::CommitInfo]) -> VersionBump {
     for commit in commits {
         let msg = commit.message.to_lowercase();
 
-        if msg.contains("breaking change") || msg.contains("breaking-change") || msg.contains("breaking_change") {
+        if msg.contains("breaking change")
+            || msg.contains("breaking-change")
+            || msg.contains("breaking_change")
+        {
             has_breaking = true;
         }
 

src/i18n/messages.rs

@@ -267,7 +267,9 @@ impl Messages {
             Language::Chinese => "没有可提交的更改。工作树是干净的。",
             Language::Japanese => "コミットする変更がありません。作業ツリーはクリーンです。",
             Language::Korean => "커밋할 변경 사항이 없습니다. 작업 트리가 깨끗합니다.",
-            Language::Spanish => "No hay cambios para hacer commit. El árbol de trabajo está limpio.",
+            Language::Spanish => {
+                "No hay cambios para hacer commit. El árbol de trabajo está limpio."
+            }
             Language::French => "Aucun changement à commiter. L'arbre de travail est propre.",
             Language::German => "Keine Änderungen zum Committen. Arbeitsbaum ist sauber.",
         }
@@ -289,11 +291,19 @@ impl Messages {
         match self.language {
             Language::English => "No files staged. Auto-staging all changes...",
             Language::Chinese => "没有暂存文件。自动暂存所有更改...",
-            Language::Japanese => "ステージされたファイルがありません。すべての変更を自動ステージ中...",
+            Language::Japanese => {
+                "ステージされたファイルがありません。すべての変更を自動ステージ中..."
+            }
             Language::Korean => "스테이징된 파일이 없습니다. 모든 변경 사항을 자동 스테이징 중...",
-            Language::Spanish => "No hay archivos preparados. Preparando automáticamente todos los cambios...",
+            Language::Spanish => {
-            Language::French => "Aucun fichier indexé. Indexation automatique de tous les changements...",
+                "No hay archivos preparados. Preparando automáticamente todos los cambios..."
-            Language::German => "Keine Dateien bereitgestellt. Alle Änderungen werden automatisch bereitgestellt...",
+            }
+            Language::French => {
+                "Aucun fichier indexé. Indexation automatique de tous les changements..."
+            }
+            Language::German => {
+                "Keine Dateien bereitgestellt. Alle Änderungen werden automatisch bereitgestellt..."
+            }
         }
     }
 
@@ -359,12 +369,23 @@ impl Messages {
 
     pub fn ai_generating_tag(&self, count: usize) -> String {
         match self.language {
-            Language::English => format!("🤖 AI is generating tag message from {} commits...", count),
+            Language::English => {
+                format!("🤖 AI is generating tag message from {} commits...", count)
+            }
             Language::Chinese => format!("🤖 AI 正在从 {} 个提交生成标签消息...", count),
-            Language::Japanese => format!("🤖 AIが{}個のコミットからタグメッセージを生成しています...", count),
+            Language::Japanese => format!(
+                "🤖 AIが{}個のコミットからタグメッセージを生成しています...",
+                count
+            ),
             Language::Korean => format!("🤖 AI가 {}개의 커밋에서 태그 메시지를 생성 중...", count),
-            Language::Spanish => format!("🤖 La IA está generando mensaje de etiqueta desde {} commits...", count),
+            Language::Spanish => format!(
-            Language::French => format!("🤖 L'IA génère le message d'étiquette à partir de {} commits...", count),
+                "🤖 La IA está generando mensaje de etiqueta desde {} commits...",
+                count
+            ),
+            Language::French => format!(
+                "🤖 L'IA génère le message d'étiquette à partir de {} commits...",
+                count
+            ),
             Language::German => format!("🤖 KI generiert Tag-Nachricht aus {} Commits...", count),
         }
     }

src/i18n/translator.rs

@@ -7,7 +7,11 @@ pub struct Translator {
 }
 
 impl Translator {
-    pub fn new(language: Language, keep_types_english: bool, keep_changelog_types_english: bool) -> Self {
+    pub fn new(
+        language: Language,
+        keep_types_english: bool,
+        keep_changelog_types_english: bool,
+    ) -> Self {
         Self {
             language,
             keep_types_english,
@@ -227,7 +231,11 @@ pub fn translate_commit_type(commit_type: &str, language: Language, keep_english
     translator.translate_commit_type(commit_type)
 }
 
-pub fn translate_changelog_category(category: &str, language: Language, keep_english: bool) -> String {
+pub fn translate_changelog_category(
+    category: &str,
+    language: Language,
+    keep_english: bool,
+) -> String {
     let translator = Translator::new(language, true, keep_english);
     translator.translate_changelog_category(category)
 }

src/llm/anthropic.rs

@@ -1,6 +1,6 @@
 use super::thinking::ThinkingStateManager;
-use super::{create_http_client, LlmProvider};
+use super::{LlmProvider, create_http_client};
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
@@ -618,10 +618,7 @@ mod tests {
         let json = r#"{"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":""}}"#;
         let event: SseEvent = serde_json::from_str(json).unwrap();
         assert_eq!(event.event_type, "content_block_start");
-        assert_eq!(
+        assert_eq!(event.content_block.unwrap().content_type, "thinking");
-            event.content_block.unwrap().content_type,
-            "thinking"
-        );
     }
 
     #[test]

src/llm/deepseek.rs

@@ -1,6 +1,6 @@
 use super::thinking::ThinkingStateManager;
-use super::{create_http_client, LlmProvider};
+use super::{LlmProvider, create_http_client};
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
@@ -459,7 +459,8 @@ impl DeepSeekClient {
                             for choice in &chunk.choices {
                                 // 处理 reasoning_content
                                 if let Some(ref reasoning) = choice.delta.reasoning_content
-                                    && !reasoning.is_empty() {
+                                    && !reasoning.is_empty()
+                                {
                                     if !has_reasoning {
                                         has_reasoning = true;
                                         if let Some(state) = thinking_state {
@@ -472,10 +473,13 @@ impl DeepSeekClient {
 
                                 // 处理 content
                                 if let Some(ref content) = choice.delta.content
-                                    && !content.is_empty() {
+                                    && !content.is_empty()
+                                {
                                     // reasoning 结束，content 开始出现时移除 thinking 标识
-                                        if has_reasoning && !has_content
+                                    if has_reasoning
-                                            && let Some(state) = thinking_state {
+                                        && !has_content
+                                        && let Some(state) = thinking_state
+                                    {
                                         state.end_thinking();
                                     }
                                     has_content = true;
@@ -484,7 +488,8 @@ impl DeepSeekClient {
 
                                 // 检查 finish_reason
                                 if let Some(ref reason) = choice.finish_reason
-                                    && reason == "stop" {
+                                    && reason == "stop"
+                                {
                                     stream_ended = true;
                                 }
                             }
@@ -612,9 +617,6 @@ mod tests {
         let json = r#"{"content":null,"reasoning_content":"Let me think..."}"#;
         let delta: StreamDelta = serde_json::from_str(json).unwrap();
         assert!(delta.content.is_none());
-        assert_eq!(
+        assert_eq!(delta.reasoning_content, Some("Let me think...".to_string()));
-            delta.reasoning_content,
-            Some("Let me think...".to_string())
-        );
     }
 }

src/llm/kimi.rs

@@ -1,6 +1,6 @@
 use super::thinking::ThinkingStateManager;
-use super::{create_http_client, LlmProvider};
+use super::{LlmProvider, create_http_client};
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
@@ -431,7 +431,8 @@ impl KimiClient {
                         Ok(chunk) => {
                             for choice in &chunk.choices {
                                 if let Some(ref reasoning) = choice.delta.reasoning_content
-                                    && !reasoning.is_empty() {
+                                    && !reasoning.is_empty()
+                                {
                                     if !has_reasoning {
                                         has_reasoning = true;
                                         if let Some(state) = thinking_state {
@@ -442,9 +443,12 @@ impl KimiClient {
                                 }
 
                                 if let Some(ref content) = choice.delta.content
-                                    && !content.is_empty() {
+                                    && !content.is_empty()
-                                        if has_reasoning && !has_content
+                                {
-                                            && let Some(state) = thinking_state {
+                                    if has_reasoning
+                                        && !has_content
+                                        && let Some(state) = thinking_state
+                                    {
                                         state.end_thinking();
                                     }
                                     has_content = true;
@@ -452,7 +456,8 @@ impl KimiClient {
                                 }
 
                                 if let Some(ref reason) = choice.finish_reason
-                                    && reason == "stop" {
+                                    && reason == "stop"
+                                {
                                     stream_ended = true;
                                 }
                             }

src/llm/mod.rs

@@ -1,21 +1,21 @@
-use anyhow::{bail, Context, Result};
+use crate::config::Language;
+use anyhow::{Context, Result, bail};
 use async_trait::async_trait;
 use std::time::Duration;
-use crate::config::Language;
 
+pub mod anthropic;
+pub mod deepseek;
+pub mod kimi;
 pub mod ollama;
 pub mod openai;
-pub mod anthropic;
-pub mod kimi;
-pub mod deepseek;
 pub mod openrouter;
 pub mod thinking;
 
+pub use anthropic::AnthropicClient;
+pub use deepseek::DeepSeekClient;
+pub use kimi::KimiClient;
 pub use ollama::OllamaClient;
 pub use openai::OpenAiClient;
-pub use anthropic::AnthropicClient;
-pub use kimi::KimiClient;
-pub use deepseek::DeepSeekClient;
 pub use openrouter::OpenRouterClient;
 
 /// LLM provider trait
@@ -84,13 +84,14 @@ impl LlmClient {
         let api_key = manager.get_api_key();
 
         let provider: Box<dyn LlmProvider> = match provider {
-            "ollama" => {
+            "ollama" => Box::new(
-                Box::new(OllamaClient::new(&base_url, model)
+                OllamaClient::new(&base_url, model)
                     .with_max_tokens(client_config.max_tokens)
-                    .with_temperature(client_config.temperature))
+                    .with_temperature(client_config.temperature),
-            }
+            ),
             "openai" => {
-                let key = api_key.as_ref()
+                let key = api_key
+                    .as_ref()
                     .ok_or_else(|| anyhow::anyhow!("OpenAI API key not configured"))?;
                 let thinking_state = if thinking_enabled {
                     Some(thinking::create_console_thinking_state())
@@ -108,7 +109,8 @@ impl LlmClient {
                 Box::new(client)
             }
             "anthropic" => {
-                let key = api_key.as_ref()
+                let key = api_key
+                    .as_ref()
                     .ok_or_else(|| anyhow::anyhow!("Anthropic API key not configured"))?;
                 let thinking_state = if thinking_enabled {
                     Some(thinking::create_console_thinking_state())
@@ -128,7 +130,8 @@ impl LlmClient {
                 Box::new(client)
             }
             "kimi" => {
-                let key = api_key.as_ref()
+                let key = api_key
+                    .as_ref()
                     .ok_or_else(|| anyhow::anyhow!("Kimi API key not configured"))?;
                 let thinking_state = if thinking_enabled {
                     Some(thinking::create_console_thinking_state())
@@ -146,7 +149,8 @@ impl LlmClient {
                 Box::new(client)
             }
             "deepseek" => {
-                let key = api_key.as_ref()
+                let key = api_key
+                    .as_ref()
                     .ok_or_else(|| anyhow::anyhow!("DeepSeek API key not configured"))?;
                 let thinking_state = if thinking_enabled {
                     Some(thinking::create_console_thinking_state())
@@ -164,12 +168,15 @@ impl LlmClient {
                 Box::new(client)
             }
             "openrouter" => {
-                let key = api_key.as_ref()
+                let key = api_key
+                    .as_ref()
                     .ok_or_else(|| anyhow::anyhow!("OpenRouter API key not configured"))?;
-                Box::new(OpenRouterClient::with_base_url(key, model, &base_url)?
+                Box::new(
+                    OpenRouterClient::with_base_url(key, model, &base_url)?
                         .with_max_tokens(client_config.max_tokens)
                         .with_temperature(client_config.temperature)
-                    .with_timeout(client_config.timeout)?)
+                        .with_timeout(client_config.timeout)?,
+                )
             }
             _ => bail!("Unknown LLM provider: {}", provider),
         };
@@ -209,7 +216,10 @@ impl LlmClient {
         };
 
         let prompt = format!("{}{}", diff, language_instruction);
-        let response = self.provider.generate_with_system(system_prompt, &prompt).await?;
+        let response = self
+            .provider
+            .generate_with_system(system_prompt, &prompt)
+            .await?;
 
         self.parse_commit_response(&response, format)
     }
@@ -235,9 +245,14 @@ impl LlmClient {
             Language::English => "",
         };
 
-        let prompt = format!("Version: {}\n\nCommits:\n{}{}", version, commits_text, language_instruction);
+        let prompt = format!(
+            "Version: {}\n\nCommits:\n{}{}",
+            version, commits_text, language_instruction
+        );
 
-        self.provider.generate_with_system(system_prompt, &prompt).await
+        self.provider
+            .generate_with_system(system_prompt, &prompt)
+            .await
     }
 
     /// Generate changelog entry
@@ -266,9 +281,14 @@ impl LlmClient {
             Language::English => "",
         };
 
-        let prompt = format!("Version: {}\n\nCommits:\n{}{}", version, commits_text, language_instruction);
+        let prompt = format!(
+            "Version: {}\n\nCommits:\n{}{}",
+            version, commits_text, language_instruction
+        );
 
-        self.provider.generate_with_system(system_prompt, &prompt).await
+        self.provider
+            .generate_with_system(system_prompt, &prompt)
+            .await
     }
 
     /// Check if provider is available
@@ -277,8 +297,16 @@ impl LlmClient {
     }
 
     /// Parse commit response from LLM
-    fn parse_commit_response(&self, response: &str, format: crate::config::CommitFormat) -> Result<GeneratedCommit> {
+    fn parse_commit_response(
-        let lines: Vec<&str> = response.lines()
+        &self,
+        response: &str,
+        format: crate::config::CommitFormat,
+    ) -> Result<GeneratedCommit> {
+        // Clean markdown code fences from the response
+        let cleaned = Self::strip_code_fences(response);
+
+        let lines: Vec<&str> = cleaned
+            .lines()
             .map(|l| l.trim())
             .filter(|l| !l.is_empty())
             .collect();
@@ -295,28 +323,89 @@ impl LlmClient {
             );
         }
 
-        let first_line = lines[0];
+        // Find the line most likely to be the commit subject
+        let first_line = Self::find_commit_subject_line(&lines, format);
 
         // Parse based on format
         match format {
             crate::config::CommitFormat::Conventional => {
-                self.parse_conventional_commit(first_line, lines)
+                self.parse_conventional_commit(first_line, &lines, response)
             }
             crate::config::CommitFormat::Commitlint => {
-                self.parse_commitlint_commit(first_line, lines)
+                self.parse_commitlint_commit(first_line, &lines, response)
             }
         }
     }
 
+    /// Remove surrounding markdown code fences (```) from LLM output
+    fn strip_code_fences(response: &str) -> String {
+        let mut lines: Vec<&str> = response.lines().collect();
+
+        // Strip leading fence lines (``` or ```lang)
+        while lines.first().map_or(false, |l| l.trim().starts_with("```")) {
+            lines.remove(0);
+        }
+
+        // Strip trailing fence lines
+        while lines.last().map_or(false, |l| l.trim() == "```") {
+            lines.pop();
+        }
+
+        lines.join("\n")
+    }
+
+    /// Find the line that is most likely the commit subject among extracted lines
+    fn find_commit_subject_line<'a>(
+        lines: &[&'a str],
+        format: crate::config::CommitFormat,
+    ) -> &'a str {
+        let valid_types = crate::utils::validators::get_commit_types(matches!(
+            format,
+            crate::config::CommitFormat::Commitlint
+        ));
+
+        // First pass: line starting with a known type that also has proper syntax
+        // (e.g. "type:", "type(scope):", "type!:")
+        for &line in lines {
+            let trimmed = line.trim();
+            for &t in valid_types {
+                if let Some(rest) = trimmed.strip_prefix(t) {
+                    if rest.starts_with(':') || rest.starts_with('(') || rest.starts_with("!:") {
+                        return trimmed;
+                    }
+                }
+            }
+        }
+
+        // Second pass: any line containing a colon (generic "prefix: description")
+        for &line in lines {
+            if line.contains(':') {
+                return line.trim();
+            }
+        }
+
+        // Fallback: return the first line as-is
+        lines[0].trim()
+    }
+
     fn parse_conventional_commit(
         &self,
         first_line: &str,
-        lines: Vec<&str>,
+        lines: &[&str],
+        raw_response: &str,
     ) -> Result<GeneratedCommit> {
         // Parse: type(scope)!: description
         let parts: Vec<&str> = first_line.splitn(2, ':').collect();
         if parts.len() != 2 {
-            bail!("Invalid conventional commit format: missing colon");
+            let preview: String = raw_response.chars().take(300).collect();
+            bail!(
+                "Invalid conventional commit format: missing colon.\n\
+                 Parsed subject line: '{}'\n\
+                 Raw response preview: '{}'\n\
+                 Expected: <type>[optional scope]: <description>",
+                first_line,
+                preview
+            );
         }
 
         let type_part = parts[0];
@@ -339,7 +428,7 @@ impl LlmClient {
         };
 
         // Extract body and footer
-        let (body, footer) = self.extract_body_footer(&lines);
+        let (body, footer) = self.extract_body_footer(lines);
 
         Ok(GeneratedCommit {
             commit_type,
@@ -354,12 +443,21 @@ impl LlmClient {
     fn parse_commitlint_commit(
         &self,
         first_line: &str,
-        lines: Vec<&str>,
+        lines: &[&str],
+        raw_response: &str,
     ) -> Result<GeneratedCommit> {
         // Similar parsing but with commitlint rules
         let parts: Vec<&str> = first_line.splitn(2, ':').collect();
         if parts.len() != 2 {
-            bail!("Invalid commit format: missing colon");
+            let preview: String = raw_response.chars().take(300).collect();
+            bail!(
+                "Invalid commit format: missing colon.\n\
+                 Parsed subject line: '{}'\n\
+                 Raw response preview: '{}'\n\
+                 Expected: <type>[optional scope]: <subject>",
+                first_line,
+                preview
+            );
         }
 
         let type_part = parts[0];
@@ -405,7 +503,13 @@ impl LlmClient {
         }
 
         // Look for footer markers
-        let footer_markers = ["BREAKING CHANGE:", "Closes", "Fixes", "Refs", "Co-authored-by:"];
+        let footer_markers = [
+            "BREAKING CHANGE:",
+            "Closes",
+            "Fixes",
+            "Refs",
+            "Co-authored-by:",
+        ];
 
         let mut body_lines = vec![];
         let mut footer_lines = vec![];
@@ -485,17 +589,34 @@ pub(crate) fn create_http_client(timeout: Duration) -> Result<reqwest::Client> {
 }
 
 /// Get commit system prompt based on format and language
-fn get_commit_system_prompt(format: crate::config::CommitFormat, language: Language) -> &'static str {
+fn get_commit_system_prompt(
+    format: crate::config::CommitFormat,
+    language: Language,
+) -> &'static str {
     match (format, language) {
-        (crate::config::CommitFormat::Conventional, Language::Chinese) => CONVENTIONAL_COMMIT_SYSTEM_PROMPT_ZH,
+        (crate::config::CommitFormat::Conventional, Language::Chinese) => {
-        (crate::config::CommitFormat::Conventional, Language::Japanese) => CONVENTIONAL_COMMIT_SYSTEM_PROMPT_JA,
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_ZH
-        (crate::config::CommitFormat::Conventional, Language::Korean) => CONVENTIONAL_COMMIT_SYSTEM_PROMPT_KO,
+        }
-        (crate::config::CommitFormat::Conventional, Language::Spanish) => CONVENTIONAL_COMMIT_SYSTEM_PROMPT_ES,
+        (crate::config::CommitFormat::Conventional, Language::Japanese) => {
-        (crate::config::CommitFormat::Conventional, Language::French) => CONVENTIONAL_COMMIT_SYSTEM_PROMPT_FR,
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_JA
-        (crate::config::CommitFormat::Conventional, Language::German) => CONVENTIONAL_COMMIT_SYSTEM_PROMPT_DE,
+        }
+        (crate::config::CommitFormat::Conventional, Language::Korean) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_KO
+        }
+        (crate::config::CommitFormat::Conventional, Language::Spanish) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_ES
+        }
+        (crate::config::CommitFormat::Conventional, Language::French) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_FR
+        }
+        (crate::config::CommitFormat::Conventional, Language::German) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_DE
+        }
         (crate::config::CommitFormat::Conventional, _) => CONVENTIONAL_COMMIT_SYSTEM_PROMPT,
         (crate::config::CommitFormat::Commitlint, Language::Chinese) => COMMITLINT_SYSTEM_PROMPT_ZH,
-        (crate::config::CommitFormat::Commitlint, Language::Japanese) => COMMITLINT_SYSTEM_PROMPT_JA,
+        (crate::config::CommitFormat::Commitlint, Language::Japanese) => {
+            COMMITLINT_SYSTEM_PROMPT_JA
+        }
         (crate::config::CommitFormat::Commitlint, Language::Korean) => COMMITLINT_SYSTEM_PROMPT_KO,
         (crate::config::CommitFormat::Commitlint, Language::Spanish) => COMMITLINT_SYSTEM_PROMPT_ES,
         (crate::config::CommitFormat::Commitlint, Language::French) => COMMITLINT_SYSTEM_PROMPT_FR,

src/llm/ollama.rs

@@ -1,4 +1,4 @@
-use super::{create_http_client, LlmProvider};
+use super::{LlmProvider, create_http_client};
 use anyhow::{Context, Result};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
@@ -50,8 +50,8 @@ struct ModelInfo {
 impl OllamaClient {
     /// Create new Ollama client
     pub fn new(base_url: &str, model: &str) -> Self {
-        let client = create_http_client(Duration::from_secs(120))
+        let client =
-            .expect("Failed to create HTTP client");
+            create_http_client(Duration::from_secs(120)).expect("Failed to create HTTP client");
 
         Self {
             base_url: base_url.trim_end_matches('/').to_string(),
@@ -65,8 +65,7 @@ impl OllamaClient {
 
     /// Set timeout
     pub fn with_timeout(mut self, timeout: Duration) -> Self {
-        self.client = create_http_client(timeout)
+        self.client = create_http_client(timeout).expect("Failed to create HTTP client");
-            .expect("Failed to create HTTP client");
         self
     }
 
@@ -89,7 +88,8 @@ impl OllamaClient {
     pub async fn list_models(&self) -> Result<Vec<String>> {
         let url = format!("{}/api/tags", self.base_url);
 
-        let response = self.client
+        let response = self
+            .client
             .get(&url)
             .send()
             .await
@@ -118,7 +118,8 @@ impl OllamaClient {
             "stream": false,
         });
 
-        let response = self.client
+        let response = self
+            .client
             .post(&url)
             .json(&request)
             .send()
@@ -169,7 +170,8 @@ impl LlmProvider for OllamaClient {
             },
         };
 
-        let response = self.client
+        let response = self
+            .client
             .post(&url)
             .json(&request)
             .send()

src/llm/openai.rs

@@ -1,6 +1,6 @@
 use super::thinking::ThinkingStateManager;
-use super::{create_http_client, LlmProvider};
+use super::{LlmProvider, create_http_client};
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
@@ -411,7 +411,8 @@ impl OpenAiClient {
                             if let Some(ref content) = choice.delta.content
                                 && !content.is_empty()
                             {
-                                if has_reasoning && !has_content
+                                if has_reasoning
+                                    && !has_content
                                     && let Some(state) = thinking_state
                                 {
                                     state.end_thinking();
@@ -465,12 +466,7 @@ pub struct AzureOpenAiClient {
 }
 
 impl AzureOpenAiClient {
-    pub fn new(
+    pub fn new(endpoint: &str, api_key: &str, deployment: &str, api_version: &str) -> Result<Self> {
-        endpoint: &str,
-        api_key: &str,
-        deployment: &str,
-        api_version: &str,
-    ) -> Result<Self> {
         let client = create_http_client(Duration::from_secs(60))?;
 
         Ok(Self {
@@ -642,10 +638,7 @@ mod tests {
         let json = r#"{"content":null,"reasoning_content":"Let me think..."}"#;
         let delta: StreamDelta = serde_json::from_str(json).unwrap();
         assert!(delta.content.is_none());
-        assert_eq!(
+        assert_eq!(delta.reasoning_content, Some("Let me think...".to_string()));
-            delta.reasoning_content,
-            Some("Let me think...".to_string())
-        );
     }
 
     #[test]

src/llm/openrouter.rs

@@ -1,5 +1,5 @@
-use super::{create_http_client, LlmProvider};
+use super::{LlmProvider, create_http_client};
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
@@ -110,7 +110,8 @@ impl OpenRouterClient {
     pub async fn list_models(&self) -> Result<Vec<String>> {
         let url = format!("{}/models", self.base_url);
 
-        let response = self.client
+        let response = self
+            .client
             .get(&url)
             .header("Authorization", format!("Bearer {}", self.api_key))
             .header("HTTP-Referer", "https://quicommit.dev")
@@ -162,12 +163,10 @@ impl OpenRouterClient {
 #[async_trait]
 impl LlmProvider for OpenRouterClient {
     async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![
+        let messages = vec![Message {
-            Message {
             role: "user".to_string(),
             content: prompt.to_string(),
-            },
+        }];
-        ];
 
         self.chat_completion(messages).await
     }
@@ -211,7 +210,8 @@ impl OpenRouterClient {
             stream: false,
         };
 
-        let response = self.client
+        let response = self
+            .client
             .post(&url)
             .header("Authorization", format!("Bearer {}", self.api_key))
             .header("Content-Type", "application/json")
@@ -229,7 +229,11 @@ impl OpenRouterClient {
 
             // Try to parse error
             if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!("OpenRouter API error: {} ({})", error.error.message, error.error.error_type);
+                bail!(
+                    "OpenRouter API error: {} ({})",
+                    error.error.message,
+                    error.error.error_type
+                );
             }
 
             bail!("OpenRouter API error: {} - {}", status, text);
@@ -240,7 +244,8 @@ impl OpenRouterClient {
             .await
             .context("Failed to parse OpenRouter response")?;
 
-        result.choices
+        result
+            .choices
             .into_iter()
             .next()
             .map(|c| c.message.content.trim().to_string())

src/llm/thinking.rs

@@ -1,5 +1,5 @@
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 /// 统一的思考状态管理器，用于管理模型思考状态的显示与隐藏
 pub struct ThinkingStateManager {
@@ -115,8 +115,7 @@ mod tests {
         let events: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
         let events_clone = events.clone();
 
-        let manager = ThinkingStateManager::new()
+        let manager = ThinkingStateManager::new().on_thinking_start(move || {
-            .on_thinking_start(move || {
             events_clone.lock().unwrap().push("start".to_string());
         });
 

src/main.rs

@@ -14,8 +14,8 @@ mod llm;
 mod utils;
 
 use commands::{
-    changelog::ChangelogCommand, commit::CommitCommand, config::ConfigCommand,
+    changelog::ChangelogCommand, commit::CommitCommand, config::ConfigCommand, init::InitCommand,
-    init::InitCommand, profile::ProfileCommand, tag::TagCommand,
+    profile::ProfileCommand, tag::TagCommand,
 };
 
 /// QuiCommit - AI-powered Git assistant

src/utils/crypto.rs

@@ -1,9 +1,9 @@
 use aes_gcm::{
-    aead::{Aead, KeyInit},
     Aes256Gcm, Nonce,
+    aead::{Aead, KeyInit},
 };
 use anyhow::{Context, Result};
-use base64::{engine::general_purpose::STANDARD as BASE64, Engine};
+use base64::{Engine, engine::general_purpose::STANDARD as BASE64};
 use rand::Rng;
 use std::fs;
 use std::path::Path;
@@ -20,8 +20,7 @@ pub fn encrypt(data: &[u8], password: &str) -> Result<String> {
     rand::thread_rng().fill(&mut nonce_bytes);
 
     let key = derive_key(password, &salt)?;
-    let cipher = Aes256Gcm::new_from_slice(&key)
+    let cipher = Aes256Gcm::new_from_slice(&key).context("Failed to create cipher")?;
-        .context("Failed to create cipher")?;
     let nonce = Nonce::from_slice(&nonce_bytes);
 
     let encrypted = cipher
@@ -39,7 +38,8 @@ pub fn encrypt(data: &[u8], password: &str) -> Result<String> {
 
 /// Decrypt data with password
 pub fn decrypt(encrypted_data: &str, password: &str) -> Result<Vec<u8>> {
-    let data = BASE64.decode(encrypted_data)
+    let data = BASE64
+        .decode(encrypted_data)
         .context("Invalid base64 encoding")?;
 
     if data.len() < SALT_LEN + NONCE_LEN {
@@ -51,8 +51,7 @@ pub fn decrypt(encrypted_data: &str, password: &str) -> Result<Vec<u8>> {
     let encrypted = &data[SALT_LEN + NONCE_LEN..];
 
     let key = derive_key(password, salt)?;
-    let cipher = Aes256Gcm::new_from_slice(&key)
+    let cipher = Aes256Gcm::new_from_slice(&key).context("Failed to create cipher")?;
-        .context("Failed to create cipher")?;
     let nonce = Nonce::from_slice(nonce_bytes);
 
     let decrypted = cipher
@@ -64,7 +63,7 @@ pub fn decrypt(encrypted_data: &str, password: &str) -> Result<Vec<u8>> {
 
 /// Derive key from password using simple method
 fn derive_key(password: &str, salt: &[u8]) -> Result<[u8; KEY_LEN]> {
-    use sha2::{Sha256, Digest};
+    use sha2::{Digest, Sha256};
 
     let mut hasher = Sha256::new();
     hasher.update(salt);

src/utils/editor.rs

@@ -9,14 +9,11 @@ pub fn edit_content(initial_content: &str) -> Result<String> {
 
 /// Edit file in user's default editor
 pub fn edit_file(path: &Path) -> Result<String> {
-    let content = fs::read_to_string(path)
+    let content = fs::read_to_string(path).unwrap_or_default();
-        .unwrap_or_default();
 
-    let edited = edit::edit(&content)
+    let edited = edit::edit(&content).context("Failed to open editor")?;
-        .context("Failed to open editor")?;
 
-    fs::write(path, &edited)
+    fs::write(path, &edited).with_context(|| format!("Failed to write file: {:?}", path))?;
-        .with_context(|| format!("Failed to write file: {:?}", path))?;
 
     Ok(edited)
 }
@@ -29,8 +26,7 @@ pub fn edit_temp(initial_content: &str, extension: &str) -> Result<String> {
         .context("Failed to create temp file")?;
 
     let path = temp_file.path();
-    fs::write(path, initial_content)
+    fs::write(path, initial_content).context("Failed to write temp file")?;
-        .context("Failed to write temp file")?;
 
     edit_file(path)
 }
@@ -65,7 +61,6 @@ pub fn get_editor() -> String {
 /// Check if editor is available
 pub fn check_editor() -> Result<()> {
     let editor = get_editor();
-    which::which(&editor)
+    which::which(&editor).with_context(|| format!("Editor '{}' not found in PATH", editor))?;
-        .with_context(|| format!("Editor '{}' not found in PATH", editor))?;
     Ok(())
 }

src/utils/keyring.rs

@@ -1,4 +1,4 @@
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use std::env;
 
 const SERVICE_NAME: &str = "quicommit";
@@ -78,7 +78,8 @@ impl KeyringManager {
         let entry = keyring::Entry::new(SERVICE_NAME, provider)
             .context("Failed to create keyring entry")?;
 
-        entry.set_password(api_key)
+        entry
+            .set_password(api_key)
             .context("Failed to store API key")?;
 
         Ok(())
@@ -86,7 +87,8 @@ impl KeyringManager {
 
     pub fn get_api_key(&self, provider: &str) -> Result<Option<String>> {
         if let Ok(key) = env::var(ENV_API_KEY)
-            && !key.is_empty() {
+            && !key.is_empty()
+        {
             return Ok(Some(key));
         }
 
@@ -112,7 +114,8 @@ impl KeyringManager {
         let entry = keyring::Entry::new(SERVICE_NAME, provider)
             .context("Failed to create keyring entry")?;
 
-        entry.delete_credential()
+        entry
+            .delete_credential()
             .context("Failed to delete API key")?;
 
         Ok(())
@@ -126,7 +129,13 @@ impl KeyringManager {
         format!("{}/{}", PAT_SERVICE_PREFIX, profile_name)
     }
 
-    pub fn store_pat(&self, profile_name: &str, user_email: &str, service: &str, token: &str) -> Result<()> {
+    pub fn store_pat(
+        &self,
+        profile_name: &str,
+        user_email: &str,
+        service: &str,
+        token: &str,
+    ) -> Result<()> {
         if !self.is_available() {
             bail!("Keyring is not available on this system");
         }
@@ -137,15 +146,24 @@ impl KeyringManager {
         let entry = keyring::Entry::new(&keyring_service, &keyring_user)
             .context("Failed to create keyring entry for PAT")?;
 
-        entry.set_password(token)
+        entry
+            .set_password(token)
             .context("Failed to store PAT in keyring")?;
 
-        eprintln!("[DEBUG] PAT stored in keyring: service={}, user={}", keyring_service, keyring_user);
+        eprintln!(
+            "[DEBUG] PAT stored in keyring: service={}, user={}",
+            keyring_service, keyring_user
+        );
 
         Ok(())
     }
 
-    pub fn get_pat(&self, profile_name: &str, user_email: &str, service: &str) -> Result<Option<String>> {
+    pub fn get_pat(
+        &self,
+        profile_name: &str,
+        user_email: &str,
+        service: &str,
+    ) -> Result<Option<String>> {
         if !self.is_available() {
             return Ok(None);
         }
@@ -158,11 +176,17 @@ impl KeyringManager {
 
         match entry.get_password() {
             Ok(token) => {
-                eprintln!("[DEBUG] PAT retrieved from keyring: service={}, user={}", keyring_service, keyring_user);
+                eprintln!(
+                    "[DEBUG] PAT retrieved from keyring: service={}, user={}",
+                    keyring_service, keyring_user
+                );
                 Ok(Some(token))
             }
             Err(keyring::Error::NoEntry) => {
-                eprintln!("[DEBUG] PAT not found in keyring: service={}, user={}", keyring_service, keyring_user);
+                eprintln!(
+                    "[DEBUG] PAT not found in keyring: service={}, user={}",
+                    keyring_service, keyring_user
+                );
                 Ok(None)
             }
             Err(e) => Err(e.into()),
@@ -180,22 +204,36 @@ impl KeyringManager {
         let entry = keyring::Entry::new(&keyring_service, &keyring_user)
             .context("Failed to create keyring entry for PAT")?;
 
-        entry.delete_credential()
+        entry
+            .delete_credential()
             .context("Failed to delete PAT from keyring")?;
 
-        eprintln!("[DEBUG] PAT deleted from keyring: service={}, user={}", keyring_service, keyring_user);
+        eprintln!(
+            "[DEBUG] PAT deleted from keyring: service={}, user={}",
+            keyring_service, keyring_user
+        );
 
         Ok(())
     }
 
     pub fn has_pat(&self, profile_name: &str, user_email: &str, service: &str) -> bool {
-        self.get_pat(profile_name, user_email, service).unwrap_or(None).is_some()
+        self.get_pat(profile_name, user_email, service)
+            .unwrap_or(None)
+            .is_some()
     }
 
-    pub fn delete_all_pats_for_profile(&self, profile_name: &str, user_email: &str, services: &[String]) -> Result<()> {
+    pub fn delete_all_pats_for_profile(
+        &self,
+        profile_name: &str,
+        user_email: &str,
+        services: &[String],
+    ) -> Result<()> {
         for service in services {
             if let Err(e) = self.delete_pat(profile_name, user_email, service) {
-                eprintln!("[DEBUG] Failed to delete PAT for service '{}': {}", service, e);
+                eprintln!(
+                    "[DEBUG] Failed to delete PAT for service '{}': {}",
+                    service, e
+                );
             }
         }
         Ok(())
@@ -259,7 +297,14 @@ pub fn get_default_model(provider: &str) -> &'static str {
 }
 
 pub fn get_supported_providers() -> &'static [&'static str] {
-    &["ollama", "openai", "anthropic", "kimi", "deepseek", "openrouter"]
+    &[
+        "ollama",
+        "openai",
+        "anthropic",
+        "kimi",
+        "deepseek",
+        "openrouter",
+    ]
 }
 
 pub fn provider_needs_api_key(provider: &str) -> bool {
@@ -273,10 +318,19 @@ mod tests {
     #[test]
     fn test_get_default_base_url() {
         assert_eq!(get_default_base_url("openai"), "https://api.openai.com/v1");
-        assert_eq!(get_default_base_url("anthropic"), "https://api.anthropic.com/v1");
+        assert_eq!(
+            get_default_base_url("anthropic"),
+            "https://api.anthropic.com/v1"
+        );
         assert_eq!(get_default_base_url("kimi"), "https://api.moonshot.cn/v1");
-        assert_eq!(get_default_base_url("deepseek"), "https://api.deepseek.com/v1");
+        assert_eq!(
-        assert_eq!(get_default_base_url("openrouter"), "https://openrouter.ai/api/v1");
+            get_default_base_url("deepseek"),
+            "https://api.deepseek.com/v1"
+        );
+        assert_eq!(
+            get_default_base_url("openrouter"),
+            "https://openrouter.ai/api/v1"
+        );
         assert_eq!(get_default_base_url("ollama"), "http://localhost:11434");
     }
 

src/utils/validators.rs

@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use lazy_static::lazy_static;
 use regex::Regex;
 
@@ -121,7 +121,12 @@ pub fn validate_commitlint_commit(message: &str) -> Result<()> {
         bail!("Commit subject too long (max 100 characters)");
     }
 
-    if subject.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) {
+    if subject
+        .chars()
+        .next()
+        .map(|c| c.is_uppercase())
+        .unwrap_or(false)
+    {
         bail!("Commit subject should not start with uppercase letter");
     }
 
@@ -187,7 +192,10 @@ pub fn validate_profile_name(name: &str) -> Result<()> {
         bail!("Profile name too long (max 50 characters)");
     }
 
-    if !name.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') {
+    if !name
+        .chars()
+        .all(|c| c.is_alphanumeric() || c == '-' || c == '_')
+    {
         bail!("Profile name can only contain letters, numbers, hyphens, and underscores");
     }
 

tests/config_export_import_tests.rs

@@ -20,7 +20,12 @@ mod config_export {
         init_quicommit(&config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["config", "export", "--config", config_path.to_str().unwrap()]);
+        cmd.args(&[
+            "config",
+            "export",
+            "--config",
+            config_path.to_str().unwrap(),
+        ]);
 
         cmd.assert()
             .success()
@@ -37,10 +42,14 @@ mod config_export {
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "export",
+            "config",
-            "--config", config_path.to_str().unwrap(),
+            "export",
-            "--output", export_path.to_str().unwrap(),
+            "--config",
-            "--password", ""
+            config_path.to_str().unwrap(),
+            "--output",
+            export_path.to_str().unwrap(),
+            "--password",
+            "",
         ]);
 
         cmd.assert()
@@ -51,7 +60,10 @@ mod config_export {
 
         let content = fs::read_to_string(&export_path).unwrap();
         assert!(content.contains("version"), "Export should contain version");
-        assert!(content.contains("[llm]"), "Export should contain LLM config");
+        assert!(
+            content.contains("[llm]"),
+            "Export should contain LLM config"
+        );
     }
 
     #[test]
@@ -63,10 +75,14 @@ mod config_export {
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "export",
+            "config",
-            "--config", config_path.to_str().unwrap(),
+            "export",
-            "--output", export_path.to_str().unwrap(),
+            "--config",
-            "--password", "test_password_123"
+            config_path.to_str().unwrap(),
+            "--output",
+            export_path.to_str().unwrap(),
+            "--password",
+            "test_password_123",
         ]);
 
         cmd.assert()
@@ -76,8 +92,14 @@ mod config_export {
         assert!(export_path.exists(), "Export file should be created");
 
         let content = fs::read_to_string(&export_path).unwrap();
-        assert!(content.starts_with("ENCRYPTED:"), "Encrypted file should start with ENCRYPTED:");
+        assert!(
-        assert!(!content.contains("[llm]"), "Encrypted content should not be readable");
+            content.starts_with("ENCRYPTED:"),
+            "Encrypted file should start with ENCRYPTED:"
+        );
+        assert!(
+            !content.contains("[llm]"),
+            "Encrypted content should not be readable"
+        );
     }
 }
 
@@ -139,9 +161,12 @@ keep_changelog_types_english = true
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "import",
+            "config",
-            "--config", config_path.to_str().unwrap(),
+            "import",
-            "--file", import_path.to_str().unwrap()
+            "--config",
+            config_path.to_str().unwrap(),
+            "--file",
+            import_path.to_str().unwrap(),
         ]);
 
         cmd.assert()
@@ -149,7 +174,13 @@ keep_changelog_types_english = true
             .stdout(predicate::str::contains("Configuration imported"));
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["config", "get", "llm.provider", "--config", config_path.to_str().unwrap()]);
+        cmd.args(&[
+            "config",
+            "get",
+            "llm.provider",
+            "--config",
+            config_path.to_str().unwrap(),
+        ]);
         cmd.assert()
             .success()
             .stdout(predicate::str::contains("openai"));
@@ -166,33 +197,51 @@ keep_changelog_types_english = true
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "set", "llm.provider", "anthropic",
+            "config",
-            "--config", config_path1.to_str().unwrap()
+            "set",
+            "llm.provider",
+            "anthropic",
+            "--config",
+            config_path1.to_str().unwrap(),
         ]);
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "export",
+            "config",
-            "--config", config_path1.to_str().unwrap(),
+            "export",
-            "--output", export_path.to_str().unwrap(),
+            "--config",
-            "--password", "secure_password"
+            config_path1.to_str().unwrap(),
+            "--output",
+            export_path.to_str().unwrap(),
+            "--password",
+            "secure_password",
         ]);
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "import",
+            "config",
-            "--config", config_path2.to_str().unwrap(),
+            "import",
-            "--file", export_path.to_str().unwrap(),
+            "--config",
-            "--password", "secure_password"
+            config_path2.to_str().unwrap(),
+            "--file",
+            export_path.to_str().unwrap(),
+            "--password",
+            "secure_password",
         ]);
         cmd.assert()
             .success()
             .stdout(predicate::str::contains("Configuration imported"));
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["config", "get", "llm.provider", "--config", config_path2.to_str().unwrap()]);
+        cmd.args(&[
+            "config",
+            "get",
+            "llm.provider",
+            "--config",
+            config_path2.to_str().unwrap(),
+        ]);
         cmd.assert()
             .success()
             .stdout(predicate::str::contains("anthropic"));
@@ -208,19 +257,27 @@ keep_changelog_types_english = true
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "export",
+            "config",
-            "--config", config_path.to_str().unwrap(),
+            "export",
-            "--output", export_path.to_str().unwrap(),
+            "--config",
-            "--password", "correct_password"
+            config_path.to_str().unwrap(),
+            "--output",
+            export_path.to_str().unwrap(),
+            "--password",
+            "correct_password",
         ]);
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "import",
+            "config",
-            "--config", config_path.to_str().unwrap(),
+            "import",
-            "--file", export_path.to_str().unwrap(),
+            "--config",
-            "--password", "wrong_password"
+            config_path.to_str().unwrap(),
+            "--file",
+            export_path.to_str().unwrap(),
+            "--password",
+            "wrong_password",
         ]);
         cmd.assert()
             .failure()
@@ -242,30 +299,47 @@ mod config_export_import_roundtrip {
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "set", "llm.model", "gpt-4-turbo",
+            "config",
-            "--config", config_path1.to_str().unwrap()
+            "set",
+            "llm.model",
+            "gpt-4-turbo",
+            "--config",
+            config_path1.to_str().unwrap(),
         ]);
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "export",
+            "config",
-            "--config", config_path1.to_str().unwrap(),
+            "export",
-            "--output", export_path.to_str().unwrap(),
+            "--config",
-            "--password", ""
+            config_path1.to_str().unwrap(),
+            "--output",
+            export_path.to_str().unwrap(),
+            "--password",
+            "",
         ]);
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "import",
+            "config",
-            "--config", config_path2.to_str().unwrap(),
+            "import",
-            "--file", export_path.to_str().unwrap()
+            "--config",
+            config_path2.to_str().unwrap(),
+            "--file",
+            export_path.to_str().unwrap(),
         ]);
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["config", "get", "llm.model", "--config", config_path2.to_str().unwrap()]);
+        cmd.args(&[
+            "config",
+            "get",
+            "llm.model",
+            "--config",
+            config_path2.to_str().unwrap(),
+        ]);
         cmd.assert()
             .success()
             .stdout(predicate::str::contains("gpt-4-turbo"));
@@ -283,24 +357,36 @@ mod config_export_import_roundtrip {
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "set", "llm.provider", "deepseek",
+            "config",
-            "--config", config_path1.to_str().unwrap()
+            "set",
+            "llm.provider",
+            "deepseek",
+            "--config",
+            config_path1.to_str().unwrap(),
         ]);
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "set", "llm.model", "deepseek-chat",
+            "config",
-            "--config", config_path1.to_str().unwrap()
+            "set",
+            "llm.model",
+            "deepseek-chat",
+            "--config",
+            config_path1.to_str().unwrap(),
         ]);
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "export",
+            "config",
-            "--config", config_path1.to_str().unwrap(),
+            "export",
-            "--output", export_path.to_str().unwrap(),
+            "--config",
-            "--password", password
+            config_path1.to_str().unwrap(),
+            "--output",
+            export_path.to_str().unwrap(),
+            "--password",
+            password,
         ]);
         cmd.assert().success();
 
@@ -310,21 +396,37 @@ mod config_export_import_roundtrip {
 
         let mut cmd = cargo_bin_cmd!("quicommit");
         cmd.args(&[
-            "config", "import",
+            "config",
-            "--config", config_path2.to_str().unwrap(),
+            "import",
-            "--file", export_path.to_str().unwrap(),
+            "--config",
-            "--password", password
+            config_path2.to_str().unwrap(),
+            "--file",
+            export_path.to_str().unwrap(),
+            "--password",
+            password,
         ]);
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["config", "get", "llm.provider", "--config", config_path2.to_str().unwrap()]);
+        cmd.args(&[
+            "config",
+            "get",
+            "llm.provider",
+            "--config",
+            config_path2.to_str().unwrap(),
+        ]);
         cmd.assert()
             .success()
             .stdout(predicate::str::contains("deepseek"));
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["config", "get", "llm.model", "--config", config_path2.to_str().unwrap()]);
+        cmd.args(&[
+            "config",
+            "get",
+            "llm.model",
+            "--config",
+            config_path2.to_str().unwrap(),
+        ]);
         cmd.assert()
             .success()
             .stdout(predicate::str::contains("deepseek-chat"));

tests/integration_tests.rs

@@ -107,7 +107,13 @@ mod cli_basic {
         configure_git_user(&repo_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["-vv", "init", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "-vv",
+            "init",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert().success();
@@ -169,7 +175,13 @@ mod init_command {
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["init", "--yes", "--reset", "--config", config_path.to_str().unwrap()]);
+        cmd.args(&[
+            "init",
+            "--yes",
+            "--reset",
+            "--config",
+            config_path.to_str().unwrap(),
+        ]);
         cmd.assert()
             .success()
             .stdout(predicate::str::contains("initialized successfully"));
@@ -261,7 +273,13 @@ mod commit_command {
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["commit", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "commit",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(temp_dir.path());
 
         cmd.assert()
@@ -279,7 +297,16 @@ mod commit_command {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["commit", "--manual", "-m", "test: empty", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "commit",
+            "--manual",
+            "-m",
+            "test: empty",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert()
@@ -297,7 +324,16 @@ mod commit_command {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["commit", "--manual", "-m", "test: add test file", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "commit",
+            "--manual",
+            "-m",
+            "test: add test file",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert()
@@ -315,7 +351,14 @@ mod commit_command {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["commit", "--date", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "commit",
+            "--date",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert()
@@ -333,7 +376,17 @@ mod commit_command {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["commit", "--think", "--manual", "-m", "test: think flag", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "commit",
+            "--think",
+            "--manual",
+            "-m",
+            "test: think flag",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert().success();
@@ -353,7 +406,13 @@ mod tag_command {
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["tag", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "tag",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(temp_dir.path());
 
         cmd.assert()
@@ -375,7 +434,15 @@ mod tag_command {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["tag", "--name", "v0.1.0", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "tag",
+            "--name",
+            "v0.1.0",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert()
@@ -397,7 +464,16 @@ mod tag_command {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["tag", "--think", "--name", "v0.2.0", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "tag",
+            "--think",
+            "--name",
+            "v0.2.0",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert().success();
@@ -419,7 +495,14 @@ mod changelog_command {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["changelog", "--init", "--output", changelog_path.to_str().unwrap(), "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "changelog",
+            "--init",
+            "--output",
+            changelog_path.to_str().unwrap(),
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert().success();
@@ -441,11 +524,16 @@ mod changelog_command {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["changelog", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "changelog",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
-        cmd.assert()
+        cmd.assert().success();
-            .success();
     }
 }
 
@@ -560,7 +648,16 @@ mod validators {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["commit", "--manual", "-m", "invalid commit message without type", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "commit",
+            "--manual",
+            "-m",
+            "invalid commit message without type",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert()
@@ -578,7 +675,16 @@ mod validators {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["commit", "--manual", "-m", "feat: add new feature", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "commit",
+            "--manual",
+            "-m",
+            "feat: add new feature",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert()
@@ -600,7 +706,16 @@ mod subcommands {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["c", "--manual", "-m", "fix: test", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "c",
+            "--manual",
+            "-m",
+            "fix: test",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert()
@@ -648,7 +763,12 @@ mod edge_cases {
         let non_existent_config = temp_dir.path().join("non_existent_config.toml");
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["config", "show", "--config", non_existent_config.to_str().unwrap()]);
+        cmd.args(&[
+            "config",
+            "show",
+            "--config",
+            non_existent_config.to_str().unwrap(),
+        ]);
 
         cmd.assert()
             .success()
@@ -668,7 +788,13 @@ mod edge_cases {
         cmd.assert().success();
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["commit", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "commit",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
         cmd.assert()
@@ -686,11 +812,20 @@ mod edge_cases {
         init_quicommit(&repo_path, &config_path);
 
         let mut cmd = cargo_bin_cmd!("quicommit");
-        cmd.args(&["commit", "--manual", "-m", "", "--dry-run", "--yes", "--config", config_path.to_str().unwrap()])
+        cmd.args(&[
+            "commit",
+            "--manual",
+            "-m",
+            "",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
         .current_dir(&repo_path);
 
-        cmd.assert()
+        cmd.assert().failure().stderr(predicate::str::contains(
-            .failure()
+            "Invalid conventional commit format",
-            .stderr(predicate::str::contains("Invalid conventional commit format"));
+        ));
     }
 }