SidneyZhang/QuiCommit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

feat: feat: add multilingual output support for commit, tag, and changelog commands

Browse Source
This commit is contained in:
Sidney Zhang
2026-02-01 12:06:12 +00:00
parent c3cd01dbcd
commit 0cbd975748
11 changed files with 1710 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
src/commands/changelog.rs
View File

@@ -5,10 +5,11 @@ use colored::Colorize;
use dialoguer::{Confirm, Input};
use std::path::PathBuf;
use crate::config::manager::ConfigManager;
use crate::config::{Language, manager::ConfigManager};
use crate::generator::ContentGenerator;
use crate::git::find_repo;
use crate::git::{changelog::*, CommitInfo, GitRepo};
use crate::i18n::{Messages, translate_changelog_category};
/// Generate changelog
#[derive(Parser)]
@@ -67,6 +68,8 @@ impl ChangelogCommand {
let repo = find_repo(std::env::current_dir()?.as_path())?;
let manager = ConfigManager::new()?;
let config = manager.config();
let language = manager.get_language().unwrap_or(Language::English);
let messages = Messages::new(language);
// Initialize changelog if requested
if self.init {
@@ -75,7 +78,7 @@ impl ChangelogCommand {
.unwrap_or_else(|| PathBuf::from(&config.changelog.path));
init_changelog(&path)?;
println!("{} Initialized changelog at {:?}", "✓".green(), path);
println!("{}", messages.initialized_changelog(&format!("{:?}", path)));
return Ok(());
}
@@ -98,28 +101,28 @@ impl ChangelogCommand {
v.clone()
} else if !self.yes {
Input::new()
.with_prompt("Version")
.default("Unreleased".to_string())
.with_prompt(messages.version())
.default(messages.unreleased().to_string())
.interact_text()?
} else {
"Unreleased".to_string()
messages.unreleased().to_string()
};
// Get commits
println!("{} Fetching commits...", "→".blue());
println!("{}", messages.fetching_commits());
let commits = generate_from_history(&repo, self.from.as_deref(), Some(&self.to))?;
if commits.is_empty() {
bail!("No commits found in the specified range");
bail!("{}", messages.no_commits_found());
}
println!("{} Found {} commits", "✓".green(), commits.len());
println!("{}", messages.found_commits(commits.len()));
// Generate changelog
let changelog = if self.generate || (config.changelog.auto_generate && !self.yes) {
self.generate_with_ai(&repo, &version, &commits).await?
self.generate_with_ai(&repo, &version, &commits, &messages).await?
} else {
self.generate_with_template(format, &version, &commits)?
self.generate_with_template(format, &version, &commits, language)?
};
// Output or write
@@ -133,7 +136,7 @@ impl ChangelogCommand {
// Preview
if !self.yes {
println!("\n{}", "─".repeat(60));
println!("{}", "Changelog preview:".bold());
println!("{}", messages.changelog_preview().bold());
println!("{}", "─".repeat(60));
// Show first 20 lines
let preview: String = changelog.lines().take(20).collect::<Vec<_>>().join("\n");
@@ -144,12 +147,12 @@ impl ChangelogCommand {
println!("{}", "─".repeat(60));
let confirm = Confirm::new()
.with_prompt(&format!("Write to {:?}?", output_path))
.with_prompt(&messages.write_to_file(&format!("{:?}", output_path)))
.default(true)
.interact()?;
if !confirm {
println!("{}", "Cancelled.".yellow());
println!("{}", messages.cancelled().yellow());
return Ok(());
}
}
@@ -163,7 +166,7 @@ impl ChangelogCommand {
std::fs::write(&output_path, changelog)?;
}
println!("{} Changelog written to {:?}", "✓".green(), output_path);
println!("{} {:?}", messages.changelog_written(), output_path);
Ok(())
}
@@ -173,11 +176,12 @@ impl ChangelogCommand {
repo: &GitRepo,
version: &str,
commits: &[CommitInfo],
messages: &Messages,
) -> Result<String> {
let manager = ConfigManager::new()?;
let config = manager.config();
println!("{} AI is generating changelog...", "🤖");
println!("{}", messages.ai_generating_changelog());
let generator = ContentGenerator::new(&config.llm).await?;
generator.generate_changelog_entry(version, commits).await
@@ -188,12 +192,43 @@ impl ChangelogCommand {
format: ChangelogFormat,
version: &str,
commits: &[CommitInfo],
language: Language,
) -> Result<String> {
let manager = ConfigManager::new()?;
let generator = ChangelogGenerator::new()
.format(format)
.include_hashes(self.include_hashes)
.include_authors(self.include_authors);
generator.generate(version, Utc::now(), commits)
let changelog = generator.generate(version, Utc::now(), commits)?;
// Translate changelog categories if configured
if !manager.keep_changelog_types_english() {
Ok(self.translate_changelog_categories(&changelog, language))
} else {
Ok(changelog)
}
}
fn translate_changelog_categories(&self, changelog: &str, language: Language) -> String {
let translated = 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);
if line.starts_with("## ") {
format!("## {}", translated_category)
} else {
format!("### {}", translated_category)
}
} else {
line.to_string()
}
})
.collect::<Vec<_>>()
.join("\n");
translated
}
}

55
src/commands/commit.rs
View File

@@ -3,11 +3,12 @@ use clap::Parser;
use colored::Colorize;
use dialoguer::{Confirm, Input, Select};
use crate::config::manager::ConfigManager;
use crate::config::{Language, manager::ConfigManager};
use crate::config::CommitFormat;
use crate::generator::ContentGenerator;
use crate::git::{find_repo, GitRepo};
use crate::git::commit::{CommitBuilder, create_date_commit_message};
use crate::i18n::{Messages, translate_commit_type};
use crate::utils::validators::get_commit_types;
/// Generate and execute conventional commits
@@ -79,15 +80,17 @@ impl CommitCommand {
// Find git repository
let repo = find_repo(std::env::current_dir()?.as_path())?;
// Check for changes
let status = repo.status_summary()?;
if status.clean && !self.amend {
bail!("No changes to commit. Working tree is clean.");
}
// Load configuration
let manager = ConfigManager::new()?;
let config = manager.config();
let language = manager.get_language().unwrap_or(Language::English);
let messages = Messages::new(language);
// Check for changes
let status = repo.status_summary()?;
if status.clean && !self.amend {
bail!("{}", messages.no_changes());
}
// Determine commit format
let format = if self.conventional {
@@ -101,7 +104,7 @@ impl CommitCommand {
// Stage all if requested
if self.all {
repo.stage_all()?;
println!("{}", "✓ Staged all changes".green());
println!("{}", messages.staged_all().green());
}
// Generate or build commit message
@@ -113,10 +116,10 @@ impl CommitCommand {
self.create_manual_commit(format)?
} else if config.commit.auto_generate && !self.yes {
// AI-generated commit
self.generate_commit(&repo, format).await?
self.generate_commit(&repo, format, &messages).await?
} else {
// Interactive commit creation
self.create_interactive_commit(format).await?
self.create_interactive_commit(format, &messages).await?
};
// Validate message
@@ -132,32 +135,32 @@ impl CommitCommand {
// Show commit preview
if !self.yes {
println!("\n{}", "─".repeat(60));
println!("{}", "Commit preview:".bold());
println!("{}", messages.commit_preview().bold());
println!("{}", "─".repeat(60));
println!("{}", commit_message);
println!("{}", "─".repeat(60));
let confirm = Confirm::new()
.with_prompt("Do you want to proceed with this commit?")
.with_prompt(messages.proceed_commit())
.default(true)
.interact()?;
if !confirm {
println!("{}", "Commit cancelled.".yellow());
println!("{}", messages.commit_cancelled().yellow());
return Ok(());
}
}
let result = if self.amend {
if self.dry_run {
println!("\n{}", "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{}", "Dry run - commit not created.".yellow());
println!("\n{} {}", messages.dry_run(), "- commit not created.".yellow());
return Ok(());
}
CommitBuilder::new()
@@ -167,9 +170,9 @@ impl CommitCommand {
};
if let Some(commit_oid) = result {
println!("{} {}", "✓ Created commit".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!("{} {}", "✓ Amended commit".green().bold(), "successfully");
println!("{} {}", messages.commit_amended().green().bold(), "successfully");
}
Ok(())
@@ -198,7 +201,7 @@ impl CommitCommand {
builder.build_message()
}
async fn generate_commit(&self, repo: &GitRepo, format: CommitFormat) -> Result<String> {
async fn generate_commit(&self, repo: &GitRepo, format: CommitFormat, messages: &Messages) -> Result<String> {
let manager = ConfigManager::new()?;
let config = manager.config();
@@ -206,7 +209,7 @@ impl CommitCommand {
let generator = ContentGenerator::new(&config.llm).await
.context("Failed to initialize LLM. Use --manual for manual commit.")?;
println!("{} AI is analyzing your changes...", "🤖".to_string());
println!("{}", messages.ai_analyzing());
let generated = if self.yes {
generator.generate_commit_from_repo(repo, format).await?
@@ -217,42 +220,42 @@ impl CommitCommand {
Ok(generated.to_conventional())
}
async fn create_interactive_commit(&self, format: CommitFormat) -> Result<String> {
async fn create_interactive_commit(&self, format: CommitFormat, messages: &Messages) -> Result<String> {
let types = get_commit_types(format == CommitFormat::Commitlint);
// Select type
let type_idx = Select::new()
.with_prompt("Select commit type")
.with_prompt(messages.select_commit_type())
.items(types)
.interact()?;
let commit_type = types[type_idx].to_string();
// Enter scope (optional)
let scope: String = Input::new()
.with_prompt("Scope (optional, press Enter to skip)")
.with_prompt(messages.scope_optional())
.allow_empty(true)
.interact_text()?;
let scope = if scope.is_empty() { None } else { Some(scope) };
// Enter description
let description: String = Input::new()
.with_prompt("Description")
.with_prompt(messages.description())
.interact_text()?;
// Breaking change
let breaking = Confirm::new()
.with_prompt("Is this a breaking change?")
.with_prompt(messages.breaking_change())
.default(false)
.interact()?;
// Add body
let add_body = Confirm::new()
.with_prompt("Add body to commit?")
.with_prompt(messages.add_body())
.default(false)
.interact()?;
let body = if add_body {
let body_text = crate::utils::editor::edit_content("Enter commit body...")?;
let body_text = crate::utils::editor::edit_content(messages.enter_commit_body())?;
if body_text.trim().is_empty() {
None
} else {

79
src/commands/config.rs
View File

@@ -3,7 +3,7 @@ use clap::{Parser, Subcommand};
use colored::Colorize;
use dialoguer::{Confirm, Input, Select};
use crate::config::manager::ConfigManager;
use crate::config::{Language, manager::ConfigManager};
use crate::config::CommitFormat;
/// Mask API key with asterisks for security
@@ -146,7 +146,25 @@ enum ConfigSubcommand {
/// Path
path: String,
},
/// Set output language
SetLanguage {
/// Language code (en, zh, ja, ko, es, fr, de)
language: Option<String>,
},
/// Set whether to keep commit types in English
SetKeepTypesEnglish {
/// Keep types in English (true/false)
keep: bool,
},
/// Set whether to keep changelog types in English
SetKeepChangelogTypesEnglish {
/// Keep types in English (true/false)
keep: bool,
},
/// Reset configuration to defaults
Reset {
/// Skip confirmation
@@ -196,6 +214,9 @@ impl ConfigCommand {
Some(ConfigSubcommand::SetCommitFormat { format }) => self.set_commit_format(format).await,
Some(ConfigSubcommand::SetVersionPrefix { prefix }) => self.set_version_prefix(prefix).await,
Some(ConfigSubcommand::SetChangelogPath { path }) => self.set_changelog_path(path).await,
Some(ConfigSubcommand::SetLanguage { language }) => self.set_language(language.as_deref()).await,
Some(ConfigSubcommand::SetKeepTypesEnglish { keep }) => self.set_keep_types_english(*keep).await,
Some(ConfigSubcommand::SetKeepChangelogTypesEnglish { keep }) => self.set_keep_changelog_types_english(*keep).await,
Some(ConfigSubcommand::Reset { force }) => self.reset(*force).await,
Some(ConfigSubcommand::Export { output }) => self.export_config(output.as_deref()).await,
Some(ConfigSubcommand::Import { file }) => self.import_config(file).await,
@@ -268,6 +289,12 @@ impl ConfigCommand {
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!(" 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() });
@@ -706,6 +733,54 @@ impl ConfigCommand {
Ok(())
}
async fn set_language(&self, language: Option<&str>) -> Result<()> {
let mut manager = ConfigManager::new()?;
let language_code = if let Some(lang) = language {
lang.to_string()
} else {
let languages = vec![
Language::English,
Language::Chinese,
Language::Japanese,
Language::Korean,
Language::Spanish,
Language::French,
Language::German,
];
let language_names: Vec<String> = languages.iter().map(|l| l.display_name().to_string()).collect();
let idx = Select::new()
.with_prompt("Select language")
.items(&language_names)
.default(0)
.interact()?;
languages[idx].to_code().to_string()
};
manager.set_output_language(language_code.clone());
manager.save()?;
println!("{} Set output language to {}", "✓".green(), language_code.cyan());
Ok(())
}
async fn set_keep_types_english(&self, keep: bool) -> Result<()> {
let mut manager = ConfigManager::new()?;
manager.set_keep_types_english(keep);
manager.save()?;
let status = if keep { "enabled" } else { "disabled" };
println!("{} Keep commit types in English: {}", "✓".green(), status);
Ok(())
}
async fn set_keep_changelog_types_english(&self, keep: bool) -> Result<()> {
let mut manager = ConfigManager::new()?;
manager.set_keep_changelog_types_english(keep);
manager.save()?;
let status = if keep { "enabled" } else { "disabled" };
println!("{} Keep changelog types in English: {}", "✓".green(), status);
Ok(())
}
async fn reset(&self, force: bool) -> Result<()> {
if !force {
let confirm = Confirm::new()

89
src/commands/init.rs
View File

@@ -3,9 +3,10 @@ use clap::Parser;
use colored::Colorize;
use dialoguer::{Confirm, Input, Select};
use crate::config::{GitProfile};
use crate::config::{GitProfile, Language};
use crate::config::manager::ConfigManager;
use crate::config::profile::{GpgConfig, SshConfig};
use crate::i18n::Messages;
use crate::utils::validators::validate_email;
/// Initialize quicommit configuration
@@ -22,7 +23,9 @@ pub struct InitCommand {
impl InitCommand {
pub async fn execute(&self) -> Result<()> {
println!("{}", "🚀 Initializing QuiCommit...".bold().cyan());
// Start with English messages for initialization
let messages = Messages::new(Language::English);
println!("{}", messages.initializing().bold().cyan());
let config_path = crate::config::AppConfig::default_path()?;
@@ -57,9 +60,13 @@ impl InitCommand {
manager.save()?;
println!("{}", "✅ QuiCommit initialized successfully!".bold().green());
println!("\nConfig file: {}", config_path.display());
println!("\nNext steps:");
// Get configured language for final messages
let language = manager.get_language().unwrap_or(Language::English);
let messages = Messages::new(language);
println!("{}", messages.init_success().bold().green());
println!("\n{}: {}", messages.config_file(), config_path.display());
println!("\n{}:", messages.next_steps());
println!(" 1. Create a profile: {}", "quicommit profile add".cyan());
println!(" 2. Configure LLM: {}", "quicommit config set-llm".cyan());
println!(" 3. Start committing: {}", "quicommit commit".cyan());
@@ -90,11 +97,35 @@ impl InitCommand {
}
async fn interactive_setup(&self, manager: &mut ConfigManager) -> Result<()> {
println!("\n{}", "Let's set up your first profile:".bold());
let messages = Messages::new(Language::English);
println!("\n{}", messages.setup_profile().bold());
// Language selection
println!("\n{}", messages.select_output_language().bold());
let languages = vec![
Language::English,
Language::Chinese,
Language::Japanese,
Language::Korean,
Language::Spanish,
Language::French,
Language::German,
];
let language_names: Vec<String> = languages.iter().map(|l| l.display_name().to_string()).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());
// Update messages to selected language
let messages = Messages::new(selected_language);
// Profile name
let profile_name: String = Input::new()
.with_prompt("Profile name")
.with_prompt(messages.profile_name())
.default("personal".to_string())
.interact_text()?;
@@ -110,12 +141,12 @@ impl InitCommand {
.unwrap_or_default();
let user_name: String = Input::new()
.with_prompt("Git user name")
.with_prompt(messages.git_user_name())
.default(default_name)
.interact_text()?;
let user_email: String = Input::new()
.with_prompt("Git user email")
.with_prompt(messages.git_user_email())
.default(default_email)
.validate_with(|input: &String| {
validate_email(input).map_err(|e| e.to_string())
@@ -123,18 +154,18 @@ impl InitCommand {
.interact_text()?;
let description: String = Input::new()
.with_prompt("Profile description (optional)")
.with_prompt(messages.profile_description())
.allow_empty(true)
.interact_text()?;
let is_work = Confirm::new()
.with_prompt("Is this a work profile?")
.with_prompt(messages.is_work_profile())
.default(false)
.interact()?;
let organization = if is_work {
Some(Input::new()
.with_prompt("Organization/Company name")
.with_prompt(messages.organization_name())
.interact_text()?)
} else {
None
@@ -142,24 +173,24 @@ impl InitCommand {
// SSH configuration
let setup_ssh = Confirm::new()
.with_prompt("Configure SSH key?")
.with_prompt(messages.configure_ssh())
.default(false)
.interact()?;
let ssh_config = if setup_ssh {
Some(self.setup_ssh_interactive().await?)
Some(self.setup_ssh_interactive(&messages).await?)
} else {
None
};
// GPG configuration
let setup_gpg = Confirm::new()
.with_prompt("Configure GPG signing?")
.with_prompt(messages.configure_gpg())
.default(false)
.interact()?;
let gpg_config = if setup_gpg {
Some(self.setup_gpg_interactive().await?)
Some(self.setup_gpg_interactive(&messages).await?)
} else {
None
};
@@ -184,7 +215,7 @@ impl InitCommand {
manager.set_default_profile(Some(profile_name))?;
// LLM provider selection
println!("\n{}", "Select your preferred LLM provider:".bold());
println!("\n{}", messages.select_llm_provider().bold());
let providers = vec![
"Ollama (local)",
"OpenAI",
@@ -213,27 +244,27 @@ impl InitCommand {
// Configure API key if needed
if provider == "openai" {
let api_key: String = Input::new()
.with_prompt("OpenAI API key")
.with_prompt(messages.openai_api_key())
.interact_text()?;
manager.set_openai_api_key(api_key);
} else if provider == "anthropic" {
let api_key: String = Input::new()
.with_prompt("Anthropic API key")
.with_prompt(messages.anthropic_api_key())
.interact_text()?;
manager.set_anthropic_api_key(api_key);
} else if provider == "kimi" {
let api_key: String = Input::new()
.with_prompt("Kimi API key")
.with_prompt(messages.kimi_api_key())
.interact_text()?;
manager.set_kimi_api_key(api_key);
} else if provider == "deepseek" {
let api_key: String = Input::new()
.with_prompt("DeepSeek API key")
.with_prompt(messages.deepseek_api_key())
.interact_text()?;
manager.set_deepseek_api_key(api_key);
} else if provider == "openrouter" {
let api_key: String = Input::new()
.with_prompt("OpenRouter API key")
.with_prompt(messages.openrouter_api_key())
.interact_text()?;
manager.set_openrouter_api_key(api_key);
}
@@ -241,7 +272,7 @@ impl InitCommand {
Ok(())
}
async fn setup_ssh_interactive(&self) -> Result<SshConfig> {
async fn setup_ssh_interactive(&self, messages: &Messages) -> Result<SshConfig> {
use std::path::PathBuf;
let ssh_dir = dirs::home_dir()
@@ -249,17 +280,17 @@ impl InitCommand {
.unwrap_or_else(|| PathBuf::from("~/.ssh"));
let key_path: String = Input::new()
.with_prompt("SSH private key path")
.with_prompt(messages.ssh_private_key_path())
.default(ssh_dir.join("id_rsa").display().to_string())
.interact_text()?;
let has_passphrase = Confirm::new()
.with_prompt("Does this key have a passphrase?")
.with_prompt(messages.has_passphrase())
.default(false)
.interact()?;
let passphrase = if has_passphrase {
Some(crate::utils::password_input("SSH key passphrase")?)
Some(crate::utils::password_input(messages.ssh_key_passphrase())?)
} else {
None
};
@@ -274,13 +305,13 @@ impl InitCommand {
})
}
async fn setup_gpg_interactive(&self) -> Result<GpgConfig> {
async fn setup_gpg_interactive(&self, messages: &Messages) -> Result<GpgConfig> {
let key_id: String = Input::new()
.with_prompt("GPG key ID")
.with_prompt(messages.gpg_key_id())
.interact_text()?;
let use_agent = Confirm::new()
.with_prompt("Use GPG agent?")
.with_prompt(messages.use_gpg_agent())
.default(true)
.interact()?;

67
src/commands/tag.rs
View File

@@ -4,12 +4,13 @@ use colored::Colorize;
use dialoguer::{Confirm, Input, Select};
use semver::Version;
use crate::config::manager::ConfigManager;
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,
};
use crate::i18n::Messages;
/// Generate and create Git tags
#[derive(Parser)]
@@ -64,6 +65,8 @@ impl TagCommand {
let repo = find_repo(std::env::current_dir()?.as_path())?;
let manager = ConfigManager::new()?;
let config = manager.config();
let language = manager.get_language().unwrap_or(Language::English);
let messages = Messages::new(language);
// Determine tag name
let tag_name = if let Some(name) = &self.name {
@@ -80,7 +83,7 @@ impl TagCommand {
format!("{}{}", prefix, new_version)
} else {
// Interactive mode
self.select_version_interactive(&repo, &config.tag.version_prefix).await?
self.select_version_interactive(&repo, &config.tag.version_prefix, &messages).await?
};
// Validate tag name (if it looks like a version)
@@ -96,7 +99,7 @@ impl TagCommand {
.interact()?;
if !proceed {
bail!("Tag creation cancelled");
bail!("{}", messages.tag_cancelled());
}
}
}
@@ -108,16 +111,16 @@ 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).await?)
Some(self.generate_tag_message(&repo, &tag_name, &messages).await?)
} else if !self.yes {
Some(self.input_message_interactive(&tag_name)?)
Some(self.input_message_interactive(&tag_name, &messages)?)
} else {
Some(format!("Release {}", tag_name))
};
// Show preview
println!("\n{}", "─".repeat(60));
println!("{}", "Tag preview:".bold());
println!("{}", messages.tag_preview().bold());
println!("{}", "─".repeat(60));
println!("Name: {}", tag_name.cyan());
if let Some(ref msg) = message {
@@ -129,18 +132,18 @@ impl TagCommand {
if !self.yes {
let confirm = Confirm::new()
.with_prompt("Create this tag?")
.with_prompt(messages.create_tag())
.default(true)
.interact()?;
if !confirm {
println!("{}", "Tag creation cancelled.".yellow());
println!("{}", messages.tag_cancelled().yellow());
return Ok(());
}
}
if self.dry_run {
println!("\n{}", "Dry run - tag not created.".yellow());
println!("\n{} {}", messages.dry_run(), "- tag not created.".yellow());
return Ok(());
}
@@ -153,41 +156,41 @@ impl TagCommand {
builder.execute(&repo)?;
println!("{} Created tag {}", "✓".green(), tag_name.cyan());
println!("{} {}", messages.tag_created().green(), tag_name.cyan());
// Push if requested
if self.push {
println!("{} Pushing tag to {}...", "→".blue(), &self.remote);
println!("{}", messages.pushing_tag(&self.remote));
repo.push(&self.remote, &format!("refs/tags/{}", tag_name))?;
println!("{} Pushed tag to {}", "✓".green(), &self.remote);
println!("{}", messages.pushed_tag(&self.remote));
}
Ok(())
}
async fn select_version_interactive(&self, repo: &GitRepo, prefix: &str) -> Result<String> {
async fn select_version_interactive(&self, repo: &GitRepo, prefix: &str, messages: &Messages) -> Result<String> {
loop {
let latest = get_latest_version(repo, prefix)?;
println!("\n{}", "Version selection:".bold());
println!("\n{}", messages.version_selection().bold());
if let Some(ref version) = latest {
println!("Latest version: {}{}", prefix, version);
println!("{} {}{}", messages.latest_version(), prefix, version);
} else {
println!("No existing version tags found");
println!("{}", messages.no_existing_version_tags());
}
let options = vec![
"Auto-detect bump from commits",
"Bump major version",
"Bump minor version",
"Bump patch version",
"Enter custom version",
"Enter custom tag name",
messages.auto_detect_bump(),
messages.bump_major_version(),
messages.bump_minor_version(),
messages.bump_patch_version(),
messages.enter_custom_version(),
messages.enter_custom_tag_name(),
];
let selection = Select::new()
.with_prompt("Select option")
.with_prompt(messages.select_option())
.items(&options)
.default(0)
.interact()?;
@@ -201,10 +204,10 @@ impl TagCommand {
.map(|v| bump_version(v, bump, None))
.unwrap_or_else(|| Version::new(0, 1, 0));
println!("Suggested bump: {:?} → {}{}", bump, prefix, version);
println!("{} {:?} → {}{}", messages.suggested_bump(), bump, prefix, version);
let confirm = Confirm::new()
.with_prompt("Use this version?")
.with_prompt(messages.use_this_version())
.default(true)
.interact()?;
@@ -233,14 +236,14 @@ impl TagCommand {
}
4 => {
let input: String = Input::new()
.with_prompt("Enter version (e.g., 1.2.3)")
.with_prompt(messages.enter_version())
.interact_text()?;
let version = Version::parse(&input)?;
return Ok(format!("{}{}", prefix, version));
}
5 => {
let input: String = Input::new()
.with_prompt("Enter tag name")
.with_prompt(messages.enter_tag_name())
.interact_text()?;
return Ok(input);
}
@@ -249,7 +252,7 @@ impl TagCommand {
}
}
async fn generate_tag_message(&self, repo: &GitRepo, version: &str) -> Result<String> {
async fn generate_tag_message(&self, repo: &GitRepo, version: &str, messages: &Messages) -> Result<String> {
let manager = ConfigManager::new()?;
let config = manager.config();
@@ -265,17 +268,17 @@ impl TagCommand {
return Ok(format!("Release {}", version));
}
println!("{} AI is generating tag message from {} commits...", "🤖", commits.len());
println!("{}", messages.ai_generating_tag(commits.len()));
let generator = ContentGenerator::new(&config.llm).await?;
generator.generate_tag_message(version, &commits).await
}
fn input_message_interactive(&self, version: &str) -> Result<String> {
fn input_message_interactive(&self, version: &str, messages: &Messages) -> Result<String> {
let default_msg = format!("Release {}", version);
let use_editor = Confirm::new()
.with_prompt("Open editor for tag message?")
.with_prompt(messages.open_editor())
.default(false)
.interact()?;
@@ -283,7 +286,7 @@ impl TagCommand {
crate::utils::editor::edit_content(&default_msg)
} else {
Ok(Input::new()
.with_prompt("Tag message")
.with_prompt(messages.tag_message())
.default(default_msg)
.interact_text()?)
}

40
src/config/manager.rs
View File

@@ -391,6 +391,46 @@ impl ConfigManager {
self.modified = true;
}
// Language configuration
/// Get output language
pub fn output_language(&self) -> &str {
&self.config.language.output_language
}
/// Set output language
pub fn set_output_language(&mut self, language: String) {
self.config.language.output_language = language;
self.modified = true;
}
/// Get language enum from config
pub fn get_language(&self) -> Option<super::Language> {
super::Language::from_str(&self.config.language.output_language)
}
/// Check if commit types should be kept in English
pub fn keep_types_english(&self) -> bool {
self.config.language.keep_types_english
}
/// Set keep types English flag
pub fn set_keep_types_english(&mut self, keep: bool) {
self.config.language.keep_types_english = keep;
self.modified = true;
}
/// Check if changelog types should be kept in English
pub fn keep_changelog_types_english(&self) -> bool {
self.config.language.keep_changelog_types_english
}
/// Set keep changelog types English flag
pub fn set_keep_changelog_types_english(&mut self, keep: bool) {
self.config.language.keep_changelog_types_english = keep;
self.modified = true;
}
/// Export configuration to TOML string
pub fn export(&self) -> Result<String> {
toml::to_string_pretty(&self.config)

86
src/config/mod.rs
View File

@@ -53,6 +53,10 @@ pub struct AppConfig {
/// Theme settings
#[serde(default)]
pub theme: ThemeConfig,
/// Language settings
#[serde(default)]
pub language: LanguageConfig,
}
impl Default for AppConfig {
@@ -68,6 +72,7 @@ impl Default for AppConfig {
repo_profiles: HashMap::new(),
encrypt_sensitive: true,
theme: ThemeConfig::default(),
language: LanguageConfig::default(),
}
}
}
@@ -497,6 +502,83 @@ impl Default for ThemeConfig {
}
}
/// Language configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LanguageConfig {
/// Output language for messages (en, zh, etc.)
#[serde(default = "default_output_language")]
pub output_language: String,
/// Keep commit types in English
#[serde(default = "default_true")]
pub keep_types_english: bool,
/// Keep changelog types in English
#[serde(default = "default_true")]
pub keep_changelog_types_english: bool,
}
impl Default for LanguageConfig {
fn default() -> Self {
Self {
output_language: default_output_language(),
keep_types_english: true,
keep_changelog_types_english: true,
}
}
}
/// Supported languages
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Language {
English,
Chinese,
Japanese,
Korean,
Spanish,
French,
German,
}
impl Language {
pub fn from_str(s: &str) -> Option<Self> {
match s.to_lowercase().as_str() {
"en" | "english" => Some(Language::English),
"zh" | "chinese" | "zh-cn" | "zh-tw" => Some(Language::Chinese),
"ja" | "japanese" => Some(Language::Japanese),
"ko" | "korean" => Some(Language::Korean),
"es" | "spanish" => Some(Language::Spanish),
"fr" | "french" => Some(Language::French),
"de" | "german" => Some(Language::German),
_ => None,
}
}
pub fn to_code(&self) -> &str {
match self {
Language::English => "en",
Language::Chinese => "zh",
Language::Japanese => "ja",
Language::Korean => "ko",
Language::Spanish => "es",
Language::French => "fr",
Language::German => "de",
}
}
pub fn display_name(&self) -> &str {
match self {
Language::English => "English",
Language::Chinese => "中文",
Language::Japanese => "日本語",
Language::Korean => "한국어",
Language::Spanish => "Español",
Language::French => "Français",
Language::German => "Deutsch",
}
}
}
// Default value functions
fn default_version() -> String {
"1".to_string()
@@ -594,6 +676,10 @@ fn default_date_format() -> String {
"%Y-%m-%d".to_string()
}
fn default_output_language() -> String {
"en".to_string()
}
impl AppConfig {
/// Load configuration from file
pub fn load(path: &Path) -> Result<Self> {

1091
src/i18n/messages.rs Normal file
View File

File diff suppressed because it is too large Load Diff

7
src/i18n/mod.rs Normal file
View File

@@ -0,0 +1,7 @@
pub mod messages;
pub mod translator;
pub use messages::Messages;
pub use translator::Translator;
pub use translator::translate_commit_type;
pub use translator::translate_changelog_category;

233
src/i18n/translator.rs Normal file
View File

@@ -0,0 +1,233 @@
use crate::config::Language;
pub struct Translator {
language: Language,
keep_types_english: bool,
keep_changelog_types_english: bool,
}
impl Translator {
pub fn new(language: Language, keep_types_english: bool, keep_changelog_types_english: bool) -> Self {
Self {
language,
keep_types_english,
keep_changelog_types_english,
}
}
pub fn translate_commit_type(&self, commit_type: &str) -> String {
if self.keep_types_english {
return commit_type.to_string();
}
match self.language {
Language::English => commit_type.to_string(),
Language::Chinese => self.translate_commit_type_zh(commit_type),
Language::Japanese => self.translate_commit_type_ja(commit_type),
Language::Korean => self.translate_commit_type_ko(commit_type),
Language::Spanish => self.translate_commit_type_es(commit_type),
Language::French => self.translate_commit_type_fr(commit_type),
Language::German => self.translate_commit_type_de(commit_type),
}
}
pub fn translate_changelog_category(&self, category: &str) -> String {
if self.keep_changelog_types_english {
return category.to_string();
}
match self.language {
Language::English => category.to_string(),
Language::Chinese => self.translate_changelog_category_zh(category),
Language::Japanese => self.translate_changelog_category_ja(category),
Language::Korean => self.translate_changelog_category_ko(category),
Language::Spanish => self.translate_changelog_category_es(category),
Language::French => self.translate_changelog_category_fr(category),
Language::German => self.translate_changelog_category_de(category),
}
}
fn translate_commit_type_zh(&self, commit_type: &str) -> String {
match commit_type {
"feat" => "新功能".to_string(),
"fix" => "修复".to_string(),
"docs" => "文档".to_string(),
"style" => "样式".to_string(),
"refactor" => "重构".to_string(),
"perf" => "性能".to_string(),
"test" => "测试".to_string(),
"build" => "构建".to_string(),
"ci" => "CI".to_string(),
"chore" => "杂项".to_string(),
"revert" => "回滚".to_string(),
_ => commit_type.to_string(),
}
}
fn translate_commit_type_ja(&self, commit_type: &str) -> String {
match commit_type {
"feat" => "機能".to_string(),
"fix" => "修正".to_string(),
"docs" => "ドキュメント".to_string(),
"style" => "スタイル".to_string(),
"refactor" => "リファクタリング".to_string(),
"perf" => "パフォーマンス".to_string(),
"test" => "テスト".to_string(),
"build" => "ビルド".to_string(),
"ci" => "CI".to_string(),
"chore" => "雑務".to_string(),
"revert" => "取り消し".to_string(),
_ => commit_type.to_string(),
}
}
fn translate_commit_type_ko(&self, commit_type: &str) -> String {
match commit_type {
"feat" => "기능".to_string(),
"fix" => "버그 수정".to_string(),
"docs" => "문서".to_string(),
"style" => "스타일".to_string(),
"refactor" => "리팩토링".to_string(),
"perf" => "성능".to_string(),
"test" => "테스트".to_string(),
"build" => "빌드".to_string(),
"ci" => "CI".to_string(),
"chore" => "기타".to_string(),
"revert" => "되돌리기".to_string(),
_ => commit_type.to_string(),
}
}
fn translate_commit_type_es(&self, commit_type: &str) -> String {
match commit_type {
"feat" => "nueva función".to_string(),
"fix" => "corrección".to_string(),
"docs" => "documentación".to_string(),
"style" => "estilo".to_string(),
"refactor" => "refactorización".to_string(),
"perf" => "rendimiento".to_string(),
"test" => "pruebas".to_string(),
"build" => "construcción".to_string(),
"ci" => "CI".to_string(),
"chore" => "tareas".to_string(),
"revert" => "revertir".to_string(),
_ => commit_type.to_string(),
}
}
fn translate_commit_type_fr(&self, commit_type: &str) -> String {
match commit_type {
"feat" => "nouvelle fonctionnalité".to_string(),
"fix" => "correction".to_string(),
"docs" => "documentation".to_string(),
"style" => "style".to_string(),
"refactor" => "refactorisation".to_string(),
"perf" => "performance".to_string(),
"test" => "tests".to_string(),
"build" => "construction".to_string(),
"ci" => "CI".to_string(),
"chore" => "tâches".to_string(),
"revert" => "rétablir".to_string(),
_ => commit_type.to_string(),
}
}
fn translate_commit_type_de(&self, commit_type: &str) -> String {
match commit_type {
"feat" => "Neue Funktion".to_string(),
"fix" => "Korrektur".to_string(),
"docs" => "Dokumentation".to_string(),
"style" => "Stil".to_string(),
"refactor" => "Refactoring".to_string(),
"perf" => "Leistung".to_string(),
"test" => "Tests".to_string(),
"build" => "Build".to_string(),
"ci" => "CI".to_string(),
"chore" => "Wartung".to_string(),
"revert" => "Zurücksetzen".to_string(),
_ => commit_type.to_string(),
}
}
fn translate_changelog_category_zh(&self, category: &str) -> String {
match category.to_lowercase().as_str() {
"added" => "新增".to_string(),
"changed" => "更改".to_string(),
"deprecated" => "弃用".to_string(),
"removed" => "移除".to_string(),
"fixed" => "修复".to_string(),
"security" => "安全".to_string(),
_ => category.to_string(),
}
}
fn translate_changelog_category_ja(&self, category: &str) -> String {
match category.to_lowercase().as_str() {
"added" => "追加".to_string(),
"changed" => "変更".to_string(),
"deprecated" => "非推奨".to_string(),
"removed" => "削除".to_string(),
"fixed" => "修正".to_string(),
"security" => "セキュリティ".to_string(),
_ => category.to_string(),
}
}
fn translate_changelog_category_ko(&self, category: &str) -> String {
match category.to_lowercase().as_str() {
"added" => "추가됨".to_string(),
"changed" => "변경됨".to_string(),
"deprecated" => "사용 중단".to_string(),
"removed" => "제거됨".to_string(),
"fixed" => "수정됨".to_string(),
"security" => "보안".to_string(),
_ => category.to_string(),
}
}
fn translate_changelog_category_es(&self, category: &str) -> String {
match category.to_lowercase().as_str() {
"added" => "Agregado".to_string(),
"changed" => "Cambiado".to_string(),
"deprecated" => "Obsoleto".to_string(),
"removed" => "Eliminado".to_string(),
"fixed" => "Corregido".to_string(),
"security" => "Seguridad".to_string(),
_ => category.to_string(),
}
}
fn translate_changelog_category_fr(&self, category: &str) -> String {
match category.to_lowercase().as_str() {
"added" => "Ajouté".to_string(),
"changed" => "Modifié".to_string(),
"deprecated" => "Obsolète".to_string(),
"removed" => "Supprimé".to_string(),
"fixed" => "Corrigé".to_string(),
"security" => "Sécurité".to_string(),
_ => category.to_string(),
}
}
fn translate_changelog_category_de(&self, category: &str) -> String {
match category.to_lowercase().as_str() {
"added" => "Hinzugefügt".to_string(),
"changed" => "Geändert".to_string(),
"deprecated" => "Veraltet".to_string(),
"removed" => "Entfernt".to_string(),
"fixed" => "Behoben".to_string(),
"security" => "Sicherheit".to_string(),
_ => category.to_string(),
}
}
}
pub fn translate_commit_type(commit_type: &str, language: Language, keep_english: bool) -> String {
let translator = Translator::new(language, keep_english, true);
translator.translate_commit_type(commit_type)
}
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)
}

1
src/main.rs
View File

@@ -6,6 +6,7 @@ mod commands;
mod config;
mod generator;
mod git;
mod i18n;
mod llm;
mod utils;