chore: 升级版本至 0.7.0 并启用 regex unicode-perl 特性

- 新增 `--no-generate` 参数，强制使用模板生成而非 AI
- 调整 `--yes` 参数仅跳过交互提示，不改变生成行为
- 统一使用工具函数替代 println 输出

.gitignore

@@ -6,6 +6,7 @@ Cargo.lock
 
 # IDE
 .idea/
+.trae/
 .vscode/
 *.swp
 *.swo
@@ -22,4 +23,9 @@ test_output/
 # Config (for development)
 config.toml
 .claude/
-CLAUDE.md
+.qoder/
+CLAUDE.md
+**/agents/
+adr/
+.scratch/
+CONTEXT.md

AGENTS.md

@@ -0,0 +1,81 @@
+# AGENTS.md
+
+Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+**Important:** Use Chinese for information responses and thinking; use English for searching and querying.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+---
+
+**These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.
+
+## Agent skills
+
+### Issue tracker
+
+Issues and specs live as local markdown files under `.scratch/`. See `docs/agents/issue-tracker.md`.
+
+### Triage labels
+
+The five canonical triage roles use their default label strings. See `docs/agents/triage-labels.md`.
+
+### Domain docs
+
+Single-context repo with `CONTEXT.md` and `docs/adr/` at the root. See `docs/agents/domain.md`.

CHANGELOG.md

@@ -9,6 +9,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 暂无。
 
+## [0.6.1] - 2026-08-18
+
+### 🔧 其他变更
+- 依赖瘦身：移除未使用的直接依赖 `config`、`handlebars`、`shell-words`、`walkdir`、`console`、`lazy_static`、`atty`，crate 总数由 341 降至 296，release 二进制体积由 7.38 MB 降至 7.00 MB（-5.2%）
+- `lazy_static!` 宏替换为标准库 `LazyLock`；`atty` 替换为标准库 `std::io::IsTerminal`
+- `tokio` 特性由 `full` 精简为 `macros` + `rt-multi-thread`
+- `regex` 关闭默认 unicode 特性（保留 `std` + `perf`），行为变化：`\s`/`\d`/`\w` 字符类仅匹配 ASCII，对提交信息、版本号、邮箱、GPG Key ID 校验无实质影响
+
+## [0.6.0] - 2026-08-17
+
+### ✨ 新功能
+- LLM 层整体迁移至 rig-core 0.41：六家 provider（Ollama / OpenAI / Anthropic / Kimi / DeepSeek / OpenRouter）统一由 rig 原生客户端驱动，删除约 2100 行手写 HTTP/SSE/重试代码
+- 新 LLM 门面（`src/llm/rig/`）：provider 枚举 + 单一生成入口 + 凭据校验（rig VerifyClient）+ 错误映射层；提示词与提交解析拆分至独立模块
+- Anthropic 支持自定义 `base_url`（此前被静默忽略，本次修复）
+- 新增基于 rig mock 后端的 LLM 层离线测试（请求形状、流式事件、错误映射），并附 6 家 provider 的 `#[ignore]` 实网冒烟用例
+
+### 🐞 错误修复
+- 各 provider 超时统一由 `llm.timeout` 配置控制（此前默认超时 60/120/300 秒不一致）
+- 消除 Ollama 客户端构造时的 panic（`expect` 式构造）
+
+### 🔧 其他变更（行为变化）
+- Ollama 请求端点由 `/api/generate` 改为 `/api/chat`（功能等价；自定义 Ollama 代理需兼容 chat 端点）
+- 非流式请求不再做应用层重试（此前按错误文案字符串匹配重试 3 次）；流式请求由 rig 的 SSE 机制自动重连
+- 可用性校验端点变化：DeepSeek 改为 `/user/balance`、OpenRouter 改为 `/key`、Anthropic 改为 `/v1/models`（对外表现为 `LLM provider 'xxx' is not available` 语义不变）
+- 依赖瘦身：移除 `reqwest`(0.12) 与 `async-trait` 直接依赖，不引入 rig agent/fastembed/lancedb 等组件
+
+## [0.5.0] - 2026-07-24
+
+### ✨ 新功能
+- `commit` 命令新增 `.gitignore` 文件过滤：自动暂存与 `--all` 模式下自动跳过被 `.gitignore` 规则匹配的文件，并清理索引中已被忽略的已跟踪文件，暂存完成后列出被移除的文件
+- `tag` 命令新增 `-A, --auto` 模式：优先从 `Cargo.toml`/`pyproject.toml` 读取项目版本，回退到基于 commit 的语义化升级分析（与 `--bump` 互斥）
+- `changelog` 命令在未指定 `--from` 时，自动检测现有 changelog 中最高版本对应的 tag 作为起始点
+- 新增 `parse_changelog_versions()`，按 semver 降序提取 changelog 中已有的版本
+- 新增 `sort_tags_by_semver()`，取代纯时间排序，按语义版本正确排序标签
+
+### 🐞 错误修复
+- 修复 `get_tags()` 对 annotated tag 的解析：改用 `find_object`+`peel_to_commit` 正确取得标签指向的 commit
+- 修复 `changelog` 写入时 `insert_changelog_entry` 覆盖已有章节的问题，现保留现有内容并按版本插入新条目
+
+### 📚 文档
+- 同步更新 README（中/英文）：补充 `--think`、`tag --auto` 选项说明，移除已废弃的 `--prepend` 参数，修正 `set-llm` 的 `--base-url` 选项名
+
+### 🔧 其他变更
+- 新增 `TagInfo::version_name()` 与 `GitRepo::find_tag_by_version()` 辅助方法
+- 新增 `tests/gitignore_tests.rs`，包含 7 个测试覆盖 `.gitignore` 过滤逻辑
+
 ## [0.4.0] - 2026-07-16
 
 ### ✨ 新功能

Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "quicommit"
-version = "0.4.0"
+version = "0.7.0"
 edition = "2024"
 authors = ["Sidney Zhang <zly@lyzhang.me>"]
-description = "A powerful Git assistant tool with AI-powered commit/tag/changelog generation(alpha version)"
+description = "A powerful Git assistant tool with AI-powered commit/tag/changelog generation"
 license = "MIT"
 repository = "https://git.lyz.one/SidneyZhang/QuiCommit"
 keywords = ["git", "commit", "ai", "cli", "automation"]
@@ -19,11 +19,9 @@ path = "src/main.rs"
 clap = { version = "4.5", features = ["derive", "env", "wrap_help"] }
 clap_complete = "4.5"
 dialoguer = "0.11"
-console = "0.15"
 indicatif = "0.17"
 
 # Configuration management
-config = "0.14"
 serde = { version = "1.0", features = ["derive"] }
 toml = "0.8"
 dirs = "5.0"
@@ -32,9 +30,7 @@ dirs = "5.0"
 git2 = "0.20.3"
 which = "6.0"
 
-# HTTP client for LLM APIs
+tokio = { version = "1.35", features = ["macros", "rt-multi-thread"] }
-reqwest = { version = "0.12", features = ["json", "rustls-tls", "stream"], default-features = false }
-tokio = { version = "1.35", features = ["full"] }
 
 # Error handling
 thiserror = "1.0"
@@ -46,20 +42,16 @@ tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt"] }
 
 # Utilities
 chrono = { version = "0.4", features = ["serde"] }
-regex = "1.10"
+regex = { version = "1.10", default-features = false, features = ["std", "perf", "unicode-perl"] }
-lazy_static = "1.4"
+roxmltree = "0.20"
 colored = "2.1"
-handlebars = "5.1"
 semver = "1.0"
-walkdir = "2.4"
 tempfile = "3.9"
 sha2 = "0.10"
 hex = "0.4"
 textwrap = "0.16"
-async-trait = "0.1"
 futures-util = "0.3"
 serde_json = "1.0"
-atty = "0.2"
 
 # Encryption for sensitive data (SSH keys, GPG, etc.)
 aes-gcm = "0.10"
@@ -73,8 +65,8 @@ keyring = { version = "3.6.3", features = ["apple-native", "windows-native", "sy
 # Interactive editor
 edit = "0.1"
 
-# Shell completion generation
+# LLM integration (rig-core only: HTTP backend + rustls; no agent/derive)
-shell-words = "1.1"
+rig-core = { version = "0.41", default-features = false, features = ["reqwest", "rustls"] }
 
 [dev-dependencies]
 assert_cmd = "2.0"
@@ -82,6 +74,9 @@ predicates = "3.1"
 tempfile = "3.9"
 mockall = "0.12"
 wiremock = "0.6"
+# rig mock HTTP backends for LLM layer tests
+rig-core = { version = "0.41", default-features = false, features = ["test-utils"] }
+http = "1"
 
 [profile.release]
 opt-level = "s"

README.md

@@ -18,7 +18,7 @@ A powerful AI-powered Git assistant for generating conventional commits, tags, a
 - **AI-Powered Generation**: Generate commits, tags, and changelogs using LLM APIs (Ollama, OpenAI, Anthropic, Kimi, DeepSeek, OpenRouter) or local models
 - **Conventional Commits**: Full support for Conventional Commits and commitlint formats
 - **Profile Management**: Manage multiple Git identities with SSH keys and GPG signing support
-- **Smart Tagging**: Semantic version bumping with AI-generated release notes
+- **Smart Tagging**: Semantic version bumping with AI-generated release notes; auto-detects version from 16+ project config files (Cargo.toml, package.json, pom.xml, pubspec.yaml, etc.)
 - **Changelog Generation**: Automatic changelog generation in Keep a Changelog format
 - **Security**: Use system keyring to store API keys securely
 - **Interactive UI**: Beautiful CLI with previews and confirmations
@@ -63,7 +63,7 @@ quicommit commit
 # Manual commit
 quicommit commit --manual -t feat -m "add new feature"
 
-# Stage all and commit
+# Stage all and commit (skips .gitignore-matched files automatically)
 quicommit commit -a
 
 # Skip confirmation
@@ -72,16 +72,25 @@ quicommit commit --yes
 # Use date-based commit message
 quicommit commit --date
 
+# Enable LLM thinking/reasoning mode for this commit
+quicommit commit --think
+
 # Push after committing
 quicommit commit --push
 ```
 
+When staging changes (auto-stage or `--all`), files matched by `.gitignore` rules are skipped and any ignored files already in the index are removed; the skipped list is printed for review.
+
 ### Create Tag
 
 ```bash
 # Auto-detect version bump
 quicommit tag
 
+# Auto-detect version from project config files (Cargo.toml, package.json, pom.xml, etc.),
+# fall back to commit analysis
+quicommit tag --auto
+
 # Specify bump type
 quicommit tag --bump minor
 
@@ -98,11 +107,14 @@ quicommit tag --push
 ### Generate Changelog
 
 ```bash
-# Generate for unreleased changes
+# Generate for unreleased changes (auto-detects --from from the highest version in the existing changelog)
 quicommit changelog
 
 # Generate for specific version
-quicommit changelog -v 1.0.0
+quicommit changelog --version 1.0.0
+
+# Generate from a specific tag
+quicommit changelog --from v0.9.0
 
 # AI-generate changelog
 quicommit changelog --generate
@@ -222,7 +234,11 @@ quicommit profile token
 ```bash
 # Configure Ollama (local)
 quicommit config set-llm ollama
-quicommit config set-llm ollama --url http://localhost:11434 --model llama2
+quicommit config set-llm ollama --base-url http://localhost:11434 --model llama2
+
+> ⚠️ **Security note**: passing your API key as a CLI argument puts it in your shell
+> history and process list. Prefer running `quicommit config set-api-key` (or
+> `config set-llm`) without the key to enter it via a hidden prompt instead.
 
 # Configure OpenAI
 quicommit config set-llm openai
@@ -309,14 +325,15 @@ quicommit config reset --force
 | `-b, --breaking` | Mark as breaking change |
 | `-d, --date` | Use date-based commit message |
 | `--manual` | Manual input, skip AI |
-| `-a, --all` | Stage all changes |
+| `-a, --all` | Stage all changes (skips `.gitignore`-matched files) |
 | `-S, --sign` | GPG sign commit |
 | `--amend` | Amend previous commit |
 | `--dry-run` | Show without committing |
 | `--conventional` | Use Conventional Commits format |
 | `--commitlint` | Use commitlint format |
 | `--no-verify` | Skip commit message verification |
-| `-y, --yes` | Skip confirmation |
+| `-t, --think` | Enable LLM thinking/reasoning mode (overrides config) |
+| `-y, --yes` | Skip confirmation prompts only (generation behavior unchanged) |
 | `--push` | Push after committing |
 | `--remote` | Specify remote repository (default: origin) |
 
@@ -326,6 +343,7 @@ quicommit config reset --force
 |--------|-------------|
 | `-n, --name` | Tag name |
 | `-b, --bump` | Version bump (major/minor/patch) |
+| `-A, --auto` | Auto-detect version from project config files (Cargo.toml, package.json, pom.xml, etc.), fall back to commit analysis (conflicts with `--bump`) |
 | `-m, --message` | Tag message |
 | `-g, --generate` | AI-generate message |
 | `-S, --sign` | GPG sign tag |
@@ -334,24 +352,26 @@ quicommit config reset --force
 | `-p, --push` | Push to remote |
 | `-r, --remote` | Specify remote repository (default: origin) |
 | `--dry-run` | Dry run |
-| `-y, --yes` | Skip confirmation |
+| `-t, --think` | Enable LLM thinking/reasoning mode (overrides config) |
+| `-y, --yes` | Skip confirmation prompts only (generation behavior unchanged) |
 
 ### Changelog Options
 
 | Option | Description |
 |--------|-------------|
 | `-o, --output` | Output file path |
-| `-v, --version` | Generate for specific version |
+| `--version` | Generate for specific version |
-| `-f, --from` | Generate from specific tag |
+| `-f, --from` | Generate from specific tag (auto-detected from existing changelog if omitted) |
 | `-t, --to` | Generate to specific ref (default: HEAD) |
 | `-i, --init` | Initialize new changelog file |
 | `-g, --generate` | AI-generate changelog |
-| `--prepend` | Prepend to existing changelog |
 | `--include-hashes` | Include commit hashes |
 | `--include-authors` | Include authors |
 | `--format` | Format (keep-a-changelog, github-releases) |
 | `--dry-run` | Dry run (output to stdout) |
-| `-y, --yes` | Skip confirmation |
+| `--think` | Enable LLM thinking/reasoning mode (overrides config) |
+| `--no-generate` | Generate deterministically from template (no AI call) |
+| `-y, --yes` | Skip confirmation prompts only (generation behavior unchanged) |
 
 ## Configuration File
 
@@ -410,6 +430,9 @@ auto_generate = true
 path = "CHANGELOG.md"
 auto_generate = true
 
+[output]
+emoji = true
+
 [repo_profiles]
 "/path/to/work/project" = "work"
 "/path/to/personal/project" = "personal"
@@ -421,7 +444,15 @@ auto_generate = true
 |----------|-------------|
 | `QUICOMMIT_CONFIG` | Configuration file path |
 | `EDITOR` | Default editor |
-| `NO_COLOR` | Disable colored output |
+| `NO_COLOR` | Disable colored output and emoji decorations (any value) |
+| `RUST_LOG` | Overrides `-v` log filtering (e.g. `debug`) |
+
+## Global Options
+
+- `-v, --verbose` (repeatable): `-v` shows info logs, `-vv` debug, `-vvv` trace.
+- `--no-color`: disable colors **and** emoji decorations (highest priority).
+- `--emoji` / `--no-emoji`: force emoji decorations on/off, overriding the `output.emoji` config value.
+- Emoji decorations can also be configured via `config set output.emoji true|false`.
 
 ## Troubleshooting
 
@@ -438,7 +469,7 @@ quicommit config set llm.provider ollama
 # Get configuration value
 quicommit config get llm.provider
 
-# Set API key (stored in system keyring)
+# Set API key (stored in system keyring; omit the value for hidden prompt input)
 quicommit config set-api-key YOUR_API_KEY
 
 # Delete API key from keyring
@@ -527,13 +558,12 @@ src/
 │   ├── commit.rs
 │   ├── tag.rs
 │   └── changelog.rs
-├── llm/         # LLM provider implementations
+├── llm/         # LLM integration (rig-core based)
-│   ├── ollama.rs
+│   ├── mod.rs
-│   ├── openai.rs
+│   ├── prompts.rs
-│   ├── anthropic.rs
+│   ├── parsing.rs
-│   ├── kimi.rs
+│   ├── thinking.rs
-│   ├── deepseek.rs
+│   └── rig/      # rig provider facade
-│   └── openrouter.rs
 ├── i18n/        # Internationalization support
 │   ├── messages.rs
 │   └── translator.rs

readme_zh.md

@@ -17,7 +17,7 @@
 - **AI智能生成**：使用LLM API（Ollama本地、OpenAI、Anthropic Claude、Kimi、DeepSeek、OpenRouter）生成提交信息、标签和变更日志
 - **规范化提交**：支持Conventional Commits和commitlint格式规范
 - **多配置管理**：为不同场景管理多个Git身份，支持SSH密钥和GPG签名配置
-- **智能标签管理**：基于语义版本自动检测升级，AI生成标签信息
+- **智能标签管理**：基于语义版本自动检测升级，AI生成标签信息；支持从 16+ 种项目配置文件（Cargo.toml、package.json、pom.xml、pubspec.yaml 等）自动读取版本
 - **变更日志生成**：自动生成Keep a Changelog格式的变更日志
 - **安全保护**：使用系统密钥环进行安全存储
 - **交互式界面**：美观的CLI界面，支持预览和确认
@@ -62,7 +62,7 @@ quicommit commit
 # 手动提交
 quicommit commit --manual -t feat -m "添加新功能"
 
-# 暂存所有文件并提交
+# 暂存所有文件并提交（自动跳过 .gitignore 匹配的文件）
 quicommit commit -a
 
 # 跳过确认直接提交
@@ -71,16 +71,25 @@ quicommit commit --yes
 # 使用日期格式的提交信息
 quicommit commit --date
 
+# 为本次提交启用 LLM 思考/推理模式
+quicommit commit --think
+
 # 提交后推送到远程
 quicommit commit --push
 ```
 
+在暂存更改时（自动暂存或 `--all` 模式），会自动跳过匹配 `.gitignore` 规则的文件，并清理索引中已被忽略的已跟踪文件，最后打印出被跳过的文件列表。
+
 ### 创建标签
 
 ```bash
 # 自动检测版本升级
 quicommit tag
 
+# 从项目配置文件（Cargo.toml、package.json、pom.xml 等）自动检测版本，
+# 回退到基于 commit 的分析
+quicommit tag --auto
+
 # 指定版本升级类型
 quicommit tag --bump minor
 
@@ -97,11 +106,14 @@ quicommit tag --push
 ### 生成变更日志
 
 ```bash
-# 生成未发布变更的变更日志
+# 生成未发布变更的变更日志（未指定 --from 时自动从现有 changelog 的最高版本检测）
 quicommit changelog
 
 # 为特定版本生成
-quicommit changelog -v 1.0.0
+quicommit changelog --version 1.0.0
+
+# 从指定标签生成
+quicommit changelog --from v0.9.0
 
 # AI生成变更日志
 quicommit changelog --generate
@@ -216,7 +228,11 @@ quicommit profile token
 ```bash
 # 配置Ollama（本地）
 quicommit config set-llm ollama
-quicommit config set-llm ollama --url http://localhost:11434 --model llama2
+quicommit config set-llm ollama --base-url http://localhost:11434 --model llama2
+
+> ⚠️ **安全提示**：把 API 密钥作为命令行参数传入会留在 shell history 与进程列表中。
+> 建议直接运行 `quicommit config set-api-key`（或 `config set-llm`）不携带密钥，
+> 以隐藏方式输入。
 
 # 配置OpenAI
 quicommit config set-llm openai
@@ -303,14 +319,15 @@ quicommit config reset --force
 | `-b, --breaking` | 标记为破坏性变更 |
 | `-d, --date` | 使用日期格式的提交信息 |
 | `--manual` | 手动输入，跳过AI生成 |
-| `-a, --all` | 暂存所有更改 |
+| `-a, --all` | 暂存所有更改（自动跳过 `.gitignore` 匹配的文件） |
 | `-S, --sign` | GPG签名提交 |
 | `--amend` | 修改上一次提交 |
 | `--dry-run` | 试运行，不实际提交 |
 | `--conventional` | 使用Conventional Commits格式 |
 | `--commitlint` | 使用commitlint格式 |
 | `--no-verify` | 不验证提交信息 |
-| `-y, --yes` | 跳过确认提示 |
+| `-t, --think` | 启用 LLM 思考/推理模式（覆盖配置） |
+| `-y, --yes` | 仅跳过确认提示（生成行为不变） |
 | `--push` | 提交后推送到远程 |
 | `--remote` | 指定远程仓库（默认：origin） |
 
@@ -320,6 +337,7 @@ quicommit config reset --force
 |------|------|
 | `-n, --name` | 标签名称 |
 | `-b, --bump` | 版本升级类型（major/minor/patch） |
+| `-A, --auto` | 从项目配置文件（Cargo.toml、package.json、pom.xml 等 16+ 种）自动检测版本，回退到基于 commit 的分析（与 `--bump` 互斥） |
 | `-m, --message` | 标签信息 |
 | `-g, --generate` | AI生成标签信息 |
 | `-S, --sign` | GPG签名标签 |
@@ -328,24 +346,26 @@ quicommit config reset --force
 | `-p, --push` | 推送到远程 |
 | `-r, --remote` | 指定远程仓库（默认：origin） |
 | `--dry-run` | 试运行 |
-| `-y, --yes` | 跳过确认提示 |
+| `-t, --think` | 启用 LLM 思考/推理模式（覆盖配置） |
+| `-y, --yes` | 仅跳过确认提示（生成行为不变） |
 
 ### changelog命令选项
 
 | 选项 | 说明 |
 |------|------|
 | `-o, --output` | 输出文件路径 |
-| `-v, --version` | 为特定版本生成 |
+| `--version` | 为特定版本生成 |
-| `-f, --from` | 从指定标签生成 |
+| `-f, --from` | 从指定标签生成（未指定时自动从现有 changelog 的最高版本检测） |
 | `-t, --to` | 生成到指定引用（默认：HEAD） |
 | `-i, --init` | 初始化新的变更日志文件 |
 | `-g, --generate` | AI生成变更日志 |
-| `--prepend` | 添加到现有变更日志开头 |
 | `--include-hashes` | 包含提交哈希 |
 | `--include-authors` | 包含作者信息 |
 | `--format` | 格式（keep-a-changelog、github-releases） |
 | `--dry-run` | 试运行（输出到stdout） |
-| `-y, --yes` | 跳过确认提示 |
+| `--think` | 启用 LLM 思考/推理模式（覆盖配置） |
+| `--no-generate` | 使用模板确定性生成（不调用 AI） |
+| `-y, --yes` | 仅跳过确认提示（生成行为不变） |
 
 ## 配置文件
 
@@ -404,6 +424,9 @@ auto_generate = true
 path = "CHANGELOG.md"
 auto_generate = true
 
+[output]
+emoji = true
+
 [repo_profiles]
 "/path/to/work/project" = "work"
 "/path/to/personal/project" = "personal"
@@ -415,7 +438,15 @@ auto_generate = true
 |--------|------|
 | `QUICOMMIT_CONFIG` | 配置文件路径 |
 | `EDITOR` | 默认编辑器 |
-| `NO_COLOR` | 禁用彩色输出 |
+| `NO_COLOR` | 禁用彩色与 Emoji 装饰输出（任意值即生效） |
+| `RUST_LOG` | 覆盖 `-v` 的日志过滤（例如 `debug`） |
+
+## 全局选项
+
+- `-v, --verbose`（可叠加）：`-v` 显示 info 日志、`-vv` debug、`-vvv` trace。
+- `--no-color`：禁用彩色**与** Emoji 装饰（最高优先级）。
+- `--emoji` / `--no-emoji`：强制开启/关闭 Emoji 装饰，覆盖 `output.emoji` 配置。
+- Emoji 装饰也可通过 `quicommit config set output.emoji true|false` 配置。
 
 ## 故障排除
 
@@ -432,7 +463,7 @@ quicommit config set llm.provider ollama
 # 获取配置值
 quicommit config get llm.provider
 
-# 设置API密钥（存储在系统密钥环中）
+# 设置API密钥（存储在系统密钥环中；省略密钥值可通过隐藏提示输入）
 quicommit config set-api-key YOUR_API_KEY
 
 # 从密钥环删除API密钥
@@ -521,13 +552,12 @@ src/
 │   ├── commit.rs
 │   ├── tag.rs
 │   └── changelog.rs
-├── llm/         # LLM提供商实现
+├── llm/         # LLM 集成（基于 rig-core）
-│   ├── ollama.rs
+│   ├── mod.rs
-│   ├── openai.rs
+│   ├── prompts.rs
-│   ├── anthropic.rs
+│   ├── parsing.rs
-│   ├── kimi.rs
+│   ├── thinking.rs
-│   ├── deepseek.rs
+│   └── rig/      # rig provider 门面
-│   └── openrouter.rs
 ├── i18n/        # 国际化支持
 │   ├── messages.rs
 │   └── translator.rs

src/commands/changelog.rs

@@ -7,9 +7,11 @@ use std::path::PathBuf;
 
 use crate::config::{Language, manager::ConfigManager};
 use crate::generator::ContentGenerator;
+use crate::git::GitRepo;
 use crate::git::find_repo;
 use crate::git::{CommitInfo, changelog::*};
 use crate::i18n::{Messages, translate_changelog_category};
+use crate::utils::{print_progress, print_success, print_warning};
 
 /// Generate changelog
 #[derive(Parser)]
@@ -59,7 +61,11 @@ pub struct ChangelogCommand {
     #[arg(long)]
     think: bool,
 
-    /// Skip interactive prompts
+    /// Generate deterministically from template (no AI call)
+    #[arg(long, conflicts_with = "generate")]
+    no_generate: bool,
+
+    /// Skip interactive prompts only (generation behavior unchanged)
     #[arg(short = 'y', long)]
     yes: bool,
 }
@@ -84,7 +90,7 @@ impl ChangelogCommand {
                 .unwrap_or_else(|| PathBuf::from(&config.changelog.path));
 
             init_changelog(&path)?;
-            println!("{}", messages.initialized_changelog(&format!("{:?}", path)));
+            print_success(&messages.initialized_changelog(&path.display().to_string()));
             return Ok(());
         }
 
@@ -100,10 +106,7 @@ impl ChangelogCommand {
             Some("keep") | Some("keep-a-changelog") => ChangelogFormat::KeepAChangelog,
             Some("custom") => ChangelogFormat::Custom,
             None => ChangelogFormat::KeepAChangelog,
-            Some(f) => bail!(
+            Some(f) => bail!("{}", messages.unknown_changelog_format(f)),
-                "Unknown format: {}. Use: keep-a-changelog, github-releases",
-                f
-            ),
         };
 
         // Get version
@@ -119,17 +122,20 @@ impl ChangelogCommand {
         };
 
         // Get commits
-        println!("{}", messages.fetching_commits());
+        print_progress(messages.fetching_commits());
-        let commits = generate_from_history(&repo, self.from.as_deref(), Some(&self.to))?;
+
+        // Determine from_tag: use explicit --from, or auto-detect from changelog
+        let from_tag = self.resolve_from_tag(&repo, &output_path, &messages);
+        let commits = generate_from_history(&repo, from_tag.as_deref(), Some(&self.to))?;
 
         if commits.is_empty() {
             bail!("{}", messages.no_commits_found());
         }
 
-        println!("{}", messages.found_commits(commits.len()));
+        print_success(&messages.found_commits(commits.len()));
 
         // Generate changelog
-        let changelog = if self.generate || (config.changelog.auto_generate && !self.yes) {
+        let changelog = if self.generate || (config.changelog.auto_generate && !self.no_generate) {
             self.generate_with_ai(&version, &commits, &messages).await?
         } else {
             self.generate_with_template(format, &version, &commits, language)?
@@ -157,43 +163,23 @@ impl ChangelogCommand {
             println!("{}", "─".repeat(60));
 
             let confirm = Confirm::new()
-                .with_prompt(messages.write_to_file(&format!("{:?}", output_path)))
+                .with_prompt(messages.write_to_file(&output_path.display().to_string()))
                 .default(true)
                 .interact()?;
 
             if !confirm {
-                println!("{}", messages.cancelled().yellow());
+                print_warning(messages.cancelled());
                 return Ok(());
             }
         }
 
-        // Write to file (always prepend to preserve history)
+        // Write to file (always prepend new entry before existing versions)
         if output_path.exists() {
             let existing = std::fs::read_to_string(&output_path)?;
             let new_content = if existing.is_empty() {
                 format!("{}{}", CHANGELOG_HEADER, changelog)
-            } else if existing.starts_with(CHANGELOG_HEADER) {
-                format!("{}{}", CHANGELOG_HEADER, changelog)
-            } else if existing.starts_with("# Changelog") {
-                let lines: Vec<&str> = existing.lines().collect();
-                let mut header_end = 0;
-
-                for (i, line) in lines.iter().enumerate() {
-                    if i == 0 && line.starts_with('#') {
-                        header_end = i + 1;
-                    } else if line.trim().is_empty() {
-                        header_end = i + 1;
-                    } else {
-                        break;
-                    }
-                }
-
-                let header = lines[..header_end].join("\n");
-                let rest = lines[header_end..].join("\n");
-
-                format!("{}\n{}\n{}", header, changelog, rest)
             } else {
-                format!("{}{}", CHANGELOG_HEADER, changelog)
+                insert_changelog_entry(&existing, &changelog)
             };
             std::fs::write(&output_path, new_content)?;
         } else {
@@ -201,11 +187,37 @@ impl ChangelogCommand {
             std::fs::write(&output_path, content)?;
         }
 
-        println!("{} {:?}", messages.changelog_written(), output_path);
+        print_success(&format!(
+            "{} {}",
+            messages.changelog_written(),
+            output_path.display()
+        ));
 
         Ok(())
     }
 
+    fn resolve_from_tag(
+        &self,
+        repo: &GitRepo,
+        output_path: &PathBuf,
+        messages: &Messages,
+    ) -> Option<String> {
+        // Explicit --from always wins
+        if self.from.is_some() {
+            return self.from.clone();
+        }
+
+        // Auto-detect: find highest version already in changelog
+        let existing = std::fs::read_to_string(output_path).ok()?;
+        let versions = parse_changelog_versions(&existing);
+        let highest = versions.first()?;
+
+        // Match highest version to a git tag
+        let tag = repo.find_tag_by_version(highest)?;
+        println!("  {}: {}", messages.version(), tag.name);
+        Some(tag.name)
+    }
+
     async fn generate_with_ai(
         &self,
         version: &str,
@@ -215,12 +227,13 @@ impl ChangelogCommand {
         let manager = ConfigManager::new()?;
         let language = manager.get_language().unwrap_or(Language::English);
 
-        println!("{}", messages.ai_generating_changelog());
-
         let generator = ContentGenerator::new_with_think(&manager, self.think, None).await?;
-        generator
+        let spinner = crate::utils::Spinner::start(messages.ai_generating_changelog());
+        let result = generator
             .generate_changelog_entry(version, commits, language)
-            .await
+            .await;
+        spinner.finish_clear();
+        result
     }
 
     fn generate_with_template(

src/commands/commit.rs

@@ -11,6 +11,7 @@ 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;
+use crate::utils::{print_progress, print_success, print_warning};
 
 /// Generate and execute conventional commits
 #[derive(Parser)]
@@ -75,7 +76,7 @@ pub struct CommitCommand {
     #[arg(short = 't', long)]
     think: bool,
 
-    /// Skip interactive prompts
+    /// Skip interactive prompts only (generation behavior unchanged)
     #[arg(short = 'y', long)]
     yes: bool,
 
@@ -121,20 +122,38 @@ impl CommitCommand {
         // Auto-add if no files are staged and there are unstaged/untracked changes
         if status.staged == 0 && (status.unstaged > 0 || status.untracked > 0) && !self.all {
             println!("{}", messages.auto_stage_changes().yellow());
-            repo.stage_all()?;
+            let removed = repo.stage_all(&messages)?;
             println!("{}", messages.staged_all().green());
+            if !removed.is_empty() {
+                print_warning(&format!(
+                    "Removed {} ignored files from staging:",
+                    removed.len()
+                ));
+                for file in &removed {
+                    println!("  • {}", file);
+                }
+            }
 
             // Re-check status after staging to ensure changes are detected
             let new_status = repo.status_summary()?;
             if new_status.staged == 0 {
-                bail!("Failed to stage changes. Please try running 'git add -A' manually.");
+                bail!("{}", messages.failed_to_stage());
             }
         }
 
         // Stage all if requested
         if self.all {
-            repo.stage_all()?;
+            let removed = repo.stage_all(&messages)?;
             println!("{}", messages.staged_all().green());
+            if !removed.is_empty() {
+                print_warning(&format!(
+                    "Removed {} ignored files from staging:",
+                    removed.len()
+                ));
+                for file in &removed {
+                    println!("  • {}", file);
+                }
+            }
         }
 
         // Generate or build commit message
@@ -176,29 +195,21 @@ impl CommitCommand {
                 .interact()?;
 
             if !confirm {
-                println!("{}", messages.commit_cancelled().yellow());
+                print_warning(messages.commit_cancelled());
                 return Ok(());
             }
         }
 
         let result = if self.amend {
             if self.dry_run {
-                println!(
+                println!("\n{}", messages.dry_run_commit_not_amended().yellow());
-                    "\n{} {}",
-                    messages.dry_run(),
-                    "- commit not amended.".yellow()
-                );
                 return Ok(());
             }
             self.amend_commit(&repo, &commit_message)?;
             None
         } else {
             if self.dry_run {
-                println!(
+                println!("\n{}", messages.dry_run_commit_not_created().yellow());
-                    "\n{} {}",
-                    messages.dry_run(),
-                    "- commit not created.".yellow()
-                );
                 return Ok(());
             }
             CommitBuilder::new()
@@ -208,30 +219,34 @@ impl CommitCommand {
         };
 
         if let Some(commit_oid) = result {
-            println!(
+            print_success(&format!(
                 "{} {}",
                 messages.commit_created().green().bold(),
                 commit_oid.to_string()[..8].to_string().cyan()
-            );
+            ));
         } else {
-            println!("{} successfully", messages.commit_amended().green().bold());
+            print_success(messages.commit_amended_successfully());
         }
 
         // Push after commit if requested or ask user
-        if self.push {
+        if self.push || (!self.yes && !self.dry_run) {
-            println!("\n{}", messages.pushing_commit(&self.remote));
+            let branch = repo
-            repo.push(&self.remote, "HEAD")?;
+                .current_branch()
-            println!("{}", messages.pushed_commit(&self.remote));
+                .unwrap_or_else(|_| "HEAD (detached)".to_string());
-        } else if !self.yes && !self.dry_run {
+
-            let should_push = Confirm::new()
+            let should_push = if self.push {
-                .with_prompt(messages.push_after_commit())
+                true
-                .default(false)
+            } else {
-                .interact()?;
+                Confirm::new()
+                    .with_prompt(messages.push_after_commit(&branch))
+                    .default(false)
+                    .interact()?
+            };
 
             if should_push {
-                println!("\n{}", messages.pushing_commit(&self.remote));
+                print_progress(&messages.pushing_commit(&self.remote, &branch));
                 repo.push(&self.remote, "HEAD")?;
-                println!("{}", messages.pushed_commit(&self.remote));
+                print_success(&messages.pushed_commit(&self.remote, &branch));
             }
         }
 
@@ -288,21 +303,22 @@ impl CommitCommand {
             .await
             .context("Failed to initialize LLM. Use --manual for manual commit.")?;
 
-        println!("{}", messages.ai_analyzing());
+        let spinner = crate::utils::Spinner::start(messages.ai_analyzing());
 
         let language = manager.get_language().unwrap_or(Language::English);
 
         let generated = if self.yes {
             generator
                 .generate_commit_from_repo(repo, format, language)
-                .await?
+                .await
         } else {
             generator
-                .generate_commit_interactive(repo, format, language)
+                .generate_commit_interactive(repo, format, language, messages)
-                .await?
+                .await
         };
+        spinner.finish_clear();
 
-        Ok(generated.to_conventional())
+        Ok(generated?.to_conventional())
     }
 
     async fn create_interactive_commit(

src/commands/credential.rs

@@ -1,458 +1,457 @@
-use anyhow::{Context, Result};
+use anyhow::{Context, Result};
-use clap::{Parser, Subcommand};
+use clap::{Parser, Subcommand};
-use std::io::{self, BufRead, Write};
+use std::io::{self, BufRead, Write};
-use std::path::PathBuf;
+use std::path::PathBuf;
-
+
-use crate::config::manager::ConfigManager;
+use crate::config::manager::ConfigManager;
-use crate::config::{TokenConfig, TokenType};
+use crate::config::{TokenConfig, TokenType};
-
+
-/// Git credential helper command.
+/// Git credential helper command.
-///
+///
-/// Implements the git credential helper protocol
+/// Implements the git credential helper protocol
-/// (https://git-scm.com/docs/gitcredentials). Intended to be invoked by git
+/// (https://git-scm.com/docs/gitcredentials). Intended to be invoked by git
-/// via `credential.helper` configuration, not by end users. Hidden from the
+/// via `credential.helper` configuration, not by end users. Hidden from the
-/// main help output.
+/// main help output.
-#[derive(Parser)]
+#[derive(Parser)]
-#[command(hide = true)]
+#[command(hide = true)]
-pub struct CredentialCommand {
+pub struct CredentialCommand {
-    #[command(subcommand)]
+    #[command(subcommand)]
-    command: CredentialSubcommand,
+    command: CredentialSubcommand,
-}
+}
-
+
-#[derive(Subcommand)]
+#[derive(Subcommand)]
-enum CredentialSubcommand {
+enum CredentialSubcommand {
-    /// Read attributes on stdin and output credentials on stdout.
+    /// Read attributes on stdin and output credentials on stdout.
-    #[command(hide = true)]
+    #[command(hide = true)]
-    Get,
+    Get,
-    /// Read attributes (including password) on stdin and store them.
+    /// Read attributes (including password) on stdin and store them.
-    #[command(hide = true)]
+    #[command(hide = true)]
-    Store,
+    Store,
-    /// Read attributes on stdin and erase any matching stored credentials.
+    /// Read attributes on stdin and erase any matching stored credentials.
-    #[command(hide = true)]
+    #[command(hide = true)]
-    Erase,
+    Erase,
-}
+}
-
+
-impl CredentialCommand {
+impl CredentialCommand {
-    pub async fn execute(&self, config_path: Option<PathBuf>) -> Result<()> {
+    pub async fn execute(&self, config_path: Option<PathBuf>) -> Result<()> {
-        match &self.command {
+        match &self.command {
-            CredentialSubcommand::Get => Self::get(config_path),
+            CredentialSubcommand::Get => Self::get(config_path),
-            CredentialSubcommand::Store => Self::store(config_path),
+            CredentialSubcommand::Store => Self::store(config_path),
-            CredentialSubcommand::Erase => Self::erase(config_path),
+            CredentialSubcommand::Erase => Self::erase(config_path),
-        }
+        }
-    }
+    }
-
+
-    fn get_manager(config_path: &Option<PathBuf>) -> Result<ConfigManager> {
+    fn get_manager(config_path: &Option<PathBuf>) -> Result<ConfigManager> {
-        match config_path {
+        match config_path {
-            Some(path) => ConfigManager::with_path(path),
+            Some(path) => ConfigManager::with_path(path),
-            None => ConfigManager::new(),
+            None => ConfigManager::new(),
-        }
+        }
-    }
+    }
-
+
-    /// `git credential get`: look up a PAT for the requested host and emit it
+    /// `git credential get`: look up a PAT for the requested host and emit it
-    /// on stdout following the git credential helper protocol.
+    /// on stdout following the git credential helper protocol.
-    fn get(config_path: Option<PathBuf>) -> Result<()> {
+    fn get(config_path: Option<PathBuf>) -> Result<()> {
-        let attrs = CredentialAttributes::from_stdin()?;
+        let attrs = CredentialAttributes::from_stdin()?;
-
+
-        let host = match attrs.host.as_deref() {
+        let host = match attrs.host.as_deref() {
-            Some(h) if !h.is_empty() => h,
+            Some(h) if !h.is_empty() => h,
-            _ => return Ok(()),
+            _ => return Ok(()),
-        };
+        };
-        let service = host_to_service(host);
+        let service = host_to_service(host);
-
+
-        let manager = match Self::get_manager(&config_path) {
+        let manager = match Self::get_manager(&config_path) {
-            Ok(m) => m,
+            Ok(m) => m,
-            Err(_) => return Ok(()),
+            Err(_) => return Ok(()),
-        };
+        };
-
+
-        let (profile_name, pat) = match find_pat_for_service(&manager, &service) {
+        let (profile_name, pat) = match find_pat_for_service(&manager, &service) {
-            Some(tuple) => tuple,
+            Some(tuple) => tuple,
-            None => return Ok(()),
+            None => return Ok(()),
-        };
+        };
-
+
-        // Prefer a git-supplied username; fall back to the profile's user_name.
+        // Prefer a git-supplied username; fall back to the profile's user_name.
-        let username = attrs.username.clone().or_else(|| {
+        let username = attrs.username.clone().or_else(|| {
-            manager
+            manager
-                .get_profile(&profile_name)
+                .get_profile(&profile_name)
-                .map(|p| p.user_name.clone())
+                .map(|p| p.user_name.clone())
-        });
+        });
-
+
-        let output = CredentialAttributes {
+        let output = CredentialAttributes {
-            protocol: attrs.protocol.clone(),
+            protocol: attrs.protocol.clone(),
-            host: attrs.host.clone(),
+            host: attrs.host.clone(),
-            path: attrs.path.clone(),
+            path: attrs.path.clone(),
-            username,
+            username,
-            password: Some(pat),
+            password: Some(pat),
-        };
+        };
-        output.to_stdout()?;
+        output.to_stdout()?;
-        Ok(())
+        Ok(())
-    }
+    }
-
+
-    /// `git credential store`: persist the PAT provided by git using the
+    /// `git credential store`: persist the PAT provided by git using the
-    /// existing keyring-backed storage, associated with a matching profile.
+    /// existing keyring-backed storage, associated with a matching profile.
-    fn store(config_path: Option<PathBuf>) -> Result<()> {
+    fn store(config_path: Option<PathBuf>) -> Result<()> {
-        let attrs = CredentialAttributes::from_stdin()?;
+        let attrs = CredentialAttributes::from_stdin()?;
-
+
-        let host = match attrs.host.as_deref() {
+        let host = match attrs.host.as_deref() {
-            Some(h) if !h.is_empty() => h,
+            Some(h) if !h.is_empty() => h,
-            _ => return Ok(()),
+            _ => return Ok(()),
-        };
+        };
-        let service = host_to_service(host);
+        let service = host_to_service(host);
-
+
-        let password = match attrs.password.as_deref() {
+        let password = match attrs.password.as_deref() {
-            Some(p) if !p.is_empty() => p,
+            Some(p) if !p.is_empty() => p,
-            _ => return Ok(()),
+            _ => return Ok(()),
-        };
+        };
-
+
-        let mut manager = Self::get_manager(&config_path)?;
+        let mut manager = Self::get_manager(&config_path)?;
-
+
-        let profile_name = match find_profile_for_store(&manager, attrs.username.as_deref()) {
+        let profile_name = match find_profile_for_store(&manager, attrs.username.as_deref()) {
-            Some(name) => name,
+            Some(name) => name,
-            None => return Ok(()),
+            None => return Ok(()),
-        };
+        };
-
+
-        // Store PAT in keyring using the existing profile-bound logic.
+        // Store PAT in keyring using the existing profile-bound logic.
-        if let Err(e) = manager.store_pat_for_profile(&profile_name, &service, password) {
+        if let Err(e) = manager.store_pat_for_profile(&profile_name, &service, password) {
-            eprintln!("[quicommit credential] failed to store PAT: {}", e);
+            eprintln!("[quicommit credential] failed to store PAT: {}", e);
-            return Ok(());
+            return Ok(());
-        }
+        }
-
+
-        // Register the token in the profile config if not already present.
+        // Register the token in the profile config if not already present.
-        let already_has = manager
+        let already_has = manager
-            .get_profile(&profile_name)
+            .get_profile(&profile_name)
-            .map(|p| p.tokens.contains_key(&service))
+            .map(|p| p.tokens.contains_key(&service))
-            .unwrap_or(false);
+            .unwrap_or(false);
-        if !already_has {
+        if !already_has {
-            let _ = manager.add_token_to_profile(
+            let _ = manager.add_token_to_profile(
-                &profile_name,
+                &profile_name,
-                service.clone(),
+                service.clone(),
-                TokenConfig::new(TokenType::Personal),
+                TokenConfig::new(TokenType::Personal),
-            );
+            );
-        }
+        }
-
+
-        manager.save()?;
+        manager.save()?;
-        Ok(())
+        Ok(())
-    }
+    }
-
+
-    /// `git credential erase`: remove any PAT stored for the requested host
+    /// `git credential erase`: remove any PAT stored for the requested host
-    /// from the keyring and the associated profile config entries.
+    /// from the keyring and the associated profile config entries.
-    fn erase(config_path: Option<PathBuf>) -> Result<()> {
+    fn erase(config_path: Option<PathBuf>) -> Result<()> {
-        let attrs = CredentialAttributes::from_stdin()?;
+        let attrs = CredentialAttributes::from_stdin()?;
-
+
-        let host = match attrs.host.as_deref() {
+        let host = match attrs.host.as_deref() {
-            Some(h) if !h.is_empty() => h,
+            Some(h) if !h.is_empty() => h,
-            _ => return Ok(()),
+            _ => return Ok(()),
-        };
+        };
-        let service = host_to_service(host);
+        let service = host_to_service(host);
-
+
-        let mut manager = Self::get_manager(&config_path)?;
+        let mut manager = Self::get_manager(&config_path)?;
-
+
-        let profile_names: Vec<String> = manager
+        let profile_names: Vec<String> = manager.list_profiles().into_iter().cloned().collect();
-            .list_profiles()
+
-            .into_iter()
+        for name in &profile_names {
-            .filter(|name| {
+            let registered = manager
-                manager
+                .get_profile(name)
-                    .get_profile(name)
+                .map(|p| p.tokens.contains_key(&service))
-                    .map(|p| p.tokens.contains_key(&service))
+                .unwrap_or(false);
-                    .unwrap_or(false)
+
-            })
+            if registered {
-            .cloned()
+                if let Err(e) = manager.remove_token_from_profile(name, &service) {
-            .collect();
+                    eprintln!(
-
+                        "[quicommit credential] failed to erase PAT for '{}': {}",
-        for name in &profile_names {
+                        name, e
-            if let Err(e) = manager.remove_token_from_profile(name, &service) {
+                    );
-                eprintln!(
+                }
-                    "[quicommit credential] failed to erase PAT for '{}': {}",
+            } else if let Ok(true) = manager.delete_orphan_pat(name, &service) {
-                    name, e
+                // Keyring PAT without a config token entry (issue 24).
-                );
+                eprintln!(
-            }
+                    "[quicommit credential] erased unregistered PAT for '{}' (service {}) from keyring",
-        }
+                    name, service
-
+                );
-        manager.save()?;
+            }
-        Ok(())
+        }
-    }
+
-}
+        manager.save()?;
-
+        Ok(())
-/// Credential attributes exchanged with git via stdin/stdout following the
+    }
-/// git credential helper protocol (`key=value`, one per line, blank line ends).
+}
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
+
-pub struct CredentialAttributes {
+/// Credential attributes exchanged with git via stdin/stdout following the
-    pub protocol: Option<String>,
+/// git credential helper protocol (`key=value`, one per line, blank line ends).
-    pub host: Option<String>,
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
-    pub path: Option<String>,
+pub struct CredentialAttributes {
-    pub username: Option<String>,
+    pub protocol: Option<String>,
-    pub password: Option<String>,
+    pub host: Option<String>,
-}
+    pub path: Option<String>,
-
+    pub username: Option<String>,
-impl CredentialAttributes {
+    pub password: Option<String>,
-    /// Read attributes from stdin following the git credential helper protocol.
+}
-    pub fn from_stdin() -> Result<Self> {
+
-        let stdin = io::stdin();
+impl CredentialAttributes {
-        let mut attrs = Self::default();
+    /// Read attributes from stdin following the git credential helper protocol.
-        for line in stdin.lock().lines() {
+    pub fn from_stdin() -> Result<Self> {
-            let line =
+        let stdin = io::stdin();
-                line.context("Failed to read credential attributes from stdin")?;
+        let mut attrs = Self::default();
-            if line.is_empty() {
+        for line in stdin.lock().lines() {
-                break;
+            let line = line.context("Failed to read credential attributes from stdin")?;
-            }
+            if line.is_empty() {
-            if let Some((key, value)) = line.split_once('=') {
+                break;
-                match key {
+            }
-                    "protocol" => attrs.protocol = Some(value.to_string()),
+            if let Some((key, value)) = line.split_once('=') {
-                    "host" => attrs.host = Some(value.to_string()),
+                match key {
-                    "path" => attrs.path = Some(value.to_string()),
+                    "protocol" => attrs.protocol = Some(value.to_string()),
-                    "username" => attrs.username = Some(value.to_string()),
+                    "host" => attrs.host = Some(value.to_string()),
-                    "password" => attrs.password = Some(value.to_string()),
+                    "path" => attrs.path = Some(value.to_string()),
-                    _ => {} // ignore unknown keys
+                    "username" => attrs.username = Some(value.to_string()),
-                }
+                    "password" => attrs.password = Some(value.to_string()),
-            }
+                    _ => {} // ignore unknown keys
-        }
+                }
-        Ok(attrs)
+            }
-    }
+        }
-
+        Ok(attrs)
-    /// Write attributes to stdout following the git credential helper protocol.
+    }
-    pub fn to_stdout(&self) -> Result<()> {
+
-        let stdout = io::stdout();
+    /// Write attributes to stdout following the git credential helper protocol.
-        let mut handle = stdout.lock();
+    pub fn to_stdout(&self) -> Result<()> {
-        if let Some(ref v) = self.protocol {
+        let stdout = io::stdout();
-            writeln!(handle, "protocol={}", v)?;
+        let mut handle = stdout.lock();
-        }
+        if let Some(ref v) = self.protocol {
-        if let Some(ref v) = self.host {
+            writeln!(handle, "protocol={}", v)?;
-            writeln!(handle, "host={}", v)?;
+        }
-        }
+        if let Some(ref v) = self.host {
-        if let Some(ref v) = self.path {
+            writeln!(handle, "host={}", v)?;
-            writeln!(handle, "path={}", v)?;
+        }
-        }
+        if let Some(ref v) = self.path {
-        if let Some(ref v) = self.username {
+            writeln!(handle, "path={}", v)?;
-            writeln!(handle, "username={}", v)?;
+        }
-        }
+        if let Some(ref v) = self.username {
-        if let Some(ref v) = self.password {
+            writeln!(handle, "username={}", v)?;
-            writeln!(handle, "password={}", v)?;
+        }
-        }
+        if let Some(ref v) = self.password {
-        writeln!(handle)?; // blank line terminates the attribute list
+            writeln!(handle, "password={}", v)?;
-        handle.flush()?;
+        }
-        Ok(())
+        writeln!(handle)?; // blank line terminates the attribute list
-    }
+        handle.flush()?;
-
+        Ok(())
-    /// Parse attributes from a text block following the git credential helper
+    }
-    /// protocol. Intended for testing and non-stdin input handling.
+
-    pub fn parse_str(input: &str) -> Self {
+    /// Parse attributes from a text block following the git credential helper
-        let mut attrs = Self::default();
+    /// protocol. Intended for testing and non-stdin input handling.
-        for line in input.lines() {
+    pub fn parse_str(input: &str) -> Self {
-            if line.is_empty() {
+        let mut attrs = Self::default();
-                break;
+        for line in input.lines() {
-            }
+            if line.is_empty() {
-            if let Some((key, value)) = line.split_once('=') {
+                break;
-                match key {
+            }
-                    "protocol" => attrs.protocol = Some(value.to_string()),
+            if let Some((key, value)) = line.split_once('=') {
-                    "host" => attrs.host = Some(value.to_string()),
+                match key {
-                    "path" => attrs.path = Some(value.to_string()),
+                    "protocol" => attrs.protocol = Some(value.to_string()),
-                    "username" => attrs.username = Some(value.to_string()),
+                    "host" => attrs.host = Some(value.to_string()),
-                    "password" => attrs.password = Some(value.to_string()),
+                    "path" => attrs.path = Some(value.to_string()),
-                    _ => {}
+                    "username" => attrs.username = Some(value.to_string()),
-                }
+                    "password" => attrs.password = Some(value.to_string()),
-            }
+                    _ => {}
-        }
+                }
-        attrs
+            }
-    }
+        }
-
+        attrs
-    /// Serialize attributes to a string following the git credential helper
+    }
-    /// protocol. Intended for testing and non-stdout output handling.
+
-    pub fn serialize(&self) -> String {
+    /// Serialize attributes to a string following the git credential helper
-        let mut out = String::new();
+    /// protocol. Intended for testing and non-stdout output handling.
-        if let Some(ref v) = self.protocol {
+    pub fn serialize(&self) -> String {
-            out.push_str(&format!("protocol={}\n", v));
+        let mut out = String::new();
-        }
+        if let Some(ref v) = self.protocol {
-        if let Some(ref v) = self.host {
+            out.push_str(&format!("protocol={}\n", v));
-            out.push_str(&format!("host={}\n", v));
+        }
-        }
+        if let Some(ref v) = self.host {
-        if let Some(ref v) = self.path {
+            out.push_str(&format!("host={}\n", v));
-            out.push_str(&format!("path={}\n", v));
+        }
-        }
+        if let Some(ref v) = self.path {
-        if let Some(ref v) = self.username {
+            out.push_str(&format!("path={}\n", v));
-            out.push_str(&format!("username={}\n", v));
+        }
-        }
+        if let Some(ref v) = self.username {
-        if let Some(ref v) = self.password {
+            out.push_str(&format!("username={}\n", v));
-            out.push_str(&format!("password={}\n", v));
+        }
-        }
+        if let Some(ref v) = self.password {
-        out.push('\n');
+            out.push_str(&format!("password={}\n", v));
-        out
+        }
-    }
+        out.push('\n');
-}
+        out
-
+    }
-/// Map a git host to a service name used by the keyring-backed PAT storage.
+}
-///
+
-/// Common git hosting services are mapped to short canonical names. Unknown
+/// Map a git host to a service name used by the keyring-backed PAT storage.
-/// hosts are used as-is (lowercased, trailing slash trimmed).
+///
-pub fn host_to_service(host: &str) -> String {
+/// Common git hosting services are mapped to short canonical names. Unknown
-    let host = host.to_lowercase();
+/// hosts are used as-is (lowercased, trailing slash trimmed).
-    let host = host.trim_end_matches('/');
+pub fn host_to_service(host: &str) -> String {
-    match host {
+    let host = host.to_lowercase();
-        "github.com" | "www.github.com" => "github".to_string(),
+    let host = host.trim_end_matches('/');
-        "gitlab.com" | "www.gitlab.com" => "gitlab".to_string(),
+    match host {
-        "bitbucket.org" | "www.bitbucket.org" => "bitbucket".to_string(),
+        "github.com" | "www.github.com" => "github".to_string(),
-        "codeberg.org" | "www.codeberg.org" => "codeberg".to_string(),
+        "gitlab.com" | "www.gitlab.com" => "gitlab".to_string(),
-        "gitea.com" | "www.gitea.com" => "gitea".to_string(),
+        "bitbucket.org" | "www.bitbucket.org" => "bitbucket".to_string(),
-        "gitee.com" | "www.gitee.com" => "gitee".to_string(),
+        "codeberg.org" | "www.codeberg.org" => "codeberg".to_string(),
-        other => other.to_string(),
+        "gitea.com" | "www.gitea.com" => "gitea".to_string(),
-    }
+        "gitee.com" | "www.gitee.com" => "gitee".to_string(),
-}
+        other => other.to_string(),
-
+    }
-/// Search all profiles for one that has a PAT stored for the given service.
+}
-/// Returns the profile name and the PAT value.
+
-fn find_pat_for_service(manager: &ConfigManager, service: &str) -> Option<(String, String)> {
+/// Search all profiles for one that has a PAT stored for the given service.
-    for profile_name in manager.list_profiles() {
+/// Returns the profile name and the PAT value.
-        if manager.has_pat_for_profile(profile_name, service) {
+fn find_pat_for_service(manager: &ConfigManager, service: &str) -> Option<(String, String)> {
-            if let Ok(Some(pat)) = manager.get_pat_for_profile(profile_name, service) {
+    for profile_name in manager.list_profiles() {
-                return Some((profile_name.clone(), pat));
+        if manager.has_pat_for_profile(profile_name, service) {
-            }
+            if let Ok(Some(pat)) = manager.get_pat_for_profile(profile_name, service) {
-        }
+                return Some((profile_name.clone(), pat));
-    }
+            }
-    None
+        }
-}
+    }
-
+    None
-/// Determine which profile to use when storing a credential.
+}
-///
+
-/// Prefers a profile whose `user_name` or `user_email` matches the
+/// Determine which profile to use when storing a credential.
-/// git-supplied username; otherwise falls back to the default profile.
+///
-fn find_profile_for_store(
+/// Prefers a profile whose `user_name` or `user_email` matches the
-    manager: &ConfigManager,
+/// git-supplied username; otherwise falls back to the default profile.
-    username: Option<&str>,
+fn find_profile_for_store(manager: &ConfigManager, username: Option<&str>) -> Option<String> {
-) -> Option<String> {
+    if let Some(username) = username {
-    if let Some(username) = username {
+        for name in manager.list_profiles() {
-        for name in manager.list_profiles() {
+            if let Some(profile) = manager.get_profile(name) {
-            if let Some(profile) = manager.get_profile(name) {
+                if profile.user_name == username || profile.user_email == username {
-                if profile.user_name == username || profile.user_email == username {
+                    return Some(name.clone());
-                    return Some(name.clone());
+                }
-                }
+            }
-            }
+        }
-        }
+    }
-    }
+    manager.default_profile_name().cloned()
-    manager.default_profile_name().cloned()
+}
-}
+
-
+/// Extract a PAT for the given host from saved credentials across all profiles.
-/// Extract a PAT for the given host from saved credentials across all profiles.
+///
-///
+/// This is intended for use by other parts of the application (e.g. when
-/// This is intended for use by other parts of the application (e.g. when
+/// verifying access to a git hosting service) and searches every configured
-/// verifying access to a git hosting service) and searches every configured
+/// profile for a stored PAT matching the host.
-/// profile for a stored PAT matching the host.
+pub fn get_pat_for_host(host: &str) -> Result<Option<String>> {
-pub fn get_pat_for_host(host: &str) -> Result<Option<String>> {
+    let manager = ConfigManager::new()?;
-    let manager = ConfigManager::new()?;
+    let service = host_to_service(host);
-    let service = host_to_service(host);
+    Ok(find_pat_for_service(&manager, &service).map(|(_, pat)| pat))
-    Ok(find_pat_for_service(&manager, &service).map(|(_, pat)| pat))
+}
-}
+
-
+#[cfg(test)]
-#[cfg(test)]
+mod tests {
-mod tests {
+    use super::*;
-    use super::*;
+
-
+    #[test]
-    #[test]
+    fn test_host_to_service_known_hosts() {
-    fn test_host_to_service_known_hosts() {
+        assert_eq!(host_to_service("github.com"), "github");
-        assert_eq!(host_to_service("github.com"), "github");
+        assert_eq!(host_to_service("www.github.com"), "github");
-        assert_eq!(host_to_service("www.github.com"), "github");
+        assert_eq!(host_to_service("gitlab.com"), "gitlab");
-        assert_eq!(host_to_service("gitlab.com"), "gitlab");
+        assert_eq!(host_to_service("bitbucket.org"), "bitbucket");
-        assert_eq!(host_to_service("bitbucket.org"), "bitbucket");
+        assert_eq!(host_to_service("codeberg.org"), "codeberg");
-        assert_eq!(host_to_service("codeberg.org"), "codeberg");
+        assert_eq!(host_to_service("gitea.com"), "gitea");
-        assert_eq!(host_to_service("gitea.com"), "gitea");
+        assert_eq!(host_to_service("gitee.com"), "gitee");
-        assert_eq!(host_to_service("gitee.com"), "gitee");
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_host_to_service_case_insensitive() {
-    fn test_host_to_service_case_insensitive() {
+        assert_eq!(host_to_service("GitHub.Com"), "github");
-        assert_eq!(host_to_service("GitHub.Com"), "github");
+        assert_eq!(host_to_service("GITLAB.COM"), "gitlab");
-        assert_eq!(host_to_service("GITLAB.COM"), "gitlab");
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_host_to_service_trailing_slash() {
-    fn test_host_to_service_trailing_slash() {
+        assert_eq!(host_to_service("github.com/"), "github");
-        assert_eq!(host_to_service("github.com/"), "github");
+        assert_eq!(host_to_service("gitlab.com//"), "gitlab");
-        assert_eq!(host_to_service("gitlab.com//"), "gitlab");
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_host_to_service_unknown_host() {
-    fn test_host_to_service_unknown_host() {
+        assert_eq!(host_to_service("example.com"), "example.com");
-        assert_eq!(host_to_service("example.com"), "example.com");
+        assert_eq!(host_to_service("git.internal.corp"), "git.internal.corp");
-        assert_eq!(host_to_service("git.internal.corp"), "git.internal.corp");
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_credential_attributes_parse_basic() {
-    fn test_credential_attributes_parse_basic() {
+        let input = "protocol=https\nhost=github.com\nusername=octocat\npassword=ghp_token123\n\n";
-        let input = "protocol=https\nhost=github.com\nusername=octocat\npassword=ghp_token123\n\n";
+        let attrs = CredentialAttributes::parse_str(input);
-        let attrs = CredentialAttributes::parse_str(input);
+        assert_eq!(attrs.protocol.as_deref(), Some("https"));
-        assert_eq!(attrs.protocol.as_deref(), Some("https"));
+        assert_eq!(attrs.host.as_deref(), Some("github.com"));
-        assert_eq!(attrs.host.as_deref(), Some("github.com"));
+        assert_eq!(attrs.username.as_deref(), Some("octocat"));
-        assert_eq!(attrs.username.as_deref(), Some("octocat"));
+        assert_eq!(attrs.password.as_deref(), Some("ghp_token123"));
-        assert_eq!(attrs.password.as_deref(), Some("ghp_token123"));
+        assert!(attrs.path.is_none());
-        assert!(attrs.path.is_none());
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_credential_attributes_parse_with_path() {
-    fn test_credential_attributes_parse_with_path() {
+        let input = "protocol=https\nhost=github.com\npath=owner/repo.git\n\n";
-        let input = "protocol=https\nhost=github.com\npath=owner/repo.git\n\n";
+        let attrs = CredentialAttributes::parse_str(input);
-        let attrs = CredentialAttributes::parse_str(input);
+        assert_eq!(attrs.path.as_deref(), Some("owner/repo.git"));
-        assert_eq!(attrs.path.as_deref(), Some("owner/repo.git"));
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_credential_attributes_parse_empty() {
-    fn test_credential_attributes_parse_empty() {
+        let attrs = CredentialAttributes::parse_str("");
-        let attrs = CredentialAttributes::parse_str("");
+        assert!(attrs.protocol.is_none());
-        assert!(attrs.protocol.is_none());
+        assert!(attrs.host.is_none());
-        assert!(attrs.host.is_none());
+        assert!(attrs.username.is_none());
-        assert!(attrs.username.is_none());
+        assert!(attrs.password.is_none());
-        assert!(attrs.password.is_none());
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_credential_attributes_parse_ignores_unknown_keys() {
-    fn test_credential_attributes_parse_ignores_unknown_keys() {
+        let input = "protocol=https\nhost=github.com\nunknown=value\nfoo=bar\n\n";
-        let input = "protocol=https\nhost=github.com\nunknown=value\nfoo=bar\n\n";
+        let attrs = CredentialAttributes::parse_str(input);
-        let attrs = CredentialAttributes::parse_str(input);
+        assert_eq!(attrs.protocol.as_deref(), Some("https"));
-        assert_eq!(attrs.protocol.as_deref(), Some("https"));
+        assert_eq!(attrs.host.as_deref(), Some("github.com"));
-        assert_eq!(attrs.host.as_deref(), Some("github.com"));
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_credential_attributes_parse_stops_at_blank_line() {
-    fn test_credential_attributes_parse_stops_at_blank_line() {
+        let input = "protocol=https\nhost=github.com\n\npassword=should_be_ignored\n";
-        let input = "protocol=https\nhost=github.com\n\npassword=should_be_ignored\n";
+        let attrs = CredentialAttributes::parse_str(input);
-        let attrs = CredentialAttributes::parse_str(input);
+        assert_eq!(attrs.protocol.as_deref(), Some("https"));
-        assert_eq!(attrs.protocol.as_deref(), Some("https"));
+        assert_eq!(attrs.host.as_deref(), Some("github.com"));
-        assert_eq!(attrs.host.as_deref(), Some("github.com"));
+        assert!(attrs.password.is_none());
-        assert!(attrs.password.is_none());
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_credential_attributes_serialize_roundtrip() {
-    fn test_credential_attributes_serialize_roundtrip() {
+        let attrs = CredentialAttributes {
-        let attrs = CredentialAttributes {
+            protocol: Some("https".to_string()),
-            protocol: Some("https".to_string()),
+            host: Some("github.com".to_string()),
-            host: Some("github.com".to_string()),
+            path: None,
-            path: None,
+            username: Some("octocat".to_string()),
-            username: Some("octocat".to_string()),
+            password: Some("ghp_token".to_string()),
-            password: Some("ghp_token".to_string()),
+        };
-        };
+        let serialized = attrs.serialize();
-        let serialized = attrs.serialize();
+        let reparsed = CredentialAttributes::parse_str(&serialized);
-        let reparsed = CredentialAttributes::parse_str(&serialized);
+        assert_eq!(attrs, reparsed);
-        assert_eq!(attrs, reparsed);
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_credential_attributes_serialize_includes_blank_line() {
-    fn test_credential_attributes_serialize_includes_blank_line() {
+        let attrs = CredentialAttributes {
-        let attrs = CredentialAttributes {
+            protocol: Some("https".to_string()),
-            protocol: Some("https".to_string()),
+            host: Some("github.com".to_string()),
-            host: Some("github.com".to_string()),
+            path: None,
-            path: None,
+            username: None,
-            username: None,
+            password: None,
-            password: None,
+        };
-        };
+        let serialized = attrs.serialize();
-        let serialized = attrs.serialize();
+        assert!(serialized.ends_with("\n\n"));
-        assert!(serialized.ends_with("\n\n"));
+        assert!(serialized.contains("protocol=https\n"));
-        assert!(serialized.contains("protocol=https\n"));
+        assert!(serialized.contains("host=github.com\n"));
-        assert!(serialized.contains("host=github.com\n"));
+    }
-    }
+
-
+    #[test]
-    #[test]
+    fn test_credential_attributes_default() {
-    fn test_credential_attributes_default() {
+        let attrs = CredentialAttributes::default();
-        let attrs = CredentialAttributes::default();
+        assert!(attrs.protocol.is_none());
-        assert!(attrs.protocol.is_none());
+        assert!(attrs.host.is_none());
-        assert!(attrs.host.is_none());
+        assert!(attrs.path.is_none());
-        assert!(attrs.path.is_none());
+        assert!(attrs.username.is_none());
-        assert!(attrs.username.is_none());
+        assert!(attrs.password.is_none());
-        assert!(attrs.password.is_none());
+    }
-    }
+}
-}

src/commands/init.rs

@@ -10,6 +10,7 @@ use crate::config::{GitProfile, Language};
 use crate::i18n::Messages;
 use crate::utils::keyring::{get_default_model, get_supported_providers, provider_needs_api_key};
 use crate::utils::validators::validate_email;
+use crate::utils::{print_success, print_warning};
 
 /// Initialize quicommit configuration
 #[derive(Parser)]
@@ -34,19 +35,16 @@ impl InitCommand {
         if config_path.exists() && !self.reset {
             if !self.yes {
                 let overwrite = Confirm::new()
-                    .with_prompt("Configuration already exists. Overwrite?")
+                    .with_prompt(messages.config_exists_overwrite())
                     .default(false)
                     .interact()?;
 
                 if !overwrite {
-                    println!("{}", "Initialization cancelled.".yellow());
+                    print_warning(messages.init_cancelled());
                     return Ok(());
                 }
             } else {
-                println!(
+                print_warning(messages.config_exists_use_reset());
-                    "{}",
-                    "Configuration already exists. Use --reset to overwrite.".yellow()
-                );
                 return Ok(());
             }
         }
@@ -59,7 +57,7 @@ impl InitCommand {
         let mut manager = ConfigManager::with_path_fresh(&config_path)?;
 
         if self.yes {
-            self.quick_setup(&mut manager).await?;
+            self.quick_setup(&mut manager, &messages).await?;
         } else {
             self.interactive_setup(&mut manager).await?;
         }
@@ -69,27 +67,52 @@ impl InitCommand {
         let language = manager.get_language().unwrap_or(Language::English);
         let messages = Messages::new(language);
 
-        println!("{}", messages.init_success().bold().green());
+        print_success(messages.init_success());
         println!("\n{}: {}", messages.config_file(), config_path.display());
         println!("\n{}:", messages.next_steps());
-        println!("  1. Create a profile: {}", "quicommit profile add".cyan());
+        println!(
-        println!("  2. Configure LLM: {}", "quicommit config set-llm".cyan());
+            "  1. {}: {}",
-        println!("  3. Start committing: {}", "quicommit commit".cyan());
+            messages.next_steps_create_profile(),
+            "quicommit profile add".cyan()
+        );
+        println!(
+            "  2. {}: {}",
+            messages.next_steps_configure_llm(),
+            "quicommit config set-llm".cyan()
+        );
+        println!(
+            "  3. {}: {}",
+            messages.next_steps_start_committing(),
+            "quicommit commit".cyan()
+        );
 
         Ok(())
     }
 
-    async fn quick_setup(&self, manager: &mut ConfigManager) -> Result<()> {
+    async fn quick_setup(&self, manager: &mut ConfigManager, messages: &Messages) -> Result<()> {
         let git_config = git2::Config::open_default()?;
 
-        let user_name = git_config
+        let name_result = git_config.get_string("user.name");
-            .get_string("user.name")
+        let email_result = git_config.get_string("user.email");
-            .unwrap_or_else(|_| "User".to_string());
+        let name_missing = name_result.is_err();
-        let user_email = git_config
+        let email_missing = email_result.is_err();
-            .get_string("user.email")
+        let user_name = name_result.unwrap_or_else(|_| "User".to_string());
-            .unwrap_or_else(|_| "user@example.com".to_string());
+        let user_email = email_result.unwrap_or_else(|_| "user@example.com".to_string());
 
-        let profile = GitProfile::new("default".to_string(), user_name, user_email);
+        let profile = GitProfile::new("default".to_string(), user_name.clone(), user_email.clone());
+
+        println!("\n{}", messages.quick_setup_summary().bold());
+        println!("  {}: {}", messages.profile_label(), "default".cyan());
+        println!(
+            "  {}: {} <{}>",
+            messages.identity_label(),
+            user_name,
+            user_email
+        );
+        if name_missing || email_missing {
+            print_warning(messages.identity_placeholder_warning());
+        }
+        println!("  {}: {}", messages.llm_provider_label(), "ollama".cyan());
 
         manager.add_profile("default".to_string(), profile)?;
         manager.set_default_profile(Some("default".to_string()))?;
@@ -231,11 +254,8 @@ impl InitCommand {
         let keyring_available = keyring.is_available();
 
         if !keyring_available {
-            println!(
+            print_warning(messages.keyring_unavailable());
-                "\n{}",
+            print_warning(&keyring.get_status_message());
-                "⚠ Keyring is not available on this system.".yellow()
-            );
-            println!("{}", keyring.get_status_message().yellow());
         }
 
         let api_key = if provider_needs_api_key(&provider) {
@@ -246,11 +266,7 @@ impl InitCommand {
                 .ok();
 
             if let Some(_key) = env_key {
-                println!(
+                print_success(messages.api_key_found_env());
-                    "\n{} {}",
-                    "✓".green(),
-                    "Found API key in environment variable.".green()
-                );
                 None
             } else if keyring_available {
                 let prompt = match provider.as_str() {
@@ -259,16 +275,13 @@ impl InitCommand {
                     "kimi" => messages.kimi_api_key(),
                     "deepseek" => messages.deepseek_api_key(),
                     "openrouter" => messages.openrouter_api_key(),
-                    _ => "API Key",
+                    _ => messages.api_key_prompt_other(),
                 };
 
-                let key: String = Input::new().with_prompt(prompt).interact_text()?;
+                let key: String = crate::utils::password_input(prompt)?;
                 Some(key)
             } else {
-                println!(
+                print_warning(messages.please_set_api_key_env());
-                    "\n{}",
-                    "Please set the QUICOMMIT_API_KEY environment variable.".yellow()
-                );
                 None
             }
         } else {
@@ -277,24 +290,26 @@ impl InitCommand {
 
         let default_model = get_default_model(&provider);
         let model: String = Input::new()
-            .with_prompt("Model name")
+            .with_prompt(messages.model_name())
             .default(default_model.to_string())
             .interact_text()?;
 
         let base_url: Option<String> = if provider == "ollama" {
             let url: String = Input::new()
-                .with_prompt("Ollama server URL")
+                .with_prompt(messages.ollama_server_url())
                 .default("http://localhost:11434".to_string())
                 .interact_text()?;
             Some(url)
         } else {
             let use_custom_url = Confirm::new()
-                .with_prompt("Use custom API base URL?")
+                .with_prompt(messages.use_custom_base_url())
                 .default(false)
                 .interact()?;
 
             if use_custom_url {
-                let url: String = Input::new().with_prompt("Base URL").interact_text()?;
+                let url: String = Input::new()
+                    .with_prompt(messages.base_url_plain())
+                    .interact_text()?;
                 Some(url)
             } else {
                 None
@@ -309,11 +324,7 @@ impl InitCommand {
             && provider_needs_api_key(&provider)
         {
             manager.set_api_key(&key)?;
-            println!(
+            print_success(messages.api_key_stored_keyring());
-                "\n{} {}",
-                "✓".green(),
-                "API key stored securely in system keyring.".green()
-            );
         }
 
         Ok(())
@@ -332,7 +343,7 @@ impl InitCommand {
             .interact_text()?;
 
         let pub_key_path: String = Input::new()
-            .with_prompt("SSH public key path (optional, leave empty to auto-detect)")
+            .with_prompt(messages.ssh_public_key_path())
             .default(ssh_dir.join("id_rsa.pub").display().to_string())
             .allow_empty(true)
             .interact_text()?;
@@ -354,12 +365,12 @@ impl InitCommand {
         };
 
         let agent_forwarding = Confirm::new()
-            .with_prompt("Enable SSH agent forwarding (-A)?")
+            .with_prompt(messages.ssh_agent_forwarding())
             .default(false)
             .interact()?;
 
         let known_hosts: String = Input::new()
-            .with_prompt("Custom known_hosts file path (optional)")
+            .with_prompt(messages.known_hosts_path())
             .allow_empty(true)
             .interact_text()?;
         let known_hosts_file = if known_hosts.is_empty() {
@@ -369,7 +380,7 @@ impl InitCommand {
         };
 
         let custom_cmd: String = Input::new()
-            .with_prompt("Custom SSH command (optional, overrides all other SSH settings)")
+            .with_prompt(messages.custom_ssh_command())
             .allow_empty(true)
             .interact_text()?;
         let ssh_command = if custom_cmd.is_empty() {

src/commands/tag.rs

@@ -8,10 +8,12 @@ use std::path::PathBuf;
 use crate::config::{Language, manager::ConfigManager};
 use crate::generator::ContentGenerator;
 use crate::git::tag::{
-    TagBuilder, VersionBump, bump_version, get_latest_version, suggest_version_bump,
+    ConfigVersion, TagBuilder, VersionBump, bump_version, get_latest_version,
+    read_project_versions, suggest_version_bump,
 };
 use crate::git::{GitRepo, find_repo};
 use crate::i18n::Messages;
+use crate::utils::{print_progress, print_success, print_warning};
 
 /// Generate and create Git tags
 #[derive(Parser)]
@@ -60,9 +62,14 @@ pub struct TagCommand {
     #[arg(short = 't', long)]
     think: bool,
 
-    /// Skip interactive prompts
+    /// Skip interactive prompts only (generation behavior unchanged)
     #[arg(short = 'y', long)]
     yes: bool,
+
+    /// Auto-detect version from project config (Cargo.toml/pyproject.toml),
+    /// falling back to commit analysis with confirmation. Mutually exclusive with --bump.
+    #[arg(short = 'A', long, conflicts_with = "bump")]
+    auto: bool,
 }
 
 impl TagCommand {
@@ -80,6 +87,9 @@ impl TagCommand {
         // Determine tag name
         let tag_name = if let Some(name) = &self.name {
             name.clone()
+        } else if self.auto {
+            self.auto_detect_version(&repo, &config.tag.version_prefix, &messages)
+                .await?
         } else if let Some(bump_str) = &self.bump {
             // Calculate bumped version
             let prefix = &config.tag.version_prefix;
@@ -106,11 +116,11 @@ impl TagCommand {
         {
             let version_str = tag_name.trim_start_matches('v');
             if let Err(e) = crate::utils::validators::validate_semver(version_str) {
-                println!("{}: {}", "Warning".yellow(), e);
+                print_warning(&format!("{}: {}", messages.warning(), e));
 
                 if !self.yes {
                     let proceed = Confirm::new()
-                        .with_prompt("Proceed with this tag name anyway?")
+                        .with_prompt(messages.proceed_invalid_tag_name())
                         .default(true)
                         .interact()?;
 
@@ -126,7 +136,7 @@ impl TagCommand {
             None
         } else if let Some(msg) = &self.message {
             Some(msg.clone())
-        } else if self.generate || (config.tag.auto_generate && !self.yes) {
+        } else if self.generate || config.tag.auto_generate {
             Some(
                 self.generate_tag_message(&repo, &tag_name, &messages)
                     .await?,
@@ -134,7 +144,7 @@ impl TagCommand {
         } else if !self.yes {
             Some(self.input_message_interactive(&tag_name, &messages)?)
         } else {
-            Some(format!("Release {}", tag_name))
+            Some(messages.release_default(&tag_name))
         };
 
         // Show preview
@@ -156,13 +166,13 @@ impl TagCommand {
                 .interact()?;
 
             if !confirm {
-                println!("{}", messages.tag_cancelled().yellow());
+                print_warning(messages.tag_cancelled());
                 return Ok(());
             }
         }
 
         if self.dry_run {
-            println!("\n{} {}", messages.dry_run(), "- tag not created.".yellow());
+            println!("\n{}", messages.dry_run_tag_not_created().yellow());
             return Ok(());
         }
 
@@ -175,13 +185,13 @@ impl TagCommand {
 
         builder.execute(&repo)?;
 
-        println!("{} {}", messages.tag_created().green(), tag_name.cyan());
+        print_success(&format!("{} {}", messages.tag_created(), tag_name.cyan()));
 
         // Push if requested or ask user
         if self.push {
-            println!("{}", messages.pushing_tag(&self.remote));
+            print_progress(&messages.pushing_tag(&self.remote));
             repo.push(&self.remote, &format!("refs/tags/{}", tag_name))?;
-            println!("{}", messages.pushed_tag(&self.remote));
+            print_success(&messages.pushed_tag(&self.remote));
         } else if !self.yes && !self.dry_run {
             let should_push = Confirm::new()
                 .with_prompt(messages.push_after_tag())
@@ -189,9 +199,9 @@ impl TagCommand {
                 .interact()?;
 
             if should_push {
-                println!("{}", messages.pushing_tag(&self.remote));
+                print_progress(&messages.pushing_tag(&self.remote));
                 repo.push(&self.remote, &format!("refs/tags/{}", tag_name))?;
-                println!("{}", messages.pushed_tag(&self.remote));
+                print_success(&messages.pushed_tag(&self.remote));
             }
         }
 
@@ -314,19 +324,103 @@ impl TagCommand {
         };
 
         if commits.is_empty() {
-            return Ok(format!("Release {}", version));
+            return Ok(messages.release_default(version));
         }
 
-        println!("{}", messages.ai_generating_tag(commits.len()));
-
         let generator = ContentGenerator::new_with_think(&manager, self.think, None).await?;
-        generator
+        let spinner = crate::utils::Spinner::start(&messages.ai_generating_tag(commits.len()));
+        let result = generator
             .generate_tag_message(version, &commits, language)
-            .await
+            .await;
+        spinner.finish_clear();
+        result
+    }
+
+    async fn auto_detect_version(
+        &self,
+        repo: &GitRepo,
+        prefix: &str,
+        messages: &Messages,
+    ) -> Result<String> {
+        let project_dir = std::env::current_dir()?;
+
+        // 1. Try reading from project config files
+        let config_versions = read_project_versions(&project_dir);
+
+        if !config_versions.is_empty() {
+            if config_versions.len() == 1 {
+                let cv = &config_versions[0];
+                let tag_name = format!("{}{}", prefix, cv.version);
+                println!(
+                    "{} ({}): {}",
+                    messages.found_version_in(),
+                    cv.source,
+                    tag_name.cyan()
+                );
+                return Ok(tag_name);
+            }
+
+            // Multiple config files: let user choose
+            return self.select_config_version(&config_versions, prefix, messages);
+        }
+
+        // 2. Fall back to commit analysis
+        println!("{}", messages.auto_detect_bump());
+        let commits = repo.get_commits(50)?;
+        let bump = suggest_version_bump(&commits);
+        let latest = get_latest_version(repo, prefix)?.unwrap_or_else(|| Version::new(0, 0, 0));
+        let version = bump_version(&latest, bump, None);
+        let tag_name = format!("{}{}", prefix, version);
+
+        println!(
+            "{} {:?} → {}",
+            messages.suggested_bump(),
+            bump,
+            tag_name.cyan()
+        );
+
+        if !self.yes {
+            let confirm = Confirm::new()
+                .with_prompt(messages.use_this_version())
+                .default(true)
+                .interact()?;
+
+            if !confirm {
+                // Fall through to interactive version selection
+                return self
+                    .select_version_interactive(repo, prefix, messages)
+                    .await;
+            }
+        }
+
+        Ok(tag_name)
+    }
+
+    fn select_config_version(
+        &self,
+        config_versions: &[ConfigVersion],
+        prefix: &str,
+        messages: &Messages,
+    ) -> Result<String> {
+        println!("\n{}", messages.found_multiple_versions().bold());
+
+        let items: Vec<String> = config_versions
+            .iter()
+            .map(|cv| format!("{} → {}{}", cv.source, prefix, cv.version))
+            .collect();
+
+        let selection = Select::new()
+            .with_prompt(messages.select_version_to_use())
+            .items(&items)
+            .default(0)
+            .interact()?;
+
+        let cv = &config_versions[selection];
+        Ok(format!("{}{}", prefix, cv.version))
     }
 
     fn input_message_interactive(&self, version: &str, messages: &Messages) -> Result<String> {
-        let default_msg = format!("Release {}", version);
+        let default_msg = messages.release_default(version);
 
         let use_editor = Confirm::new()
             .with_prompt(messages.open_editor())

src/config/manager.rs

@@ -278,6 +278,22 @@ impl ConfigManager {
         Ok(())
     }
 
+    /// Delete a PAT from the keyring even when no config token entry exists.
+    /// Returns true if a keyring entry was deleted (issue 24).
+    pub fn delete_orphan_pat(&self, profile_name: &str, service: &str) -> Result<bool> {
+        if let Some(profile) = self.get_profile(profile_name) {
+            let user_email = &profile.user_email;
+            if self.keyring.has_pat(profile_name, user_email, service) {
+                self.keyring.delete_pat(profile_name, user_email, service)?;
+                Ok(true)
+            } else {
+                Ok(false)
+            }
+        } else {
+            Ok(false)
+        }
+    }
+
     /// Delete all PAT tokens for a profile (used when removing a profile)
     pub fn delete_all_pats_for_profile(&self, profile_name: &str) -> Result<()> {
         if let Some(profile) = self.get_profile(profile_name) {
@@ -658,6 +674,17 @@ impl ConfigManager {
         self.modified = true;
     }
 
+    /// Check if emoji decorations are enabled
+    pub fn emoji_enabled(&self) -> bool {
+        self.config.output.emoji
+    }
+
+    /// Set emoji decorations flag
+    pub fn set_emoji_enabled(&mut self, enabled: bool) {
+        self.config.output.emoji = enabled;
+        self.modified = true;
+    }
+
     /// Export configuration to TOML string
     pub fn export(&self) -> Result<String> {
         toml::to_string_pretty(&self.config).context("Failed to serialize config")

src/config/mod.rs

@@ -47,6 +47,10 @@ pub struct AppConfig {
     /// Language settings
     #[serde(default)]
     pub language: LanguageConfig,
+
+    /// Output settings
+    #[serde(default)]
+    pub output: OutputConfig,
 }
 
 impl Default for AppConfig {
@@ -61,6 +65,7 @@ impl Default for AppConfig {
             changelog: ChangelogConfig::default(),
             repo_profiles: HashMap::new(),
             language: LanguageConfig::default(),
+            output: OutputConfig::default(),
         }
     }
 }
@@ -236,6 +241,20 @@ impl Default for LanguageConfig {
     }
 }
 
+/// Output configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OutputConfig {
+    /// Show emoji/symbol decorations (✓/✗/⚠/→)
+    #[serde(default = "default_true")]
+    pub emoji: bool,
+}
+
+impl Default for OutputConfig {
+    fn default() -> Self {
+        Self { emoji: true }
+    }
+}
+
 /// Supported languages
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Language {

src/generator/mod.rs

@@ -1,7 +1,10 @@
 use crate::config::manager::ConfigManager;
 use crate::config::{CommitFormat, Language};
 use crate::git::{CommitInfo, GitRepo};
-use crate::llm::{GeneratedCommit, LlmClient};
+use crate::i18n::Messages;
+use crate::llm::parsing::GeneratedCommit;
+use crate::llm::rig::LlmClient;
+use crate::utils::{eprint_warning, success_prefix};
 use anyhow::{Context, Result};
 
 /// Content generator using LLM
@@ -32,11 +35,9 @@ impl ContentGenerator {
         if thinking_enabled {
             let provider = manager.llm_provider();
             if !Self::supports_thinking(provider) {
-                eprintln!(
+                let language = manager.get_language().unwrap_or(Language::English);
-                    "Warning: Provider '{}' does not support thinking mode. \
+                let messages = Messages::new(language);
-                     Disabling thinking for this invocation.",
+                eprint_warning(&messages.thinking_unsupported(provider));
-                    provider
-                );
                 thinking_enabled = false;
             }
         }
@@ -155,6 +156,7 @@ impl ContentGenerator {
         repo: &GitRepo,
         format: CommitFormat,
         language: Language,
+        messages: &Messages,
     ) -> Result<GeneratedCommit> {
         use dialoguer::Select;
 
@@ -166,33 +168,33 @@ impl ContentGenerator {
 
         // Show diff summary
         let files = repo.get_staged_files()?;
-        println!("\nStaged files ({}):", files.len());
+        println!("\n{}", messages.staged_files(files.len()));
         for file in &files {
             println!("  • {}", file);
         }
 
         // Generate initial commit
-        println!("\nGenerating commit message...");
+        println!("\n{}", messages.generating_commit_message());
         let mut generated = self
             .generate_commit_message(&diff, format, language)
             .await?;
 
         loop {
             println!("\n{}", "─".repeat(60));
-            println!("Generated commit message:");
+            println!("{}", messages.generated_commit_message());
             println!("{}", "─".repeat(60));
             println!("{}", generated.to_conventional());
             println!("{}", "─".repeat(60));
 
             let options = vec![
-                "✓ Accept and commit",
+                format!("{} {}", success_prefix(), messages.accept_and_commit()),
-                "🔄 Regenerate",
+                messages.regenerate().to_string(),
-                "✏️  Edit",
+                messages.edit().to_string(),
-                "❌ Cancel",
+                messages.cancel().to_string(),
             ];
 
             let selection = Select::new()
-                .with_prompt("What would you like to do?")
+                .with_prompt(messages.what_would_you_like_to_do())
                 .items(&options)
                 .default(0)
                 .interact()?;
@@ -200,7 +202,7 @@ impl ContentGenerator {
             match selection {
                 0 => return Ok(generated),
                 1 => {
-                    println!("Regenerating...");
+                    println!("{}", messages.regenerating());
                     generated = self
                         .generate_commit_message(&diff, format, language)
                         .await?;
@@ -209,7 +211,7 @@ impl ContentGenerator {
                     let edited = crate::utils::editor::edit_content(&generated.to_conventional())?;
                     generated = self.parse_edited_commit(&edited, format)?;
                 }
-                3 => anyhow::bail!("Cancelled by user"),
+                3 => anyhow::bail!("{}", messages.cancelled_by_user()),
                 _ => {}
             }
         }

src/git/changelog.rs

@@ -409,8 +409,8 @@ pub fn generate_from_history(
     if let Some(from) = from_tag {
         repo.get_commits_between(from, to_ref)
     } else {
-        // Get last 50 commits if no tag specified
+        // Get all commits from the beginning (no from_tag = initial changelog)
-        repo.get_commits(50)
+        repo.get_commits(usize::MAX)
     }
 }
 
@@ -476,3 +476,137 @@ impl ChangelogEntry {
         self
     }
 }
+
+/// Extract version strings from Keep a Changelog content.
+/// Returns versions sorted by semver descending (highest first).
+/// Excludes "Unreleased".
+pub fn parse_changelog_versions(content: &str) -> Vec<String> {
+    use semver::Version;
+
+    let mut versions: Vec<String> = vec![];
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if trimmed.starts_with("## [") {
+            if let Some(end) = trimmed.find(']') {
+                let version = &trimmed[4..end];
+                if version != "Unreleased" && !version.is_empty() {
+                    versions.push(version.to_string());
+                }
+            }
+        }
+    }
+    // Sort by semver descending so highest version is first
+    versions.sort_by(|a, b| {
+        match (Version::parse(a), Version::parse(b)) {
+            (Ok(va), Ok(vb)) => vb.cmp(&va),
+            (Ok(_), Err(_)) => std::cmp::Ordering::Less,
+            (Err(_), Ok(_)) => std::cmp::Ordering::Greater,
+            (Err(_), Err(_)) => std::cmp::Ordering::Equal,
+        }
+    });
+    versions
+}
+
+/// Insert a new changelog entry into existing changelog content.
+/// The new entry is placed after the header and before the first existing version section.
+/// If no existing version sections are found, the new entry is appended after the header.
+pub fn insert_changelog_entry(existing: &str, new_entry: &str) -> String {
+    // Find the first version section (## [x.y.z])
+    if let Some(first_ver_pos) = existing.find("\n## [") {
+        let (header, rest) = existing.split_at(first_ver_pos);
+        // Ensure new_entry ends with a blank line before the next section
+        let entry = new_entry.trim_end();
+        format!("{}\n{}\n{}", header.trim_end(), entry, rest)
+    } else {
+        // No existing version sections — append after header
+        format!("{}\n{}", existing.trim_end(), new_entry.trim_end())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_changelog_versions_extracts_versions() {
+        let content = "# Changelog\n\n## [0.2.0] - 2024-03-01\n### Added\n- feature B\n\n## [0.1.0] - 2024-02-01\n### Added\n- feature A\n";
+        let versions = parse_changelog_versions(content);
+        assert_eq!(versions, vec!["0.2.0", "0.1.0"]);
+    }
+
+    #[test]
+    fn test_parse_changelog_versions_sorts_highest_first() {
+        // Versions in reversed order — should still return highest first
+        let content = "# Changelog\n\n## [0.1.0] - 2024-02-01\n### Added\n- feature A\n\n## [0.3.0] - 2024-04-01\n### Added\n- feature C\n\n## [0.2.0] - 2024-03-01\n### Added\n- feature B\n";
+        let versions = parse_changelog_versions(content);
+        assert_eq!(versions, vec!["0.3.0", "0.2.0", "0.1.0"]);
+    }
+
+    #[test]
+    fn test_parse_changelog_versions_excludes_unreleased() {
+        let content = "# Changelog\n\n## [Unreleased]\n### Added\n- wip\n\n## [0.1.0] - 2024-02-01\n### Added\n- feature A\n";
+        let versions = parse_changelog_versions(content);
+        assert_eq!(versions, vec!["0.1.0"]);
+    }
+
+    #[test]
+    fn test_parse_changelog_versions_empty_content() {
+        let versions = parse_changelog_versions("");
+        assert!(versions.is_empty());
+    }
+
+    #[test]
+    fn test_parse_changelog_versions_no_versions() {
+        let content = "# Changelog\n\nSome description text.\n";
+        let versions = parse_changelog_versions(content);
+        assert!(versions.is_empty());
+    }
+
+    #[test]
+    fn test_insert_changelog_entry_between_header_and_existing() {
+        let existing = "# Changelog\n\nAll notable changes...\n\n## [0.1.0] - 2024-02-01\n### Added\n- feature A\n";
+        let new_entry = "## [0.2.0] - 2024-03-01\n### Added\n- feature B\n";
+        let result = insert_changelog_entry(existing, new_entry);
+
+        // New entry should appear after header, before 0.1.0
+        assert!(result.contains("## [0.2.0]"));
+        assert!(result.contains("## [0.1.0]"));
+        let pos_new = result.find("## [0.2.0]").unwrap();
+        let pos_old = result.find("## [0.1.0]").unwrap();
+        assert!(pos_new < pos_old, "new version should be before old version");
+    }
+
+    #[test]
+    fn test_insert_changelog_entry_preserves_all_existing_content() {
+        let existing = "# Changelog\n\nAll notable changes...\n\n## [0.2.0] - 2024-03-01\n### Added\n- feature B\n\n## [0.1.0] - 2024-02-01\n### Added\n- feature A\n";
+        let new_entry = "## [0.3.0] - 2024-04-01\n### Added\n- feature C\n";
+        let result = insert_changelog_entry(existing, new_entry);
+
+        assert!(result.contains("## [0.3.0]"));
+        assert!(result.contains("## [0.2.0]"));
+        assert!(result.contains("## [0.1.0]"));
+        assert!(result.contains("feature A"), "oldest content preserved");
+        assert!(result.contains("feature B"), "middle content preserved");
+        assert!(result.contains("feature C"), "new content present");
+    }
+
+    #[test]
+    fn test_insert_changelog_entry_empty_existing() {
+        let existing = "# Changelog\n\nAll notable changes...\n\n";
+        let new_entry = "## [0.1.0] - 2024-02-01\n### Added\n- feature A\n";
+        let result = insert_changelog_entry(existing, new_entry);
+        assert!(result.contains("## [0.1.0]"));
+        assert!(result.contains("# Changelog"));
+    }
+
+    #[test]
+    fn test_insert_changelog_entry_extra_blank_lines_in_header() {
+        let existing = "# Changelog\n\n\n\n## [0.1.0] - 2024-02-01\n### Added\n- feature A\n";
+        let new_entry = "## [0.2.0] - 2024-03-01\n### Added\n- feature B\n";
+        let result = insert_changelog_entry(existing, new_entry);
+
+        let pos_new = result.find("## [0.2.0]").unwrap();
+        let pos_old = result.find("## [0.1.0]").unwrap();
+        assert!(pos_new < pos_old, "new version should be before old version");
+    }
+}

src/git/mod.rs

@@ -76,7 +76,7 @@ fn try_open_repo_with_git2(path: &Path) -> Result<Repository> {
         .or_else(|_| Repository::discover(&normalized))
         .or_else(|_| Repository::open(&normalized));
 
-    repo.map_err(|e| anyhow::anyhow!("git2 failed: {}", e))
+    repo.map_err(|e| anyhow::anyhow!("Failed to open repository: {}", e))
 }
 
 fn try_open_repo_with_git_cli(path: &Path) -> Result<Repository> {
@@ -533,27 +533,116 @@ impl GitRepo {
         Ok(files)
     }
 
-    /// Stage files
+    /// Stage files, skipping paths matched by .gitignore rules
-    pub fn stage_files<P: AsRef<Path>>(&self, paths: &[P]) -> Result<()> {
+    /// Returns the list of skipped paths (those matched by .gitignore)
+    pub fn stage_files<P: AsRef<Path>>(&self, paths: &[P]) -> Result<Vec<String>> {
         let mut index = self.repo.index()?;
+        let mut skipped = Vec::new();
 
         for path in paths {
             let path = path.as_ref();
-            if path.is_absolute() {
+            let rel_path = if path.is_absolute() {
-                if let Ok(rel_path) = path.strip_prefix(&self.path) {
+                match path.strip_prefix(&self.path) {
-                    index.add_path(rel_path)?;
+                    Ok(p) => p,
+                    Err(_) => {
+                        // Outside repo, skip
+                        skipped.push(path.to_string_lossy().to_string());
+                        continue;
+                    }
                 }
             } else {
-                index.add_path(path)?;
+                path
+            };
+
+            // Check if the path is ignored by .gitignore
+            if self.is_path_ignored(rel_path)? {
+                skipped.push(rel_path.to_string_lossy().to_string());
+                continue;
             }
+
+            index.add_path(rel_path)?;
         }
 
         index.write()?;
-        Ok(())
+        Ok(skipped)
     }
 
-    /// Stage all changes including subdirectories
+    /// Check if a path is ignored by .gitignore rules
-    pub fn stage_all(&self) -> Result<()> {
+    pub fn is_path_ignored<P: AsRef<Path>>(&self, path: P) -> Result<bool> {
+        let path = path.as_ref();
+
+        // Convert to relative path if absolute
+        let rel_path = if path.is_absolute() {
+            match path.strip_prefix(&self.path) {
+                Ok(p) => p,
+                Err(_) => return Ok(false), // Outside repo, not ignored
+            }
+        } else {
+            path
+        };
+
+        let path_str = match rel_path.to_str() {
+            Some(s) => s,
+            None => return Ok(false), // Non-UTF8 path, not ignored
+        };
+
+        let output = std::process::Command::new("git")
+            .args(["check-ignore", "--quiet", "--", path_str])
+            .current_dir(&self.path)
+            .output()?;
+
+        // Exit code 0: ignored, 1: not ignored, other: error
+        match output.status.code() {
+            Some(0) => Ok(true),
+            Some(1) => Ok(false),
+            _ => Ok(false), // Treat errors as not ignored
+        }
+    }
+
+    /// Remove files from index that are tracked but should be ignored by .gitignore
+    pub fn remove_ignored_from_index(&self) -> Result<Vec<String>> {
+        let output = std::process::Command::new("git")
+            .args(["ls-files", "--cached", "-i", "--exclude-standard"])
+            .current_dir(&self.path)
+            .output()?;
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            bail!("Failed to list ignored tracked files: {}", stderr);
+        }
+
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let ignored_files: Vec<String> = stdout
+            .lines()
+            .map(|l| l.trim().to_string())
+            .filter(|l| !l.is_empty())
+            .collect();
+
+        if ignored_files.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // Remove these files from the index (keep working tree files)
+        let mut args = vec!["rm", "--cached", "--quiet", "--"];
+        for file in &ignored_files {
+            args.push(file);
+        }
+
+        let rm_output = std::process::Command::new("git")
+            .args(&args)
+            .current_dir(&self.path)
+            .output()?;
+
+        if !rm_output.status.success() {
+            let stderr = String::from_utf8_lossy(&rm_output.stderr);
+            bail!("Failed to remove ignored files from index: {}", stderr);
+        }
+
+        Ok(ignored_files)
+    }
+
+    /// Stage all changes including subdirectories, then remove ignored tracked files
+    pub fn stage_all(&self, messages: &crate::i18n::Messages) -> Result<Vec<String>> {
         // Use git command for reliable staging (handles all edge cases)
         let output = std::process::Command::new("git")
             .args(["add", "-A"])
@@ -569,7 +658,18 @@ impl GitRepo {
         // Force refresh the git2 index to pick up changes from git CLI
         let _ = self.repo.index()?.write();
 
-        Ok(())
+        // Remove files that are tracked but should be ignored by .gitignore
+        match self.remove_ignored_from_index() {
+            Ok(removed) => Ok(removed),
+            Err(e) => {
+                crate::utils::eprint_warning(&format!(
+                    "{}: {}",
+                    messages.failed_clean_ignored(),
+                    e
+                ));
+                Ok(Vec::new())
+            }
+        }
     }
 
     /// Unstage files
@@ -766,24 +866,34 @@ impl GitRepo {
             let name = String::from_utf8_lossy(name);
             let name = name.strip_prefix("refs/tags/").unwrap_or(&name);
 
-            if let Ok(commit) = self.repo.find_commit(oid) {
+            // Use find_object + peel_to_commit to handle both lightweight
-                tags.push(TagInfo {
+            // (oid is a commit) and annotated (oid is a tag object) tags.
-                    name: name.to_string(),
+            if let Ok(obj) = self.repo.find_object(oid, None) {
-                    target: oid.to_string(),
+                if let Ok(commit) = obj.peel_to_commit() {
-                    message: commit.message().unwrap_or("").to_string(),
+                    tags.push(TagInfo {
-                    time: commit.time().seconds(),
+                        name: name.to_string(),
-                });
+                        target: commit.id().to_string(),
+                        message: commit.message().unwrap_or("").to_string(),
+                        time: commit.time().seconds(),
+                    });
+                }
             }
 
             true
         })?;
 
-        // Sort tags by time (newest first)
+        // Sort tags by semver (descending), then by time
-        tags.sort_by(|a, b| b.time.cmp(&a.time));
+        crate::git::tag::sort_tags_by_semver(&mut tags);
 
         Ok(tags)
     }
 
+    /// Find a tag whose version (stripping 'v' prefix) matches the given version string.
+    pub fn find_tag_by_version(&self, version: &str) -> Option<TagInfo> {
+        let tags = self.get_tags().ok()?;
+        tags.into_iter().find(|t| t.version_name() == version)
+    }
+
     /// Create a tag
     pub fn create_tag(&self, name: &str, message: Option<&str>, sign: bool) -> Result<()> {
         let head = self.repo.head()?;
@@ -831,16 +941,6 @@ impl GitRepo {
         Ok(())
     }
 
-    /// Create GPG signature for arbitrary content
-    fn create_gpg_signature_for_content(
-        &self,
-        _content: &str,
-        _gpg_program: &str,
-        _signing_key: &str,
-    ) -> Result<String> {
-        Ok(String::new())
-    }
-
     /// Delete a tag
     pub fn delete_tag(&self, name: &str) -> Result<()> {
         self.repo.tag_delete(name)?;
@@ -975,6 +1075,13 @@ pub struct TagInfo {
     pub time: i64,
 }
 
+impl TagInfo {
+    /// Return the version portion of the tag name (stripping leading 'v' if present).
+    pub fn version_name(&self) -> &str {
+        self.name.strip_prefix('v').unwrap_or(&self.name)
+    }
+}
+
 /// Repository status summary
 #[derive(Debug, Clone)]
 pub struct StatusSummary {
@@ -1345,3 +1452,139 @@ pub struct ConfigDiff {
     pub left: String,
     pub right: String,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use git2::Signature;
+    use tempfile::TempDir;
+
+    fn init_test_repo() -> (TempDir, GitRepo) {
+        let dir = TempDir::new().unwrap();
+        let repo = git2::Repository::init(dir.path()).unwrap();
+
+        // Configure git user
+        let mut config = repo.config().unwrap();
+        config.set_str("user.name", "Test User").unwrap();
+        config.set_str("user.email", "test@example.com").unwrap();
+
+        // Create an initial commit (needed for tags)
+        let sig = Signature::now("Test User", "test@example.com").unwrap();
+        let tree_id = {
+            let mut index = repo.index().unwrap();
+            index.write_tree().unwrap()
+        };
+        let tree = repo.find_tree(tree_id).unwrap();
+        repo.commit(Some("HEAD"), &sig, &sig, "initial commit", &tree, &[])
+            .unwrap();
+
+        let git_repo = GitRepo::open(dir.path()).unwrap();
+        (dir, git_repo)
+    }
+
+    #[test]
+    fn test_get_tags_returns_annotated_tags() {
+        let (_dir, repo) = init_test_repo();
+        let sig = Signature::now("Test User", "test@example.com").unwrap();
+        let head = repo.repo.head().unwrap().peel_to_commit().unwrap();
+
+        // Create an annotated tag (what QuiCommit creates by default)
+        repo.repo
+            .tag("v0.2.0", head.as_object(), &sig, "Release v0.2.0", false)
+            .unwrap();
+
+        let tags = repo.get_tags().unwrap();
+        let tag_names: Vec<&str> = tags.iter().map(|t| t.name.as_str()).collect();
+
+        assert!(
+            tag_names.contains(&"v0.2.0"),
+            "annotated tag v0.2.0 should appear in tags list, got: {:?}",
+            tag_names
+        );
+    }
+
+    #[test]
+    fn test_get_tags_returns_lightweight_tags() {
+        let (_dir, repo) = init_test_repo();
+        let head = repo.repo.head().unwrap().peel_to_commit().unwrap();
+
+        // Create a lightweight tag
+        repo.repo
+            .tag(
+                "v0.1.0",
+                head.as_object(),
+                &repo.repo.signature().unwrap(),
+                "",
+                false,
+            )
+            .unwrap();
+
+        let tags = repo.get_tags().unwrap();
+        let tag_names: Vec<&str> = tags.iter().map(|t| t.name.as_str()).collect();
+
+        assert!(
+            tag_names.contains(&"v0.1.0"),
+            "lightweight tag v0.1.0 should appear in tags list, got: {:?}",
+            tag_names
+        );
+    }
+
+    #[test]
+    fn test_get_tags_returns_mixed_annotated_and_lightweight() {
+        let (_dir, repo) = init_test_repo();
+        let sig = Signature::now("Test User", "test@example.com").unwrap();
+        let head = repo.repo.head().unwrap().peel_to_commit().unwrap();
+
+        // Create annotated tag
+        repo.repo
+            .tag("v0.2.0", head.as_object(), &sig, "annotated", false)
+            .unwrap();
+
+        // Create lightweight tag
+        repo.repo
+            .tag(
+                "v0.1.0",
+                head.as_object(),
+                &repo.repo.signature().unwrap(),
+                "",
+                false,
+            )
+            .unwrap();
+
+        let tags = repo.get_tags().unwrap();
+        let tag_names: Vec<&str> = tags.iter().map(|t| t.name.as_str()).collect();
+
+        assert!(
+            tag_names.contains(&"v0.2.0"),
+            "annotated tag should be present, got: {:?}",
+            tag_names
+        );
+        assert!(
+            tag_names.contains(&"v0.1.0"),
+            "lightweight tag should be present, got: {:?}",
+            tag_names
+        );
+        assert_eq!(tags.len(), 2, "should have exactly 2 tags");
+    }
+
+    #[test]
+    fn test_get_tags_target_points_to_commit_not_tag_object() {
+        let (_dir, repo) = init_test_repo();
+        let sig = Signature::now("Test User", "test@example.com").unwrap();
+        let head = repo.repo.head().unwrap().peel_to_commit().unwrap();
+        let expected_commit_id = head.id().to_string();
+
+        // Create annotated tag
+        repo.repo
+            .tag("v0.2.0", head.as_object(), &sig, "annotated", false)
+            .unwrap();
+
+        let tags = repo.get_tags().unwrap();
+        let tag = tags.iter().find(|t| t.name == "v0.2.0").unwrap();
+
+        assert_eq!(
+            tag.target, expected_commit_id,
+            "tag.target should be the commit OID, not the tag object OID"
+        );
+    }
+}

src/git/tag.rs

@@ -1,6 +1,7 @@
 use super::GitRepo;
 use anyhow::{Result, bail};
 use semver::Version;
+use std::path::Path;
 
 /// Tag builder for creating tags
 pub struct TagBuilder {
@@ -327,3 +328,456 @@ pub fn list_tags(
         Ok(filtered)
     }
 }
+
+/// Sort tags by semver version descending, then by time descending.
+/// Non-semver tags are placed after semver tags, sorted by time descending.
+pub fn sort_tags_by_semver(tags: &mut [super::TagInfo]) {
+    use semver::Version;
+
+    tags.sort_by(|a, b| {
+        match (
+            Version::parse(a.version_name()),
+            Version::parse(b.version_name()),
+        ) {
+            (Ok(va), Ok(vb)) => {
+                // Both semver: version descending, then time descending as tiebreaker
+                vb.cmp(&va).then_with(|| b.time.cmp(&a.time))
+            }
+            (Ok(_), Err(_)) => std::cmp::Ordering::Less,   // semver tags first
+            (Err(_), Ok(_)) => std::cmp::Ordering::Greater, // semver tags first
+            (Err(_), Err(_)) => b.time.cmp(&a.time),        // both non-semver: time descending
+        }
+    });
+}
+
+/// A version found in a project config file, tagged with its source.
+#[derive(Debug, Clone)]
+pub struct ConfigVersion {
+    /// Source file name, e.g. "Cargo.toml", "package.json"
+    pub source: String,
+    /// Parsed semantic version
+    pub version: Version,
+}
+
+/// Read project versions from all supported config files in the project root.
+///
+/// If `go.mod` exists the function returns an empty `Vec` immediately — Go projects
+/// use git tags as the version authority and store nothing in go.mod.
+///
+/// Otherwise every supported format is tried. Results are returned in a stable
+/// order (see `PARSER_ORDER`). Files that don't exist or whose version can't be
+/// parsed are silently skipped.
+pub fn read_project_versions(project_dir: &Path) -> Vec<ConfigVersion> {
+    // Go projects: go.mod has no version field; skip directly to commit analysis
+    if project_dir.join("go.mod").exists() {
+        return vec![];
+    }
+
+    let parsers: &[(&str, fn(&Path) -> Option<Version>)] = PARSER_ORDER;
+    let mut results = Vec::new();
+
+    for &(source, parser) in parsers {
+        if let Some(v) = parser(project_dir) {
+            results.push(ConfigVersion {
+                source: source.to_string(),
+                version: v,
+            });
+        }
+    }
+
+    results
+}
+
+/// Stable order for parser dispatch. No priority implied — all results are
+/// surfaced to the user when more than one is found.
+type Parser = fn(&Path) -> Option<Version>;
+const PARSER_ORDER: &[(&str, Parser)] = &[
+    ("Cargo.toml", try_cargo_toml),
+    ("package.json", try_package_json),
+    ("pyproject.toml", try_pyproject_toml),
+    ("pom.xml", try_pom_xml),
+    ("pubspec.yaml", try_pubspec_yaml),
+    ("build.sbt", try_build_sbt),
+    ("project.clj", try_project_clj),
+    ("mix.exs", try_mix_exs),
+    ("package.yaml", try_package_yaml),
+    ("Project.toml", try_project_toml_julia),
+    ("composer.json", try_composer_json),
+    (".csproj", try_csproj),
+    ("CMakeLists.txt", try_cmake_lists),
+    ("meson.build", try_meson_build),
+    (".gemspec", try_gemspec),
+];
+
+// ── Structured parsers ──────────────────────────────────────────────
+
+fn try_cargo_toml(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("Cargo.toml")).ok()?;
+    let value = content.parse::<toml::Value>().ok()?;
+    let version_str = value.get("package")?.get("version")?.as_str()?;
+    Version::parse(version_str).ok()
+}
+
+fn try_pyproject_toml(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("pyproject.toml")).ok()?;
+    let value = content.parse::<toml::Value>().ok()?;
+    let version_str = value.get("project")?.get("version")?.as_str()?;
+    Version::parse(version_str).ok()
+}
+
+fn try_project_toml_julia(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("Project.toml")).ok()?;
+    let value = content.parse::<toml::Value>().ok()?;
+    let version_str = value.get("version")?.as_str()?;
+    Version::parse(version_str).ok()
+}
+
+fn try_package_json(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("package.json")).ok()?;
+    let value: serde_json::Value = serde_json::from_str(&content).ok()?;
+    let version_str = value.get("version")?.as_str()?;
+    Version::parse(version_str).ok()
+}
+
+fn try_composer_json(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("composer.json")).ok()?;
+    let value: serde_json::Value = serde_json::from_str(&content).ok()?;
+    let version_str = value.get("version")?.as_str()?;
+    Version::parse(version_str).ok()
+}
+
+fn try_pom_xml(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("pom.xml")).ok()?;
+    let doc = roxmltree::Document::parse(&content).ok()?;
+    let project = doc.root_element();
+    // Read <version> that is a direct child of <project>, not inside <parent>
+    for child in project.children() {
+        if child.is_element() && child.tag_name().name() == "version" {
+            if let Some(t) = child.text() {
+                return Version::parse(t.trim()).ok();
+            }
+        }
+    }
+    None
+}
+
+fn try_csproj(dir: &Path) -> Option<Version> {
+    // Find any .csproj file in the root (take the first)
+    let csproj = std::fs::read_dir(dir)
+        .ok()?
+        .filter_map(|e| e.ok())
+        .map(|e| e.path())
+        .find(|p| p.extension().map_or(false, |ext| ext == "csproj"))?;
+    let content = std::fs::read_to_string(&csproj).ok()?;
+    let doc = roxmltree::Document::parse(&content).ok()?;
+    // Look for <Version> (preferred) or <VersionPrefix> anywhere in the document
+    for node in doc.descendants() {
+        if node.is_element() {
+            match node.tag_name().name() {
+                "Version" => {
+                    if let Some(t) = node.text() {
+                        return Version::parse(t.trim()).ok();
+                    }
+                }
+                "VersionPrefix" => {
+                    if let Some(t) = node.text() {
+                        return Version::parse(t.trim()).ok();
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+    None
+}
+
+// ── Regex-based parsers (code-as-config or simple data formats) ─────
+
+fn try_pubspec_yaml(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("pubspec.yaml")).ok()?;
+    let re =
+        regex::Regex::new(r##"(?m)^version\s*:\s*['"]?(\d+\.\d+\.\d+[^'"#\s]*)['"]?"##).ok()?;
+    let caps = re.captures(&content)?;
+    Version::parse(caps.get(1)?.as_str()).ok()
+}
+
+fn try_package_yaml(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("package.yaml")).ok()?;
+    let re =
+        regex::Regex::new(r##"(?m)^version\s*:\s*['"]?(\d+\.\d+\.\d+[^'"#\s]*)['"]?"##).ok()?;
+    let caps = re.captures(&content)?;
+    Version::parse(caps.get(1)?.as_str()).ok()
+}
+
+fn try_gemspec(dir: &Path) -> Option<Version> {
+    // A directory may contain multiple .gemspec files; take the first.
+    let gemspec = std::fs::read_dir(dir)
+        .ok()?
+        .filter_map(|e| e.ok())
+        .map(|e| e.path())
+        .find(|p| p.extension().map_or(false, |ext| ext == "gemspec"))?;
+    let content = std::fs::read_to_string(&gemspec).ok()?;
+    let re =
+        regex::Regex::new(r#"spec\.version\s*=\s*["'](\d+\.\d+\.\d+[^"']*)["']"#).ok()?;
+    let caps = re.captures(&content)?;
+    Version::parse(caps.get(1)?.as_str()).ok()
+}
+
+fn try_build_sbt(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("build.sbt")).ok()?;
+    let re = regex::Regex::new(r#"version\s*:=\s*["'](\d+\.\d+\.\d+[^"']*)["']"#).ok()?;
+    let caps = re.captures(&content)?;
+    Version::parse(caps.get(1)?.as_str()).ok()
+}
+
+fn try_project_clj(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("project.clj")).ok()?;
+    let re = regex::Regex::new(r#"\(defproject\s+[^\s]+\s+"(\d+\.\d+\.\d+[^"]*)""#).ok()?;
+    let caps = re.captures(&content)?;
+    Version::parse(caps.get(1)?.as_str()).ok()
+}
+
+fn try_mix_exs(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("mix.exs")).ok()?;
+    let re = regex::Regex::new(r#"version\s*:\s*["'](\d+\.\d+\.\d+[^"']*)["']"#).ok()?;
+    let caps = re.captures(&content)?;
+    Version::parse(caps.get(1)?.as_str()).ok()
+}
+
+fn try_cmake_lists(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("CMakeLists.txt")).ok()?;
+    let re =
+        regex::Regex::new(r"project\s*\([^)]*VERSION\s+(\d+\.\d+\.\d+[^\s)]*)").ok()?;
+    let caps = re.captures(&content)?;
+    Version::parse(caps.get(1)?.as_str()).ok()
+}
+
+fn try_meson_build(dir: &Path) -> Option<Version> {
+    let content = std::fs::read_to_string(dir.join("meson.build")).ok()?;
+    let re =
+        regex::Regex::new(r#"version\s*:\s*["'](\d+\.\d+\.\d+[^"']*)["']"#).ok()?;
+    let caps = re.captures(&content)?;
+    Version::parse(caps.get(1)?.as_str()).ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::git::TagInfo;
+
+    fn make_tag(name: &str, time: i64) -> TagInfo {
+        TagInfo {
+            name: name.to_string(),
+            target: "abc123".to_string(),
+            message: String::new(),
+            time,
+        }
+    }
+
+    #[test]
+    fn test_sort_by_semver_descending() {
+        let mut tags = vec![
+            make_tag("v1.0.0", 100),
+            make_tag("v2.0.0", 200),
+            make_tag("v1.5.0", 150),
+        ];
+        sort_tags_by_semver(&mut tags);
+        let names: Vec<&str> = tags.iter().map(|t| t.name.as_str()).collect();
+        assert_eq!(names, vec!["v2.0.0", "v1.5.0", "v1.0.0"]);
+    }
+
+    #[test]
+    fn test_sort_semver_ties_broken_by_time() {
+        let mut tags = vec![
+            make_tag("v1.0.0", 100),
+            make_tag("v1.0.0", 300),
+            make_tag("v1.0.0", 200),
+        ];
+        sort_tags_by_semver(&mut tags);
+        let times: Vec<i64> = tags.iter().map(|t| t.time).collect();
+        assert_eq!(times, vec![300, 200, 100]);
+    }
+
+    #[test]
+    fn test_sort_non_semver_tags_at_end() {
+        let mut tags = vec![
+            make_tag("release-2024", 400),
+            make_tag("v1.0.0", 100),
+            make_tag("staging", 300),
+            make_tag("v0.2.0", 200),
+        ];
+        sort_tags_by_semver(&mut tags);
+        let names: Vec<&str> = tags.iter().map(|t| t.name.as_str()).collect();
+        assert_eq!(names[0], "v1.0.0");
+        assert_eq!(names[1], "v0.2.0");
+        assert_eq!(names[2], "release-2024");
+        assert_eq!(names[3], "staging");
+    }
+
+    #[test]
+    fn test_sort_no_prefix_semver() {
+        let mut tags = vec![
+            make_tag("1.0.0", 100),
+            make_tag("2.0.0", 200),
+            make_tag("0.1.0", 50),
+        ];
+        sort_tags_by_semver(&mut tags);
+        let names: Vec<&str> = tags.iter().map(|t| t.name.as_str()).collect();
+        assert_eq!(names, vec!["2.0.0", "1.0.0", "0.1.0"]);
+    }
+
+    #[test]
+    fn test_sort_all_non_semver_by_time() {
+        let mut tags = vec![
+            make_tag("release-2024", 100),
+            make_tag("release-2023", 300),
+            make_tag("beta", 200),
+        ];
+        sort_tags_by_semver(&mut tags);
+        let times: Vec<i64> = tags.iter().map(|t| t.time).collect();
+        assert_eq!(times, vec![300, 200, 100]);
+    }
+
+    #[test]
+    fn test_read_versions_cargo_toml() {
+        let dir = tempfile::TempDir::new().unwrap();
+        std::fs::write(
+            dir.path().join("Cargo.toml"),
+            "[package]\nname = \"test\"\nversion = \"0.3.0\"\n",
+        )
+        .unwrap();
+        let versions = read_project_versions(dir.path());
+        assert_eq!(versions.len(), 1);
+        assert_eq!(versions[0].source, "Cargo.toml");
+        assert_eq!(versions[0].version, Version::new(0, 3, 0));
+    }
+
+    #[test]
+    fn test_read_versions_pyproject_toml() {
+        let dir = tempfile::TempDir::new().unwrap();
+        std::fs::write(
+            dir.path().join("pyproject.toml"),
+            "[project]\nname = \"test\"\nversion = \"0.2.1\"\n",
+        )
+        .unwrap();
+        let versions = read_project_versions(dir.path());
+        assert_eq!(versions.len(), 1);
+        assert_eq!(versions[0].source, "pyproject.toml");
+        assert_eq!(versions[0].version, Version::new(0, 2, 1));
+    }
+
+    #[test]
+    fn test_read_versions_no_config_files() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let versions = read_project_versions(dir.path());
+        assert!(versions.is_empty());
+    }
+
+    #[test]
+    fn test_read_versions_multiple_configs_returns_all() {
+        let dir = tempfile::TempDir::new().unwrap();
+        std::fs::write(
+            dir.path().join("Cargo.toml"),
+            "[package]\nname = \"test\"\nversion = \"0.3.0\"\n",
+        )
+        .unwrap();
+        std::fs::write(
+            dir.path().join("pyproject.toml"),
+            "[project]\nname = \"test\"\nversion = \"0.2.1\"\n",
+        )
+        .unwrap();
+        let versions = read_project_versions(dir.path());
+        assert_eq!(versions.len(), 2);
+        // Order is defined by PARSER_ORDER: Cargo.toml before pyproject.toml
+        assert_eq!(versions[0].source, "Cargo.toml");
+        assert_eq!(versions[0].version, Version::new(0, 3, 0));
+        assert_eq!(versions[1].source, "pyproject.toml");
+        assert_eq!(versions[1].version, Version::new(0, 2, 1));
+    }
+
+    #[test]
+    fn test_read_versions_package_json() {
+        let dir = tempfile::TempDir::new().unwrap();
+        std::fs::write(
+            dir.path().join("package.json"),
+            r#"{"name": "test", "version": "1.2.3"}"#,
+        )
+        .unwrap();
+        let versions = read_project_versions(dir.path());
+        assert_eq!(versions.len(), 1);
+        assert_eq!(versions[0].source, "package.json");
+        assert_eq!(versions[0].version, Version::new(1, 2, 3));
+    }
+
+    #[test]
+    fn test_read_versions_pom_xml() {
+        let dir = tempfile::TempDir::new().unwrap();
+        std::fs::write(
+            dir.path().join("pom.xml"),
+            "<project><modelVersion>4.0.0</modelVersion><version>2.0.0</version></project>",
+        )
+        .unwrap();
+        let versions = read_project_versions(dir.path());
+        assert_eq!(versions.len(), 1);
+        assert_eq!(versions[0].source, "pom.xml");
+        assert_eq!(versions[0].version, Version::new(2, 0, 0));
+    }
+
+    #[test]
+    fn test_read_versions_pom_xml_ignores_parent_version() {
+        let dir = tempfile::TempDir::new().unwrap();
+        std::fs::write(
+            dir.path().join("pom.xml"),
+            "<project><parent><version>3.0.0</version></parent><version>2.0.0</version></project>",
+        )
+        .unwrap();
+        let versions = read_project_versions(dir.path());
+        assert_eq!(versions.len(), 1);
+        assert_eq!(versions[0].version, Version::new(2, 0, 0));
+    }
+
+    #[test]
+    fn test_read_versions_pubspec_yaml() {
+        let dir = tempfile::TempDir::new().unwrap();
+        std::fs::write(
+            dir.path().join("pubspec.yaml"),
+            "name: myapp\nversion: 1.0.0+1\n",
+        )
+        .unwrap();
+        let versions = read_project_versions(dir.path());
+        assert_eq!(versions.len(), 1);
+        assert_eq!(versions[0].source, "pubspec.yaml");
+        assert_eq!(
+            versions[0].version,
+            Version::parse("1.0.0+1").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_read_versions_go_mod_skips_all() {
+        let dir = tempfile::TempDir::new().unwrap();
+        std::fs::write(dir.path().join("go.mod"), "module example.com/m\n").unwrap();
+        std::fs::write(
+            dir.path().join("Cargo.toml"),
+            "[package]\nname = \"test\"\nversion = \"0.3.0\"\n",
+        )
+        .unwrap();
+        // go.mod triggers immediate return — Cargo.toml is ignored
+        let versions = read_project_versions(dir.path());
+        assert!(versions.is_empty());
+    }
+
+    #[test]
+    fn test_read_versions_project_toml_julia() {
+        let dir = tempfile::TempDir::new().unwrap();
+        std::fs::write(
+            dir.path().join("Project.toml"),
+            "name = \"MyPkg\"\nversion = \"0.1.0\"\n",
+        )
+        .unwrap();
+        let versions = read_project_versions(dir.path());
+        assert_eq!(versions.len(), 1);
+        assert_eq!(versions[0].source, "Project.toml");
+        assert_eq!(versions[0].version, Version::new(0, 1, 0));
+    }
+}

src/lib.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 pub mod commands;
 pub mod config;
 pub mod generator;

src/llm/anthropic.rs

@@ -1,655 +0,0 @@
-use super::thinking::ThinkingStateManager;
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result, bail};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::time::Duration;
-
-/// Anthropic Claude API client
-pub struct AnthropicClient {
-    api_key: String,
-    model: String,
-    client: reqwest::Client,
-    thinking_enabled: bool,
-    thinking_budget_tokens: u32,
-    max_tokens: u32,
-    temperature: f32,
-    top_p: Option<f32>,
-    thinking_state: Option<Arc<ThinkingStateManager>>,
-}
-
-#[derive(Debug, Serialize)]
-struct MessagesRequest {
-    model: String,
-    max_tokens: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    top_p: Option<f32>,
-    messages: Vec<AnthropicMessage>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    system: Option<Vec<SystemContent>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    thinking: Option<ThinkingConfig>,
-    stream: bool,
-}
-
-#[derive(Debug, Serialize, Clone)]
-struct SystemContent {
-    #[serde(rename = "type")]
-    content_type: String,
-    text: String,
-}
-
-#[derive(Debug, Serialize)]
-struct ThinkingConfig {
-    #[serde(rename = "type")]
-    thinking_type: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    budget_tokens: Option<u32>,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-struct AnthropicMessage {
-    role: String,
-    content: AnthropicContent,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(untagged)]
-enum AnthropicContent {
-    Text(String),
-    Blocks(Vec<ContentBlock>),
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-struct ContentBlock {
-    #[serde(rename = "type")]
-    content_type: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    text: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct MessagesResponse {
-    content: Vec<ResponseContentBlock>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ResponseContentBlock {
-    #[serde(rename = "type")]
-    content_type: String,
-    text: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct ErrorResponse {
-    error: AnthropicError,
-}
-
-#[derive(Debug, Deserialize)]
-struct AnthropicError {
-    #[serde(rename = "type")]
-    error_type: String,
-    message: String,
-}
-
-// --- Streaming SSE event structures ---
-
-#[derive(Debug, Deserialize)]
-struct SseEvent {
-    #[serde(rename = "type")]
-    event_type: String,
-    #[serde(default)]
-    message: Option<SseMessage>,
-    #[serde(default)]
-    index: Option<u32>,
-    #[serde(default)]
-    content_block: Option<SseContentBlock>,
-    #[serde(default)]
-    delta: Option<SseDelta>,
-    #[serde(default)]
-    usage: Option<SseUsage>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SseMessage {
-    #[serde(default)]
-    content: Option<Vec<SseContentBlock>>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SseContentBlock {
-    #[serde(rename = "type")]
-    content_type: String,
-    #[serde(default)]
-    thinking: Option<String>,
-    #[serde(default)]
-    text: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SseDelta {
-    #[serde(rename = "type")]
-    delta_type: Option<String>,
-    #[serde(default)]
-    thinking: Option<String>,
-    #[serde(default)]
-    text: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SseUsage {
-    #[serde(default)]
-    output_tokens: Option<u32>,
-}
-
-impl AnthropicClient {
-    pub fn new(api_key: &str, model: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(60))?;
-
-        Ok(Self {
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            thinking_budget_tokens: 1024,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
-        self.client = create_http_client(timeout)?;
-        Ok(self)
-    }
-
-    pub fn with_thinking(mut self, enabled: bool) -> Self {
-        self.thinking_enabled = enabled;
-        self
-    }
-
-    pub fn with_thinking_budget_tokens(mut self, budget_tokens: u32) -> Self {
-        self.thinking_budget_tokens = budget_tokens;
-        self
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_top_p(mut self, top_p: f32) -> Self {
-        self.top_p = Some(top_p);
-        self
-    }
-
-    pub fn with_thinking_state(mut self, state: Arc<ThinkingStateManager>) -> Self {
-        self.thinking_state = Some(state);
-        self
-    }
-
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        Ok(ANTHROPIC_MODELS.iter().map(|&m| m.to_string()).collect())
-    }
-
-    pub async fn validate_key(&self) -> Result<bool> {
-        let url = "https://api.anthropic.com/v1/messages";
-
-        let request = MessagesRequest {
-            model: self.model.clone(),
-            max_tokens: 5,
-            temperature: Some(0.0),
-            top_p: None,
-            messages: vec![AnthropicMessage {
-                role: "user".to_string(),
-                content: AnthropicContent::Text("Hi".to_string()),
-            }],
-            system: None,
-            thinking: None,
-            stream: false,
-        };
-
-        let response = self
-            .client
-            .post(url)
-            .header("x-api-key", &self.api_key)
-            .header("anthropic-version", "2023-06-01")
-            .header("Content-Type", "application/json")
-            .json(&request)
-            .send()
-            .await;
-
-        match response {
-            Ok(resp) => {
-                if resp.status().is_success() {
-                    Ok(true)
-                } else {
-                    let status = resp.status();
-                    if status.as_u16() == 401 {
-                        Ok(false)
-                    } else {
-                        let text = resp.text().await.unwrap_or_default();
-                        bail!("Anthropic API error: {} - {}", status, text)
-                    }
-                }
-            }
-            Err(e) => Err(e.into()),
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for AnthropicClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![AnthropicMessage {
-            role: "user".to_string(),
-            content: AnthropicContent::Text(prompt.to_string()),
-        }];
-
-        self.messages_request_with_retry(messages, None).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let messages = vec![AnthropicMessage {
-            role: "user".to_string(),
-            content: AnthropicContent::Text(user.to_string()),
-        }];
-
-        let system = if system.is_empty() {
-            None
-        } else {
-            Some(vec![SystemContent {
-                content_type: "text".to_string(),
-                text: system.to_string(),
-            }])
-        };
-
-        self.messages_request_with_retry(messages, system).await
-    }
-
-    async fn is_available(&self) -> bool {
-        self.validate_key().await.unwrap_or(false)
-    }
-
-    fn name(&self) -> &str {
-        "anthropic"
-    }
-}
-
-impl AnthropicClient {
-    async fn messages_request_with_retry(
-        &self,
-        messages: Vec<AnthropicMessage>,
-        system: Option<Vec<SystemContent>>,
-    ) -> Result<String> {
-        let mut last_error = None;
-
-        for attempt in 1..=3 {
-            match self
-                .messages_request(messages.clone(), system.clone())
-                .await
-            {
-                Ok(result) => return Ok(result),
-                Err(e) => {
-                    let err_msg = e.to_string();
-                    let is_retryable = err_msg.contains("timeout")
-                        || err_msg.contains("connection")
-                        || err_msg.contains("temporary")
-                        || err_msg.contains("5")
-                            && (err_msg.contains("500")
-                                || err_msg.contains("502")
-                                || err_msg.contains("503")
-                                || err_msg.contains("504"));
-
-                    if !is_retryable || attempt == 3 {
-                        last_error = Some(e);
-                        break;
-                    }
-
-                    tokio::time::sleep(Duration::from_millis(500 * 2u64.pow(attempt - 1))).await;
-                }
-            }
-        }
-
-        Err(last_error.unwrap_or_else(|| anyhow::anyhow!("Request failed after retries")))
-    }
-
-    async fn messages_request(
-        &self,
-        messages: Vec<AnthropicMessage>,
-        system: Option<Vec<SystemContent>>,
-    ) -> Result<String> {
-        if self.thinking_enabled {
-            self.streaming_messages_request(messages, system).await
-        } else {
-            self.non_streaming_messages_request(messages, system).await
-        }
-    }
-
-    async fn non_streaming_messages_request(
-        &self,
-        messages: Vec<AnthropicMessage>,
-        system: Option<Vec<SystemContent>>,
-    ) -> Result<String> {
-        let url = "https://api.anthropic.com/v1/messages";
-
-        let temperature = if self.temperature == 0.0 {
-            None
-        } else {
-            Some(self.temperature)
-        };
-
-        let request = MessagesRequest {
-            model: self.model.clone(),
-            max_tokens: self.max_tokens,
-            temperature,
-            top_p: self.top_p,
-            messages,
-            system,
-            thinking: Some(ThinkingConfig {
-                thinking_type: "disabled".to_string(),
-                budget_tokens: None,
-            }),
-            stream: false,
-        };
-
-        let response = self
-            .client
-            .post(url)
-            .header("x-api-key", &self.api_key)
-            .header("anthropic-version", "2023-06-01")
-            .header("Content-Type", "application/json")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send request to Anthropic")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "Anthropic API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("Anthropic API error: {} - {}", status, text);
-        }
-
-        let result: MessagesResponse = response
-            .json()
-            .await
-            .context("Failed to parse Anthropic response")?;
-
-        result
-            .content
-            .into_iter()
-            .find(|c| c.content_type == "text")
-            .map(|c| c.text.trim().to_string())
-            .filter(|s| !s.is_empty())
-            .ok_or_else(|| anyhow::anyhow!("No text response from Anthropic"))
-    }
-
-    /// Streaming request for thinking mode, filters thinking content blocks
-    async fn streaming_messages_request(
-        &self,
-        messages: Vec<AnthropicMessage>,
-        system: Option<Vec<SystemContent>>,
-    ) -> Result<String> {
-        let url = "https://api.anthropic.com/v1/messages";
-
-        let thinking = ThinkingConfig {
-            thinking_type: "enabled".to_string(),
-            budget_tokens: Some(self.thinking_budget_tokens),
-        };
-
-        // max_tokens must exceed budget_tokens
-        let max_tokens = (self.max_tokens).max(self.thinking_budget_tokens + 100);
-
-        let request = MessagesRequest {
-            model: self.model.clone(),
-            max_tokens,
-            temperature: None, // must be omitted for thinking mode
-            top_p: None,
-            messages,
-            system,
-            thinking: Some(thinking),
-            stream: true,
-        };
-
-        let response = self
-            .client
-            .post(url)
-            .header("x-api-key", &self.api_key)
-            .header("anthropic-version", "2023-06-01")
-            .header("Content-Type", "application/json")
-            .header("Accept", "text/event-stream")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send streaming request to Anthropic")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "Anthropic API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("Anthropic API error: {} - {}", status, text);
-        }
-
-        let mut content_buffer = String::new();
-        let mut in_thinking = false;
-        let mut has_reasoning = false;
-        let mut has_content = false;
-
-        let thinking_state = self.thinking_state.as_ref();
-
-        let mut byte_stream = response.bytes_stream();
-        let mut line_buffer = String::new();
-
-        use futures_util::StreamExt;
-
-        while let Some(chunk) = byte_stream.next().await {
-            let chunk = chunk.context("Failed to read streaming response chunk")?;
-            let chunk_str =
-                String::from_utf8(chunk.to_vec()).context("Invalid UTF-8 in stream chunk")?;
-
-            line_buffer.push_str(&chunk_str);
-
-            while let Some(line_end) = line_buffer.find('\n') {
-                let line = line_buffer[..line_end].trim().to_string();
-                line_buffer = line_buffer[line_end + 1..].to_string();
-
-                if line.is_empty() {
-                    continue;
-                }
-
-                // Parse SSE event line
-                if let Some(data) = line.strip_prefix("data: ") {
-                    if let Ok(event) = serde_json::from_str::<SseEvent>(data) {
-                        match event.event_type.as_str() {
-                            "content_block_start" => {
-                                if let Some(ref block) = event.content_block {
-                                    if block.content_type == "thinking" {
-                                        in_thinking = true;
-                                        if !has_reasoning {
-                                            has_reasoning = true;
-                                            if let Some(state) = thinking_state {
-                                                state.start_thinking();
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            "content_block_delta" => {
-                                if let Some(ref delta) = event.delta {
-                                    // Thinking delta - ignore content but track state
-                                    if delta.thinking.is_some() {
-                                        continue;
-                                    }
-
-                                    // Text delta - collect
-                                    if in_thinking && delta.text.is_some() {
-                                        // Transition from thinking to text
-                                        if let Some(state) = thinking_state {
-                                            state.end_thinking();
-                                        }
-                                        in_thinking = false;
-                                    }
-                                    if let Some(ref text) = delta.text
-                                        && !text.is_empty()
-                                    {
-                                        has_content = true;
-                                        content_buffer.push_str(text);
-                                    }
-                                }
-                            }
-                            "content_block_stop" => {
-                                if in_thinking {
-                                    if let Some(state) = thinking_state {
-                                        state.end_thinking();
-                                    }
-                                    in_thinking = false;
-                                }
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-            }
-        }
-
-        // Ensure thinking state is ended
-        if let Some(state) = thinking_state {
-            state.end_thinking();
-        }
-
-        let result = content_buffer.trim().to_string();
-
-        if result.is_empty() {
-            if has_reasoning && !has_content {
-                bail!(
-                    "Anthropic returned thinking content but no final answer. \
-                     The model may have entered an incomplete thinking state. \
-                     Please try again or disable thinking mode."
-                );
-            }
-            bail!(
-                "No response from Anthropic. \
-                 If thinking mode is enabled, try disabling it or ensure the model supports it."
-            );
-        }
-
-        Ok(result)
-    }
-}
-
-/// Available Anthropic models (Claude 4 series with extended thinking)
-pub const ANTHROPIC_MODELS: &[&str] = &[
-    "claude-opus-4-7",
-    "claude-sonnet-4-6",
-    "claude-haiku-4-5",
-    // Legacy models
-    "claude-3-opus-20240229",
-    "claude-3-sonnet-20240229",
-    "claude-3-haiku-20240307",
-    "claude-2.1",
-    "claude-2.0",
-    "claude-instant-1.2",
-];
-
-pub fn is_valid_model(model: &str) -> bool {
-    ANTHROPIC_MODELS.contains(&model)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_validation_claude4() {
-        assert!(is_valid_model("claude-opus-4-7"));
-        assert!(is_valid_model("claude-sonnet-4-6"));
-        assert!(is_valid_model("claude-haiku-4-5"));
-        assert!(is_valid_model("claude-3-sonnet-20240229"));
-        assert!(!is_valid_model("invalid-model"));
-    }
-
-    #[test]
-    fn test_thinking_config_serialization() {
-        let config = ThinkingConfig {
-            thinking_type: "enabled".to_string(),
-            budget_tokens: Some(2048),
-        };
-        let json = serde_json::to_string(&config).unwrap();
-        assert!(json.contains(r#""type":"enabled""#));
-        assert!(json.contains(r#""budget_tokens":2048"#));
-    }
-
-    #[test]
-    fn test_thinking_config_disabled_serialization() {
-        let config = ThinkingConfig {
-            thinking_type: "disabled".to_string(),
-            budget_tokens: None,
-        };
-        let json = serde_json::to_string(&config).unwrap();
-        assert_eq!(json, r#"{"type":"disabled"}"#);
-    }
-
-    #[test]
-    fn test_system_content_serialization() {
-        let content = SystemContent {
-            content_type: "text".to_string(),
-            text: "You are helpful.".to_string(),
-        };
-        let json = serde_json::to_string(&content).unwrap();
-        assert!(json.contains(r#""type":"text""#));
-    }
-
-    #[test]
-    fn test_sse_event_parsing_content_block_start() {
-        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!(event.content_block.unwrap().content_type, "thinking");
-    }
-
-    #[test]
-    fn test_sse_event_parsing_text_delta() {
-        let json = r#"{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}"#;
-        let event: SseEvent = serde_json::from_str(json).unwrap();
-        assert_eq!(event.event_type, "content_block_delta");
-        assert_eq!(event.delta.unwrap().text, Some("Hello".to_string()));
-    }
-
-    #[test]
-    fn test_anthropic_content_text() {
-        let msg = AnthropicMessage {
-            role: "user".to_string(),
-            content: AnthropicContent::Text("Hello".to_string()),
-        };
-        let json = serde_json::to_string(&msg).unwrap();
-        assert!(json.contains(r#""content":"Hello""#));
-    }
-}

src/llm/deepseek.rs

@@ -1,622 +0,0 @@
-use super::thinking::ThinkingStateManager;
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result, bail};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::time::Duration;
-
-/// DeepSeek API client
-pub struct DeepSeekClient {
-    base_url: String,
-    api_key: String,
-    model: String,
-    client: reqwest::Client,
-    thinking_enabled: bool,
-    reasoning_effort: Option<String>,
-    max_tokens: u32,
-    temperature: f32,
-    thinking_state: Option<Arc<ThinkingStateManager>>,
-}
-
-#[derive(Debug, Serialize)]
-struct ChatCompletionRequest {
-    model: String,
-    messages: Vec<Message>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    top_p: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    presence_penalty: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    frequency_penalty: Option<f32>,
-    stream: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    thinking: Option<ThinkingConfig>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    reasoning_effort: Option<String>,
-}
-
-#[derive(Debug, Serialize)]
-struct ThinkingConfig {
-    #[serde(rename = "type")]
-    thinking_type: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct Message {
-    role: String,
-    content: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    reasoning_content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChatCompletionResponse {
-    choices: Vec<Choice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Choice {
-    message: Message,
-    #[serde(default)]
-    reasoning_content: Option<String>,
-}
-
-// --- Streaming response structures ---
-
-#[derive(Debug, Deserialize)]
-struct StreamChunk {
-    choices: Vec<StreamChoice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct StreamChoice {
-    delta: StreamDelta,
-    #[serde(default)]
-    finish_reason: Option<String>,
-    index: Option<u32>,
-}
-
-#[derive(Debug, Deserialize, Default)]
-struct StreamDelta {
-    #[serde(default)]
-    content: Option<String>,
-    #[serde(default)]
-    reasoning_content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ErrorResponse {
-    error: ApiError,
-}
-
-#[derive(Debug, Deserialize)]
-struct ApiError {
-    message: String,
-    #[serde(rename = "type")]
-    error_type: String,
-}
-
-impl DeepSeekClient {
-    pub fn new(api_key: &str, model: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(300))?;
-
-        Ok(Self {
-            base_url: "https://api.deepseek.com".to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            reasoning_effort: None,
-            max_tokens: 500,
-            temperature: 0.7,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_base_url(api_key: &str, model: &str, base_url: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(300))?;
-
-        Ok(Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            reasoning_effort: None,
-            max_tokens: 500,
-            temperature: 0.7,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
-        self.client = create_http_client(timeout)?;
-        Ok(self)
-    }
-
-    pub fn with_thinking(mut self, enabled: bool) -> Self {
-        self.thinking_enabled = enabled;
-        self
-    }
-
-    pub fn with_reasoning_effort(mut self, effort: Option<String>) -> Self {
-        self.reasoning_effort = effort;
-        self
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_thinking_state(mut self, state: Arc<ThinkingStateManager>) -> Self {
-        self.thinking_state = Some(state);
-        self
-    }
-
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        let url = format!("{}/models", self.base_url);
-
-        let response = self
-            .client
-            .get(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .send()
-            .await
-            .context("Failed to list DeepSeek models")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            bail!("DeepSeek API error: {} - {}", status, text);
-        }
-
-        #[derive(Deserialize)]
-        struct ModelsResponse {
-            data: Vec<ModelId>,
-        }
-
-        #[derive(Deserialize)]
-        struct ModelId {
-            id: String,
-        }
-
-        let result: ModelsResponse = response
-            .json()
-            .await
-            .context("Failed to parse DeepSeek response")?;
-
-        Ok(result.data.into_iter().map(|m| m.id).collect())
-    }
-
-    pub async fn validate_key(&self) -> Result<bool> {
-        match self.list_models().await {
-            Ok(_) => Ok(true),
-            Err(e) => {
-                let err_str = e.to_string();
-                if err_str.contains("401") || err_str.contains("Unauthorized") {
-                    Ok(false)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for DeepSeekClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![Message {
-            role: "user".to_string(),
-            content: prompt.to_string(),
-            reasoning_content: None,
-        }];
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let mut messages = vec![];
-
-        if !system.is_empty() {
-            messages.push(Message {
-                role: "system".to_string(),
-                content: system.to_string(),
-                reasoning_content: None,
-            });
-        }
-
-        messages.push(Message {
-            role: "user".to_string(),
-            content: user.to_string(),
-            reasoning_content: None,
-        });
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn is_available(&self) -> bool {
-        self.validate_key().await.unwrap_or(false)
-    }
-
-    fn name(&self) -> &str {
-        "deepseek"
-    }
-}
-
-impl DeepSeekClient {
-    async fn chat_completion_with_retry(&self, messages: Vec<Message>) -> Result<String> {
-        let mut last_error = None;
-
-        for attempt in 1..=3 {
-            match self.chat_completion(messages.clone()).await {
-                Ok(result) => return Ok(result),
-                Err(e) => {
-                    let err_msg = e.to_string();
-                    // 网络临时错误才重试
-                    let is_retryable = err_msg.contains("timeout")
-                        || err_msg.contains("connection")
-                        || err_msg.contains("temporary")
-                        || err_msg.contains("5")
-                            && (err_msg.contains("500")
-                                || err_msg.contains("502")
-                                || err_msg.contains("503")
-                                || err_msg.contains("504"));
-
-                    if !is_retryable || attempt == 3 {
-                        last_error = Some(e);
-                        break;
-                    }
-
-                    // 指数退避
-                    tokio::time::sleep(Duration::from_millis(500 * 2u64.pow(attempt - 1))).await;
-                }
-            }
-        }
-
-        Err(last_error.unwrap_or_else(|| anyhow::anyhow!("Request failed after retries")))
-    }
-
-    async fn chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!("{}/chat/completions", self.base_url);
-
-        let thinking = Some(ThinkingConfig {
-            thinking_type: if self.thinking_enabled {
-                "enabled".to_string()
-            } else {
-                "disabled".to_string()
-            },
-        });
-
-        // 思考模式下，temperature/top_p 等参数不应传递
-        // 非思考模式下可以正常传递
-        let (temperature, max_tokens, top_p, presence_penalty, frequency_penalty) =
-            if self.thinking_enabled {
-                (None, Some(self.max_tokens), None, None, None)
-            } else {
-                (
-                    Some(self.temperature),
-                    Some(self.max_tokens),
-                    None,
-                    None,
-                    None,
-                )
-            };
-
-        let reasoning_effort = if self.thinking_enabled {
-            self.reasoning_effort.clone()
-        } else {
-            None
-        };
-
-        let request = ChatCompletionRequest {
-            model: self.model.clone(),
-            messages: messages.clone(),
-            max_tokens,
-            temperature,
-            top_p,
-            presence_penalty,
-            frequency_penalty,
-            stream: self.thinking_enabled,
-            thinking,
-            reasoning_effort,
-        };
-
-        if self.thinking_enabled {
-            self.streaming_chat_completion(&url, &request).await
-        } else {
-            self.non_streaming_chat_completion(&url, &request).await
-        }
-    }
-
-    /// 非流式请求（非思考模式）
-    async fn non_streaming_chat_completion(
-        &self,
-        url: &str,
-        request: &ChatCompletionRequest,
-    ) -> Result<String> {
-        let response = self
-            .client
-            .post(url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .json(request)
-            .send()
-            .await
-            .context("Failed to send request to DeepSeek")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "DeepSeek API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("DeepSeek API error: {} - {}", status, text);
-        }
-
-        let result: ChatCompletionResponse = response
-            .json()
-            .await
-            .context("Failed to parse DeepSeek response")?;
-
-        result
-            .choices
-            .into_iter()
-            .next()
-            .map(|c| c.message.content.trim().to_string())
-            .filter(|s| !s.is_empty())
-            .ok_or_else(|| anyhow::anyhow!("No response from DeepSeek"))
-    }
-
-    /// 流式请求（思考模式），处理 reasoning_content 和 content
-    async fn streaming_chat_completion(
-        &self,
-        url: &str,
-        request: &ChatCompletionRequest,
-    ) -> Result<String> {
-        let response = self
-            .client
-            .post(url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .header("Accept", "text/event-stream")
-            .json(request)
-            .send()
-            .await
-            .context("Failed to send streaming request to DeepSeek")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "DeepSeek API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("DeepSeek API error: {} - {}", status, text);
-        }
-
-        let mut content_buffer = String::new();
-        let mut has_reasoning = false;
-        let mut has_content = false;
-        let mut stream_ended = false;
-
-        let thinking_state = self.thinking_state.as_ref();
-
-        let mut byte_stream = response.bytes_stream();
-        let mut line_buffer = String::new();
-
-        use futures_util::StreamExt;
-
-        while let Some(chunk) = byte_stream.next().await {
-            let chunk = chunk.context("Failed to read streaming response chunk")?;
-            let chunk_str =
-                String::from_utf8(chunk.to_vec()).context("Invalid UTF-8 in stream chunk")?;
-
-            line_buffer.push_str(&chunk_str);
-
-            // 处理完整行
-            while let Some(line_end) = line_buffer.find('\n') {
-                let line = line_buffer[..line_end].trim().to_string();
-                line_buffer = line_buffer[line_end + 1..].to_string();
-
-                if line.is_empty() {
-                    continue;
-                }
-
-                // SSE 格式：data: {...} 或 data: [DONE]
-                if line == "data: [DONE]" {
-                    stream_ended = true;
-                    break;
-                }
-
-                if let Some(json_str) = line.strip_prefix("data: ") {
-                    match serde_json::from_str::<StreamChunk>(json_str) {
-                        Ok(chunk) => {
-                            for choice in &chunk.choices {
-                                // 处理 reasoning_content
-                                if let Some(ref reasoning) = choice.delta.reasoning_content
-                                    && !reasoning.is_empty()
-                                {
-                                    if !has_reasoning {
-                                        has_reasoning = true;
-                                        if let Some(state) = thinking_state {
-                                            state.start_thinking();
-                                        }
-                                    }
-                                    // reasoning_content 不对外输出，仅用于内部状态判断
-                                    continue;
-                                }
-
-                                // 处理 content
-                                if let Some(ref content) = choice.delta.content
-                                    && !content.is_empty()
-                                {
-                                    // reasoning 结束，content 开始出现时移除 thinking 标识
-                                    if has_reasoning
-                                        && !has_content
-                                        && let Some(state) = thinking_state
-                                    {
-                                        state.end_thinking();
-                                    }
-                                    has_content = true;
-                                    content_buffer.push_str(content);
-                                }
-
-                                // 检查 finish_reason
-                                if let Some(ref reason) = choice.finish_reason
-                                    && reason == "stop"
-                                {
-                                    stream_ended = true;
-                                }
-                            }
-                        }
-                        Err(_) => {
-                            // 忽略无法解析的行（可能是心跳或注释）
-                        }
-                    }
-                }
-            }
-
-            if stream_ended {
-                break;
-            }
-        }
-
-        // 确保思考状态已结束
-        if let Some(state) = thinking_state {
-            state.end_thinking();
-        }
-
-        let result = content_buffer.trim().to_string();
-
-        if result.is_empty() {
-            if has_reasoning && !has_content {
-                bail!(
-                    "DeepSeek returned reasoning content but no final answer. \
-                     The model may have entered an incomplete thinking state. \
-                     Please try again or disable thinking mode."
-                );
-            }
-            bail!(
-                "No response from DeepSeek. \
-                 If thinking mode is enabled, try disabling it or ensure the model supports it."
-            );
-        }
-
-        Ok(result)
-    }
-}
-
-/// 可用 DeepSeek 模型列表
-/// deepseek-chat / deepseek-reasoner 将于 2026-07-24 停用，推荐使用 V4 系列
-pub const DEEPSEEK_MODELS: &[&str] = &[
-    "deepseek-v4-flash",
-    "deepseek-v4-pro",
-    // 兼容旧版模型 ID（将于 2026-07-24 停用）
-    "deepseek-chat",
-    "deepseek-reasoner",
-];
-
-pub fn is_valid_model(model: &str) -> bool {
-    DEEPSEEK_MODELS.contains(&model)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_validation_v4() {
-        assert!(is_valid_model("deepseek-v4-flash"));
-        assert!(is_valid_model("deepseek-v4-pro"));
-        assert!(is_valid_model("deepseek-chat"));
-        assert!(is_valid_model("deepseek-reasoner"));
-        assert!(!is_valid_model("invalid-model"));
-        assert!(!is_valid_model("deepseek-v3"));
-    }
-
-    #[test]
-    fn test_client_builder_defaults() {
-        let client = DeepSeekClient::new("test-key", "deepseek-v4-flash").unwrap();
-        assert!(!client.thinking_enabled);
-        assert_eq!(client.max_tokens, 500);
-        assert_eq!(client.temperature, 0.7);
-        assert!(client.reasoning_effort.is_none());
-        assert!(client.thinking_state.is_none());
-    }
-
-    #[test]
-    fn test_client_builder_with_thinking() {
-        let client = DeepSeekClient::new("test-key", "deepseek-v4-flash")
-            .unwrap()
-            .with_thinking(true)
-            .with_reasoning_effort(Some("high".to_string()))
-            .with_max_tokens(1000)
-            .with_temperature(0.5);
-
-        assert!(client.thinking_enabled);
-        assert_eq!(client.reasoning_effort, Some("high".to_string()));
-        assert_eq!(client.max_tokens, 1000);
-        assert_eq!(client.temperature, 0.5);
-    }
-
-    #[test]
-    fn test_thinking_config_serialization() {
-        let config = ThinkingConfig {
-            thinking_type: "enabled".to_string(),
-        };
-        let json = serde_json::to_string(&config).unwrap();
-        assert_eq!(json, r#"{"type":"enabled"}"#);
-    }
-
-    #[test]
-    fn test_message_serialization_without_reasoning() {
-        let msg = Message {
-            role: "user".to_string(),
-            content: "Hello".to_string(),
-            reasoning_content: None,
-        };
-        let json = serde_json::to_string(&msg).unwrap();
-        assert!(!json.contains("reasoning_content"));
-    }
-
-    #[test]
-    fn test_stream_delta_parsing() {
-        let json = r#"{"content":"Hello","reasoning_content":null}"#;
-        let delta: StreamDelta = serde_json::from_str(json).unwrap();
-        assert_eq!(delta.content, Some("Hello".to_string()));
-        assert!(delta.reasoning_content.is_none());
-    }
-
-    #[test]
-    fn test_stream_delta_reasoning_only() {
-        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!(delta.reasoning_content, Some("Let me think...".to_string()));
-    }
-}

src/llm/kimi.rs

@@ -1,587 +0,0 @@
-use super::thinking::ThinkingStateManager;
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result, bail};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::time::Duration;
-
-/// Kimi API client (Moonshot AI)
-pub struct KimiClient {
-    base_url: String,
-    api_key: String,
-    model: String,
-    client: reqwest::Client,
-    thinking_enabled: bool,
-    max_tokens: u32,
-    temperature: f32,
-    thinking_state: Option<Arc<ThinkingStateManager>>,
-}
-
-#[derive(Debug, Serialize)]
-struct ChatCompletionRequest {
-    model: String,
-    messages: Vec<Message>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    stream: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    thinking: Option<ThinkingConfig>,
-}
-
-#[derive(Debug, Serialize)]
-struct ThinkingConfig {
-    #[serde(rename = "type")]
-    thinking_type: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct Message {
-    role: String,
-    content: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    reasoning_content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChatCompletionResponse {
-    choices: Vec<Choice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Choice {
-    message: Message,
-    #[serde(default)]
-    reasoning_content: Option<String>,
-}
-
-// --- Streaming response structures ---
-
-#[derive(Debug, Deserialize)]
-struct StreamChunk {
-    choices: Vec<StreamChoice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct StreamChoice {
-    delta: StreamDelta,
-    #[serde(default)]
-    finish_reason: Option<String>,
-    index: Option<u32>,
-}
-
-#[derive(Debug, Deserialize, Default)]
-struct StreamDelta {
-    #[serde(default)]
-    content: Option<String>,
-    #[serde(default)]
-    reasoning_content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ErrorResponse {
-    error: ApiError,
-}
-
-#[derive(Debug, Deserialize)]
-struct ApiError {
-    message: String,
-    #[serde(rename = "type")]
-    error_type: String,
-}
-
-impl KimiClient {
-    pub fn new(api_key: &str, model: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(300))?;
-
-        Ok(Self {
-            base_url: "https://api.moonshot.cn/v1".to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            max_tokens: 500,
-            temperature: 1.0,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_base_url(api_key: &str, model: &str, base_url: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(300))?;
-
-        Ok(Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            max_tokens: 500,
-            temperature: 1.0,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
-        self.client = create_http_client(timeout)?;
-        Ok(self)
-    }
-
-    pub fn with_thinking(mut self, enabled: bool) -> Self {
-        self.thinking_enabled = enabled;
-        self
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_thinking_state(mut self, state: Arc<ThinkingStateManager>) -> Self {
-        self.thinking_state = Some(state);
-        self
-    }
-
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        let url = format!("{}/models", self.base_url);
-
-        let response = self
-            .client
-            .get(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .send()
-            .await
-            .context("Failed to list Kimi models")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            bail!("Kimi API error: {} - {}", status, text);
-        }
-
-        #[derive(Deserialize)]
-        struct ModelsResponse {
-            data: Vec<ModelId>,
-        }
-
-        #[derive(Deserialize)]
-        struct ModelId {
-            id: String,
-        }
-
-        let result: ModelsResponse = response
-            .json()
-            .await
-            .context("Failed to parse Kimi response")?;
-
-        Ok(result.data.into_iter().map(|m| m.id).collect())
-    }
-
-    pub async fn validate_key(&self) -> Result<bool> {
-        match self.list_models().await {
-            Ok(_) => Ok(true),
-            Err(e) => {
-                let err_str = e.to_string();
-                if err_str.contains("401") || err_str.contains("Unauthorized") {
-                    Ok(false)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for KimiClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![Message {
-            role: "user".to_string(),
-            content: prompt.to_string(),
-            reasoning_content: None,
-        }];
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let mut messages = vec![];
-
-        if !system.is_empty() {
-            messages.push(Message {
-                role: "system".to_string(),
-                content: system.to_string(),
-                reasoning_content: None,
-            });
-        }
-
-        messages.push(Message {
-            role: "user".to_string(),
-            content: user.to_string(),
-            reasoning_content: None,
-        });
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn is_available(&self) -> bool {
-        self.validate_key().await.unwrap_or(false)
-    }
-
-    fn name(&self) -> &str {
-        "kimi"
-    }
-}
-
-impl KimiClient {
-    async fn chat_completion_with_retry(&self, messages: Vec<Message>) -> Result<String> {
-        let mut last_error = None;
-
-        for attempt in 1..=3 {
-            match self.chat_completion(messages.clone()).await {
-                Ok(result) => return Ok(result),
-                Err(e) => {
-                    let err_msg = e.to_string();
-                    let is_retryable = err_msg.contains("timeout")
-                        || err_msg.contains("connection")
-                        || err_msg.contains("temporary")
-                        || err_msg.contains("5")
-                            && (err_msg.contains("500")
-                                || err_msg.contains("502")
-                                || err_msg.contains("503")
-                                || err_msg.contains("504"));
-
-                    if !is_retryable || attempt == 3 {
-                        last_error = Some(e);
-                        break;
-                    }
-
-                    tokio::time::sleep(Duration::from_millis(500 * 2u64.pow(attempt - 1))).await;
-                }
-            }
-        }
-
-        Err(last_error.unwrap_or_else(|| anyhow::anyhow!("Request failed after retries")))
-    }
-
-    async fn chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!("{}/chat/completions", self.base_url);
-
-        let thinking = Some(ThinkingConfig {
-            thinking_type: if self.thinking_enabled {
-                "enabled".to_string()
-            } else {
-                "disabled".to_string()
-            },
-        });
-
-        // Kimi API temperature 要求:
-        // - 思考模式: temperature 必须为 1.0
-        // - 非思考模式: temperature 必须为 0.6
-        let temperature = if self.thinking_enabled {
-            Some(1.0)
-        } else {
-            Some(0.6)
-        };
-
-        let request = ChatCompletionRequest {
-            model: self.model.clone(),
-            messages: messages.clone(),
-            max_tokens: Some(self.max_tokens),
-            temperature,
-            stream: self.thinking_enabled,
-            thinking,
-        };
-
-        if self.thinking_enabled {
-            self.streaming_chat_completion(&url, &request).await
-        } else {
-            self.non_streaming_chat_completion(&url, &request).await
-        }
-    }
-
-    /// 非流式请求（非思考模式）
-    async fn non_streaming_chat_completion(
-        &self,
-        url: &str,
-        request: &ChatCompletionRequest,
-    ) -> Result<String> {
-        let response = self
-            .client
-            .post(url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .json(request)
-            .send()
-            .await
-            .context("Failed to send request to Kimi")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "Kimi API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("Kimi API error: {} - {}", status, text);
-        }
-
-        let result: ChatCompletionResponse = response
-            .json()
-            .await
-            .context("Failed to parse Kimi response")?;
-
-        result
-            .choices
-            .into_iter()
-            .next()
-            .map(|c| {
-                let content = c.message.content.trim().to_string();
-                if content.is_empty() {
-                    c.reasoning_content
-                        .or(c.message.reasoning_content)
-                        .map(|r| r.trim().to_string())
-                        .unwrap_or_default()
-                } else {
-                    content
-                }
-            })
-            .filter(|s| !s.is_empty())
-            .ok_or_else(|| anyhow::anyhow!("No response from Kimi"))
-    }
-
-    /// 流式请求（思考模式），处理 reasoning_content 和 content
-    async fn streaming_chat_completion(
-        &self,
-        url: &str,
-        request: &ChatCompletionRequest,
-    ) -> Result<String> {
-        let response = self
-            .client
-            .post(url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .header("Accept", "text/event-stream")
-            .json(request)
-            .send()
-            .await
-            .context("Failed to send streaming request to Kimi")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "Kimi API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("Kimi API error: {} - {}", status, text);
-        }
-
-        let mut content_buffer = String::new();
-        let mut has_reasoning = false;
-        let mut has_content = false;
-        let mut stream_ended = false;
-
-        let thinking_state = self.thinking_state.as_ref();
-
-        let mut byte_stream = response.bytes_stream();
-        let mut line_buffer = String::new();
-
-        use futures_util::StreamExt;
-
-        while let Some(chunk) = byte_stream.next().await {
-            let chunk = chunk.context("Failed to read streaming response chunk")?;
-            let chunk_str =
-                String::from_utf8(chunk.to_vec()).context("Invalid UTF-8 in stream chunk")?;
-
-            line_buffer.push_str(&chunk_str);
-
-            while let Some(line_end) = line_buffer.find('\n') {
-                let line = line_buffer[..line_end].trim().to_string();
-                line_buffer = line_buffer[line_end + 1..].to_string();
-
-                if line.is_empty() {
-                    continue;
-                }
-
-                if line == "data: [DONE]" {
-                    stream_ended = true;
-                    break;
-                }
-
-                if let Some(json_str) = line.strip_prefix("data: ") {
-                    match serde_json::from_str::<StreamChunk>(json_str) {
-                        Ok(chunk) => {
-                            for choice in &chunk.choices {
-                                if let Some(ref reasoning) = choice.delta.reasoning_content
-                                    && !reasoning.is_empty()
-                                {
-                                    if !has_reasoning {
-                                        has_reasoning = true;
-                                        if let Some(state) = thinking_state {
-                                            state.start_thinking();
-                                        }
-                                    }
-                                    continue;
-                                }
-
-                                if let Some(ref content) = choice.delta.content
-                                    && !content.is_empty()
-                                {
-                                    if has_reasoning
-                                        && !has_content
-                                        && let Some(state) = thinking_state
-                                    {
-                                        state.end_thinking();
-                                    }
-                                    has_content = true;
-                                    content_buffer.push_str(content);
-                                }
-
-                                if let Some(ref reason) = choice.finish_reason
-                                    && reason == "stop"
-                                {
-                                    stream_ended = true;
-                                }
-                            }
-                        }
-                        Err(_) => {
-                            // 忽略无法解析的行
-                        }
-                    }
-                }
-            }
-
-            if stream_ended {
-                break;
-            }
-        }
-
-        // 确保思考状态已结束
-        if let Some(state) = thinking_state {
-            state.end_thinking();
-        }
-
-        let result = content_buffer.trim().to_string();
-
-        if result.is_empty() {
-            if has_reasoning && !has_content {
-                bail!(
-                    "Kimi returned reasoning content but no final answer. \
-                     The model may have entered an incomplete thinking state. \
-                     Please try again or disable thinking mode."
-                );
-            }
-            bail!(
-                "No response from Kimi. \
-                 If thinking mode is enabled, try disabling it or ensure the model supports it."
-            );
-        }
-
-        Ok(result)
-    }
-}
-
-/// 可用 Kimi 模型列表
-pub const KIMI_MODELS: &[&str] = &[
-    // K2 系列（推荐）
-    "kimi-k2.6",
-    "kimi-k2.5",
-    "kimi-k2-thinking",
-    "kimi-k2-thinking-turbo",
-    "kimi-k2-instruct",
-    "kimi-k2-instruct-0905",
-    // 兼容旧版模型 ID
-    "moonshot-v1-8k",
-    "moonshot-v1-32k",
-    "moonshot-v1-128k",
-];
-
-pub fn is_valid_model(model: &str) -> bool {
-    KIMI_MODELS.contains(&model)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_validation_k2() {
-        assert!(is_valid_model("kimi-k2.6"));
-        assert!(is_valid_model("kimi-k2.5"));
-        assert!(is_valid_model("kimi-k2-thinking"));
-        assert!(is_valid_model("kimi-k2-thinking-turbo"));
-        assert!(is_valid_model("moonshot-v1-8k"));
-        assert!(is_valid_model("moonshot-v1-32k"));
-        assert!(is_valid_model("moonshot-v1-128k"));
-        assert!(!is_valid_model("invalid-model"));
-        assert!(!is_valid_model("kimi-k1.5"));
-    }
-
-    #[test]
-    fn test_client_builder_defaults() {
-        let client = KimiClient::new("test-key", "kimi-k2.6").unwrap();
-        assert!(!client.thinking_enabled);
-        assert_eq!(client.max_tokens, 500);
-        assert_eq!(client.temperature, 1.0);
-        assert!(client.thinking_state.is_none());
-    }
-
-    #[test]
-    fn test_client_builder_with_thinking() {
-        let client = KimiClient::new("test-key", "kimi-k2.6")
-            .unwrap()
-            .with_thinking(true)
-            .with_max_tokens(1000)
-            .with_temperature(0.5);
-
-        assert!(client.thinking_enabled);
-        assert_eq!(client.max_tokens, 1000);
-        assert_eq!(client.temperature, 0.5);
-    }
-
-    #[test]
-    fn test_thinking_config_serialization() {
-        let config = ThinkingConfig {
-            thinking_type: "enabled".to_string(),
-        };
-        let json = serde_json::to_string(&config).unwrap();
-        assert_eq!(json, r#"{"type":"enabled"}"#);
-    }
-
-    #[test]
-    fn test_client_new_defaults() {
-        let client = KimiClient::new("test-key", "kimi-k2.6").unwrap();
-        assert_eq!(client.name(), "kimi");
-        assert!(!client.thinking_enabled);
-    }
-
-    #[test]
-    fn test_message_serialization() {
-        let msg = Message {
-            role: "user".to_string(),
-            content: "Hello".to_string(),
-            reasoning_content: None,
-        };
-        let json = serde_json::to_string(&msg).unwrap();
-        assert!(!json.contains("reasoning_content"));
-    }
-}

src/llm/ollama.rs

@@ -1,229 +0,0 @@
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-
-/// Ollama API client
-pub struct OllamaClient {
-    base_url: String,
-    model: String,
-    client: reqwest::Client,
-    max_tokens: u32,
-    temperature: f32,
-    top_p: Option<f32>,
-}
-
-#[derive(Debug, Serialize)]
-struct GenerateRequest {
-    model: String,
-    prompt: String,
-    system: Option<String>,
-    stream: bool,
-    options: GenerationOptions,
-}
-
-#[derive(Debug, Serialize, Default)]
-struct GenerationOptions {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    num_predict: Option<u32>,
-}
-
-#[derive(Debug, Deserialize)]
-struct GenerateResponse {
-    response: String,
-    done: bool,
-}
-
-#[derive(Debug, Deserialize)]
-struct ListModelsResponse {
-    models: Vec<ModelInfo>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ModelInfo {
-    name: String,
-}
-
-impl OllamaClient {
-    /// Create new Ollama client
-    pub fn new(base_url: &str, model: &str) -> Self {
-        let client =
-            create_http_client(Duration::from_secs(120)).expect("Failed to create HTTP client");
-
-        Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            model: model.to_string(),
-            client,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-        }
-    }
-
-    /// Set timeout
-    pub fn with_timeout(mut self, timeout: Duration) -> Self {
-        self.client = create_http_client(timeout).expect("Failed to create HTTP client");
-        self
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_top_p(mut self, top_p: f32) -> Self {
-        self.top_p = Some(top_p);
-        self
-    }
-
-    /// List available models
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        let url = format!("{}/api/tags", self.base_url);
-
-        let response = self
-            .client
-            .get(&url)
-            .send()
-            .await
-            .context("Failed to list Ollama models")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            anyhow::bail!("Ollama API error: {} - {}", status, text);
-        }
-
-        let result: ListModelsResponse = response
-            .json()
-            .await
-            .context("Failed to parse Ollama response")?;
-
-        Ok(result.models.into_iter().map(|m| m.name).collect())
-    }
-
-    /// Pull a model
-    pub async fn pull_model(&self, model: &str) -> Result<()> {
-        let url = format!("{}/api/pull", self.base_url);
-
-        let request = serde_json::json!({
-            "name": model,
-            "stream": false,
-        });
-
-        let response = self
-            .client
-            .post(&url)
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to pull Ollama model")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            anyhow::bail!("Ollama pull error: {} - {}", status, text);
-        }
-
-        Ok(())
-    }
-
-    /// Check if model exists
-    pub async fn model_exists(&self, model: &str) -> bool {
-        match self.list_models().await {
-            Ok(models) => models.contains(&model.to_string()),
-            Err(_) => false,
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for OllamaClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        self.generate_with_system("", prompt).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let url = format!("{}/api/generate", self.base_url);
-
-        let system = if system.is_empty() {
-            None
-        } else {
-            Some(system.to_string())
-        };
-
-        let request = GenerateRequest {
-            model: self.model.clone(),
-            prompt: user.to_string(),
-            system,
-            stream: false,
-            options: GenerationOptions {
-                temperature: Some(self.temperature),
-                num_predict: Some(self.max_tokens),
-            },
-        };
-
-        let response = self
-            .client
-            .post(&url)
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send request to Ollama")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            anyhow::bail!("Ollama API error: {} - {}", status, text);
-        }
-
-        let result: GenerateResponse = response
-            .json()
-            .await
-            .context("Failed to parse Ollama response")?;
-
-        Ok(result.response.trim().to_string())
-    }
-
-    async fn is_available(&self) -> bool {
-        let url = format!("{}/api/tags", self.base_url);
-
-        match self.client.get(&url).send().await {
-            Ok(response) => response.status().is_success(),
-            Err(_) => false,
-        }
-    }
-
-    fn name(&self) -> &str {
-        "ollama"
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // These tests require a running Ollama server
-    #[tokio::test]
-    #[ignore]
-    async fn test_ollama_connection() {
-        let client = OllamaClient::new("http://localhost:11434", "llama2");
-        assert!(client.is_available().await);
-    }
-
-    #[tokio::test]
-    #[ignore]
-    async fn test_ollama_generate() {
-        let client = OllamaClient::new("http://localhost:11434", "llama2");
-        let response = client.generate("Hello, how are you?").await;
-        assert!(response.is_ok());
-        println!("Response: {}", response.unwrap());
-    }
-}

src/llm/openai.rs

@@ -1,659 +0,0 @@
-use super::thinking::ThinkingStateManager;
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result, bail};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use std::time::Duration;
-
-/// OpenAI API client with o-series reasoning support
-pub struct OpenAiClient {
-    base_url: String,
-    api_key: String,
-    model: String,
-    client: reqwest::Client,
-    thinking_enabled: bool,
-    reasoning_effort: Option<String>,
-    max_tokens: u32,
-    temperature: f32,
-    top_p: Option<f32>,
-    thinking_state: Option<Arc<ThinkingStateManager>>,
-}
-
-#[derive(Debug, Serialize)]
-struct ChatCompletionRequest {
-    model: String,
-    messages: Vec<Message>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    top_p: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    reasoning_effort: Option<String>,
-    stream: bool,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-struct Message {
-    role: String,
-    content: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChatCompletionResponse {
-    choices: Vec<Choice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Choice {
-    message: Message,
-}
-
-// --- Streaming response structures ---
-
-#[derive(Debug, Deserialize)]
-struct StreamChunk {
-    choices: Vec<StreamChoice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct StreamChoice {
-    delta: StreamDelta,
-    #[serde(default)]
-    finish_reason: Option<String>,
-}
-
-#[derive(Debug, Deserialize, Default)]
-struct StreamDelta {
-    #[serde(default)]
-    content: Option<String>,
-    #[serde(default)]
-    reasoning_content: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ErrorResponse {
-    error: ApiError,
-}
-
-#[derive(Debug, Deserialize)]
-struct ApiError {
-    message: String,
-    #[serde(rename = "type")]
-    error_type: String,
-}
-
-impl OpenAiClient {
-    /// Create new OpenAI client
-    pub fn new(base_url: &str, api_key: &str, model: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(60))?;
-
-        Ok(Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            thinking_enabled: false,
-            reasoning_effort: None,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-            thinking_state: None,
-        })
-    }
-
-    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
-        self.client = create_http_client(timeout)?;
-        Ok(self)
-    }
-
-    pub fn with_thinking(mut self, enabled: bool) -> Self {
-        self.thinking_enabled = enabled;
-        self
-    }
-
-    pub fn with_reasoning_effort(mut self, effort: Option<String>) -> Self {
-        self.reasoning_effort = effort;
-        self
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_top_p(mut self, top_p: f32) -> Self {
-        self.top_p = Some(top_p);
-        self
-    }
-
-    pub fn with_thinking_state(mut self, state: Arc<ThinkingStateManager>) -> Self {
-        self.thinking_state = Some(state);
-        self
-    }
-
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        let url = format!("{}/models", self.base_url);
-
-        let response = self
-            .client
-            .get(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .send()
-            .await
-            .context("Failed to list OpenAI models")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            bail!("OpenAI API error: {} - {}", status, text);
-        }
-
-        #[derive(Deserialize)]
-        struct ModelsResponse {
-            data: Vec<Model>,
-        }
-
-        #[derive(Deserialize)]
-        struct Model {
-            id: String,
-        }
-
-        let result: ModelsResponse = response
-            .json()
-            .await
-            .context("Failed to parse OpenAI response")?;
-
-        Ok(result.data.into_iter().map(|m| m.id).collect())
-    }
-
-    pub async fn validate_key(&self) -> Result<bool> {
-        match self.list_models().await {
-            Ok(_) => Ok(true),
-            Err(e) => {
-                let err_str = e.to_string();
-                if err_str.contains("401") || err_str.contains("Unauthorized") {
-                    Ok(false)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for OpenAiClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![Message {
-            role: "user".to_string(),
-            content: prompt.to_string(),
-        }];
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let mut messages = vec![];
-
-        if !system.is_empty() {
-            messages.push(Message {
-                role: "system".to_string(),
-                content: system.to_string(),
-            });
-        }
-
-        messages.push(Message {
-            role: "user".to_string(),
-            content: user.to_string(),
-        });
-
-        self.chat_completion_with_retry(messages).await
-    }
-
-    async fn is_available(&self) -> bool {
-        self.validate_key().await.unwrap_or(false)
-    }
-
-    fn name(&self) -> &str {
-        "openai"
-    }
-}
-
-impl OpenAiClient {
-    async fn chat_completion_with_retry(&self, messages: Vec<Message>) -> Result<String> {
-        let mut last_error = None;
-
-        for attempt in 1..=3 {
-            match self.chat_completion(messages.clone()).await {
-                Ok(result) => return Ok(result),
-                Err(e) => {
-                    let err_msg = e.to_string();
-                    let is_retryable = err_msg.contains("timeout")
-                        || err_msg.contains("connection")
-                        || err_msg.contains("temporary")
-                        || err_msg.contains("5")
-                            && (err_msg.contains("500")
-                                || err_msg.contains("502")
-                                || err_msg.contains("503")
-                                || err_msg.contains("504"));
-
-                    if !is_retryable || attempt == 3 {
-                        last_error = Some(e);
-                        break;
-                    }
-
-                    tokio::time::sleep(Duration::from_millis(500 * 2u64.pow(attempt - 1))).await;
-                }
-            }
-        }
-
-        Err(last_error.unwrap_or_else(|| anyhow::anyhow!("Request failed after retries")))
-    }
-
-    async fn chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        if self.thinking_enabled {
-            self.streaming_chat_completion(messages).await
-        } else {
-            self.non_streaming_chat_completion(messages).await
-        }
-    }
-
-    async fn non_streaming_chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!("{}/chat/completions", self.base_url);
-
-        let request = ChatCompletionRequest {
-            model: self.model.clone(),
-            messages,
-            max_tokens: Some(self.max_tokens),
-            temperature: Some(self.temperature),
-            top_p: self.top_p,
-            reasoning_effort: if is_reasoning_model(&self.model) {
-                Some("none".to_string())
-            } else {
-                None
-            },
-            stream: false,
-        };
-
-        let response = self
-            .client
-            .post(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send request to OpenAI")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "OpenAI API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("OpenAI API error: {} - {}", status, text);
-        }
-
-        let result: ChatCompletionResponse = response
-            .json()
-            .await
-            .context("Failed to parse OpenAI response")?;
-
-        result
-            .choices
-            .into_iter()
-            .next()
-            .map(|c| c.message.content.trim().to_string())
-            .filter(|s| !s.is_empty())
-            .ok_or_else(|| anyhow::anyhow!("No response from OpenAI"))
-    }
-
-    /// Streaming request for reasoning mode, filters reasoning_content from output
-    async fn streaming_chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!("{}/chat/completions", self.base_url);
-
-        // For reasoning/thinking mode, omit temperature and top_p
-        let request = ChatCompletionRequest {
-            model: self.model.clone(),
-            messages,
-            max_tokens: Some(self.max_tokens),
-            temperature: None,
-            top_p: None,
-            reasoning_effort: self.reasoning_effort.clone(),
-            stream: true,
-        };
-
-        let response = self
-            .client
-            .post(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .header("Accept", "text/event-stream")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send streaming request to OpenAI")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            if let Ok(error) = serde_json::from_str::<ErrorResponse>(&text) {
-                bail!(
-                    "OpenAI API error: {} ({})",
-                    error.error.message,
-                    error.error.error_type
-                );
-            }
-
-            bail!("OpenAI API error: {} - {}", status, text);
-        }
-
-        let mut content_buffer = String::new();
-        let mut has_reasoning = false;
-        let mut has_content = false;
-
-        let thinking_state = self.thinking_state.as_ref();
-
-        let mut byte_stream = response.bytes_stream();
-        let mut line_buffer = String::new();
-
-        use futures_util::StreamExt;
-
-        while let Some(chunk) = byte_stream.next().await {
-            let chunk = chunk.context("Failed to read streaming response chunk")?;
-            let chunk_str =
-                String::from_utf8(chunk.to_vec()).context("Invalid UTF-8 in stream chunk")?;
-
-            line_buffer.push_str(&chunk_str);
-
-            while let Some(line_end) = line_buffer.find('\n') {
-                let line = line_buffer[..line_end].trim().to_string();
-                line_buffer = line_buffer[line_end + 1..].to_string();
-
-                if line.is_empty() {
-                    continue;
-                }
-
-                if line == "data: [DONE]" {
-                    break;
-                }
-
-                if let Some(json_str) = line.strip_prefix("data: ") {
-                    if let Ok(chunk) = serde_json::from_str::<StreamChunk>(json_str) {
-                        for choice in &chunk.choices {
-                            // Handle reasoning_content (o-series)
-                            if let Some(ref reasoning) = choice.delta.reasoning_content
-                                && !reasoning.is_empty()
-                            {
-                                if !has_reasoning {
-                                    has_reasoning = true;
-                                    if let Some(state) = thinking_state {
-                                        state.start_thinking();
-                                    }
-                                }
-                                continue;
-                            }
-
-                            // Handle content
-                            if let Some(ref content) = choice.delta.content
-                                && !content.is_empty()
-                            {
-                                if has_reasoning
-                                    && !has_content
-                                    && let Some(state) = thinking_state
-                                {
-                                    state.end_thinking();
-                                }
-                                has_content = true;
-                                content_buffer.push_str(content);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        if let Some(state) = thinking_state {
-            state.end_thinking();
-        }
-
-        let result = content_buffer.trim().to_string();
-
-        if result.is_empty() {
-            if has_reasoning && !has_content {
-                bail!(
-                    "OpenAI returned reasoning content but no final answer. \
-                     The model may have entered an incomplete reasoning state. \
-                     Please try again or disable thinking mode."
-                );
-            }
-            bail!(
-                "No response from OpenAI. \
-                 If thinking mode is enabled, try disabling it or ensure the model supports reasoning."
-            );
-        }
-
-        Ok(result)
-    }
-}
-
-/// Azure OpenAI client (extends OpenAI with Azure-specific config)
-pub struct AzureOpenAiClient {
-    endpoint: String,
-    api_key: String,
-    deployment: String,
-    api_version: String,
-    client: reqwest::Client,
-    thinking_enabled: bool,
-    reasoning_effort: Option<String>,
-    max_tokens: u32,
-    temperature: f32,
-    top_p: Option<f32>,
-    thinking_state: Option<Arc<ThinkingStateManager>>,
-}
-
-impl AzureOpenAiClient {
-    pub fn new(endpoint: &str, api_key: &str, deployment: &str, api_version: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(60))?;
-
-        Ok(Self {
-            endpoint: endpoint.trim_end_matches('/').to_string(),
-            api_key: api_key.to_string(),
-            deployment: deployment.to_string(),
-            api_version: api_version.to_string(),
-            client,
-            thinking_enabled: false,
-            reasoning_effort: None,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-            thinking_state: None,
-        })
-    }
-
-    async fn chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!(
-            "{}/openai/deployments/{}/chat/completions?api-version={}",
-            self.endpoint, self.deployment, self.api_version
-        );
-
-        let request = ChatCompletionRequest {
-            model: self.deployment.clone(),
-            messages,
-            max_tokens: Some(self.max_tokens),
-            temperature: Some(self.temperature),
-            top_p: self.top_p,
-            reasoning_effort: self.reasoning_effort.clone(),
-            stream: false,
-        };
-
-        let response = self
-            .client
-            .post(&url)
-            .header("api-key", &self.api_key)
-            .header("Content-Type", "application/json")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send request to Azure OpenAI")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            bail!("Azure OpenAI API error: {} - {}", status, text);
-        }
-
-        let result: ChatCompletionResponse = response
-            .json()
-            .await
-            .context("Failed to parse Azure OpenAI response")?;
-
-        result
-            .choices
-            .into_iter()
-            .next()
-            .map(|c| c.message.content.trim().to_string())
-            .filter(|s| !s.is_empty())
-            .ok_or_else(|| anyhow::anyhow!("No response from Azure OpenAI"))
-    }
-}
-
-#[async_trait]
-impl LlmProvider for AzureOpenAiClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![Message {
-            role: "user".to_string(),
-            content: prompt.to_string(),
-        }];
-
-        self.chat_completion(messages).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let mut messages = vec![];
-
-        if !system.is_empty() {
-            messages.push(Message {
-                role: "system".to_string(),
-                content: system.to_string(),
-            });
-        }
-
-        messages.push(Message {
-            role: "user".to_string(),
-            content: user.to_string(),
-        });
-
-        self.chat_completion(messages).await
-    }
-
-    async fn is_available(&self) -> bool {
-        let url = format!(
-            "{}/openai/deployments/{}/chat/completions?api-version={}",
-            self.endpoint, self.deployment, self.api_version
-        );
-
-        let request = ChatCompletionRequest {
-            model: self.deployment.clone(),
-            messages: vec![Message {
-                role: "user".to_string(),
-                content: "Hi".to_string(),
-            }],
-            max_tokens: Some(5),
-            temperature: Some(0.0),
-            top_p: None,
-            reasoning_effort: None,
-            stream: false,
-        };
-
-        match self
-            .client
-            .post(&url)
-            .header("api-key", &self.api_key)
-            .json(&request)
-            .send()
-            .await
-        {
-            Ok(response) => response.status().is_success(),
-            Err(_) => false,
-        }
-    }
-
-    fn name(&self) -> &str {
-        "azure-openai"
-    }
-}
-
-/// Available OpenAI models (including o-series with reasoning)
-pub const OPENAI_MODELS: &[&str] = &[
-    "o4-mini",
-    "o3",
-    "o3-mini",
-    "o1",
-    "o1-mini",
-    "o1-pro",
-    "gpt-4.1",
-    "gpt-4.1-mini",
-    "gpt-4.1-nano",
-    "gpt-4o",
-    "gpt-4o-mini",
-    "gpt-4-turbo",
-    "gpt-4",
-    "gpt-3.5-turbo",
-];
-
-pub fn is_valid_model(model: &str) -> bool {
-    OPENAI_MODELS.contains(&model)
-}
-
-fn is_reasoning_model(model: &str) -> bool {
-    model.starts_with("o")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_validation_o_series() {
-        assert!(is_valid_model("o4-mini"));
-        assert!(is_valid_model("o3"));
-        assert!(is_valid_model("o1"));
-        assert!(is_valid_model("gpt-4o"));
-        assert!(is_valid_model("gpt-3.5-turbo"));
-        assert!(!is_valid_model("invalid-model"));
-    }
-
-    #[test]
-    fn test_stream_delta_reasoning_parsing() {
-        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!(delta.reasoning_content, Some("Let me think...".to_string()));
-    }
-
-    #[test]
-    fn test_stream_delta_content_parsing() {
-        let json = r#"{"content":"Hello","reasoning_content":null}"#;
-        let delta: StreamDelta = serde_json::from_str(json).unwrap();
-        assert_eq!(delta.content, Some("Hello".to_string()));
-        assert!(delta.reasoning_content.is_none());
-    }
-}

src/llm/openrouter.rs

@@ -1,286 +0,0 @@
-use super::{LlmProvider, create_http_client};
-use anyhow::{Context, Result, bail};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-
-/// OpenRouter API client
-pub struct OpenRouterClient {
-    base_url: String,
-    api_key: String,
-    model: String,
-    client: reqwest::Client,
-    max_tokens: u32,
-    temperature: f32,
-    top_p: Option<f32>,
-}
-
-#[derive(Debug, Serialize)]
-struct ChatCompletionRequest {
-    model: String,
-    messages: Vec<Message>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    temperature: Option<f32>,
-    stream: bool,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Message {
-    role: String,
-    content: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChatCompletionResponse {
-    choices: Vec<Choice>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Choice {
-    message: Message,
-}
-
-#[derive(Debug, Deserialize)]
-struct ErrorResponse {
-    error: ApiError,
-}
-
-#[derive(Debug, Deserialize)]
-struct ApiError {
-    message: String,
-    #[serde(rename = "type")]
-    error_type: String,
-}
-
-impl OpenRouterClient {
-    /// Create new OpenRouter client
-    pub fn new(api_key: &str, model: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(60))?;
-
-        Ok(Self {
-            base_url: "https://openrouter.ai/api/v1".to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-        })
-    }
-
-    /// Create with custom base URL
-    pub fn with_base_url(api_key: &str, model: &str, base_url: &str) -> Result<Self> {
-        let client = create_http_client(Duration::from_secs(60))?;
-
-        Ok(Self {
-            base_url: base_url.trim_end_matches('/').to_string(),
-            api_key: api_key.to_string(),
-            model: model.to_string(),
-            client,
-            max_tokens: 500,
-            temperature: 0.7,
-            top_p: None,
-        })
-    }
-
-    /// Set timeout
-    pub fn with_timeout(mut self, timeout: Duration) -> Result<Self> {
-        self.client = create_http_client(timeout)?;
-        Ok(self)
-    }
-
-    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
-        self.max_tokens = max_tokens;
-        self
-    }
-
-    pub fn with_temperature(mut self, temperature: f32) -> Self {
-        self.temperature = temperature;
-        self
-    }
-
-    pub fn with_top_p(mut self, top_p: f32) -> Self {
-        self.top_p = Some(top_p);
-        self
-    }
-
-    /// List available models
-    pub async fn list_models(&self) -> Result<Vec<String>> {
-        let url = format!("{}/models", self.base_url);
-
-        let response = self
-            .client
-            .get(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("HTTP-Referer", "https://quicommit.dev")
-            .header("X-Title", "QuiCommit")
-            .send()
-            .await
-            .context("Failed to list OpenRouter models")?;
-
-        if !response.status().is_success() {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            bail!("OpenRouter API error: {} - {}", status, text);
-        }
-
-        #[derive(Deserialize)]
-        struct ModelsResponse {
-            data: Vec<Model>,
-        }
-
-        #[derive(Deserialize)]
-        struct Model {
-            id: String,
-        }
-
-        let result: ModelsResponse = response
-            .json()
-            .await
-            .context("Failed to parse OpenRouter response")?;
-
-        Ok(result.data.into_iter().map(|m| m.id).collect())
-    }
-
-    /// Validate API key
-    pub async fn validate_key(&self) -> Result<bool> {
-        match self.list_models().await {
-            Ok(_) => Ok(true),
-            Err(e) => {
-                let err_str = e.to_string();
-                if err_str.contains("401") || err_str.contains("Unauthorized") {
-                    Ok(false)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-}
-
-#[async_trait]
-impl LlmProvider for OpenRouterClient {
-    async fn generate(&self, prompt: &str) -> Result<String> {
-        let messages = vec![Message {
-            role: "user".to_string(),
-            content: prompt.to_string(),
-        }];
-
-        self.chat_completion(messages).await
-    }
-
-    async fn generate_with_system(&self, system: &str, user: &str) -> Result<String> {
-        let mut messages = vec![];
-
-        if !system.is_empty() {
-            messages.push(Message {
-                role: "system".to_string(),
-                content: system.to_string(),
-            });
-        }
-
-        messages.push(Message {
-            role: "user".to_string(),
-            content: user.to_string(),
-        });
-
-        self.chat_completion(messages).await
-    }
-
-    async fn is_available(&self) -> bool {
-        self.validate_key().await.unwrap_or(false)
-    }
-
-    fn name(&self) -> &str {
-        "openrouter"
-    }
-}
-
-impl OpenRouterClient {
-    async fn chat_completion(&self, messages: Vec<Message>) -> Result<String> {
-        let url = format!("{}/chat/completions", self.base_url);
-
-        let request = ChatCompletionRequest {
-            model: self.model.clone(),
-            messages,
-            max_tokens: Some(self.max_tokens),
-            temperature: Some(self.temperature),
-            stream: false,
-        };
-
-        let response = self
-            .client
-            .post(&url)
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .header("Content-Type", "application/json")
-            .header("HTTP-Referer", "https://quicommit.dev")
-            .header("X-Title", "QuiCommit")
-            .json(&request)
-            .send()
-            .await
-            .context("Failed to send request to OpenRouter")?;
-
-        let status = response.status();
-
-        if !status.is_success() {
-            let text = response.text().await.unwrap_or_default();
-
-            // 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: {} - {}", status, text);
-        }
-
-        let result: ChatCompletionResponse = response
-            .json()
-            .await
-            .context("Failed to parse OpenRouter response")?;
-
-        result
-            .choices
-            .into_iter()
-            .next()
-            .map(|c| c.message.content.trim().to_string())
-            .ok_or_else(|| anyhow::anyhow!("No response from OpenRouter"))
-    }
-}
-
-/// Popular OpenRouter models
-pub const OPENROUTER_MODELS: &[&str] = &[
-    "openai/gpt-3.5-turbo",
-    "openai/gpt-4",
-    "openai/gpt-4-turbo",
-    "anthropic/claude-3-opus",
-    "anthropic/claude-3-sonnet",
-    "anthropic/claude-3-haiku",
-    "google/gemini-pro",
-    "meta-llama/llama-2-70b-chat",
-    "mistralai/mixtral-8x7b-instruct",
-    "01-ai/yi-34b-chat",
-];
-
-/// Check if a model name is valid
-pub fn is_valid_model(_model: &str) -> bool {
-    // Since OpenRouter supports many models, we'll allow any model name
-    // but provide some popular ones as suggestions
-    true
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_model_validation() {
-        assert!(is_valid_model("openai/gpt-4"));
-        assert!(is_valid_model("custom/model"));
-    }
-}

src/llm/parsing.rs

@@ -0,0 +1,281 @@
+use anyhow::{Result, bail};
+
+/// Parse commit response from LLM
+pub(crate) fn parse_commit_response(
+    response: &str,
+    format: crate::config::CommitFormat,
+) -> Result<GeneratedCommit> {
+    // Clean markdown code fences from the response
+    let cleaned = strip_code_fences(response);
+
+    let lines: Vec<&str> = cleaned
+        .lines()
+        .map(|l| l.trim())
+        .filter(|l| !l.is_empty())
+        .collect();
+
+    if lines.is_empty() {
+        let preview: String = response.chars().take(200).collect();
+        bail!(
+            "LLM returned empty or whitespace-only response. \
+             Raw response preview: '{}'. \
+             Hint: If using DeepSeek/Kimi with thinking enabled, \
+             the model may have returned reasoning_content only. \
+             Try disabling thinking mode or switching models.",
+            preview
+        );
+    }
+
+    // Find the line most likely to be the commit subject
+    let first_line = find_commit_subject_line(&lines, format);
+
+    // Parse based on format
+    match format {
+        crate::config::CommitFormat::Conventional => {
+            parse_conventional_commit(first_line, &lines, response)
+        }
+        crate::config::CommitFormat::Commitlint => {
+            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(
+    first_line: &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 {
+        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];
+    let description = parts[1].trim();
+
+    // Extract type, scope, and breaking indicator
+    let breaking = type_part.ends_with('!');
+    let type_part = type_part.trim_end_matches('!');
+
+    let (commit_type, scope) = if let Some(start) = type_part.find('(') {
+        if let Some(end) = type_part.find(')') {
+            let t = &type_part[..start];
+            let s = &type_part[start + 1..end];
+            (t.to_string(), Some(s.to_string()))
+        } else {
+            bail!("Invalid scope format: missing closing parenthesis");
+        }
+    } else {
+        (type_part.to_string(), None)
+    };
+
+    // Extract body and footer
+    let (body, footer) = extract_body_footer(lines);
+
+    Ok(GeneratedCommit {
+        commit_type,
+        scope,
+        description: description.to_string(),
+        body,
+        footer,
+        breaking,
+    })
+}
+
+fn parse_commitlint_commit(
+    first_line: &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 {
+        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];
+    let subject = parts[1].trim();
+
+    let (commit_type, scope) = if let Some(start) = type_part.find('(') {
+        if let Some(end) = type_part.find(')') {
+            let t = &type_part[..start];
+            let s = &type_part[start + 1..end];
+            (t.to_string(), Some(s.to_string()))
+        } else {
+            (type_part.to_string(), None)
+        }
+    } else {
+        (type_part.to_string(), None)
+    };
+
+    let (body, footer) = extract_body_footer(&lines);
+
+    Ok(GeneratedCommit {
+        commit_type,
+        scope,
+        description: subject.to_string(),
+        body,
+        footer,
+        breaking: false,
+    })
+}
+
+fn extract_body_footer(lines: &[&str]) -> (Option<String>, Option<String>) {
+    if lines.len() <= 1 {
+        return (None, None);
+    }
+
+    let rest: Vec<&str> = lines[1..]
+        .iter()
+        .skip_while(|l| l.trim().is_empty())
+        .copied()
+        .collect();
+
+    if rest.is_empty() {
+        return (None, None);
+    }
+
+    // Look for footer markers
+    let footer_markers = [
+        "BREAKING CHANGE:",
+        "Closes",
+        "Fixes",
+        "Refs",
+        "Co-authored-by:",
+    ];
+
+    let mut body_lines = vec![];
+    let mut footer_lines = vec![];
+    let mut in_footer = false;
+
+    for line in &rest {
+        if footer_markers.iter().any(|m| line.starts_with(m)) {
+            in_footer = true;
+        }
+
+        if in_footer {
+            footer_lines.push(*line);
+        } else {
+            body_lines.push(*line);
+        }
+    }
+
+    let body = if body_lines.is_empty() {
+        None
+    } else {
+        Some(body_lines.join("\n"))
+    };
+
+    let footer = if footer_lines.is_empty() {
+        None
+    } else {
+        Some(footer_lines.join("\n"))
+    };
+
+    (body, footer)
+}
+
+/// Generated commit structure
+#[derive(Debug, Clone)]
+pub struct GeneratedCommit {
+    pub commit_type: String,
+    pub scope: Option<String>,
+    pub description: String,
+    pub body: Option<String>,
+    pub footer: Option<String>,
+    pub breaking: bool,
+}
+
+impl GeneratedCommit {
+    /// Format as conventional commit
+    pub fn to_conventional(&self) -> String {
+        crate::utils::formatter::format_conventional_commit(
+            &self.commit_type,
+            self.scope.as_deref(),
+            &self.description,
+            self.body.as_deref(),
+            self.footer.as_deref(),
+            self.breaking,
+        )
+    }
+
+    /// Format as commitlint commit
+    pub fn to_commitlint(&self) -> String {
+        crate::utils::formatter::format_commitlint_commit(
+            &self.commit_type,
+            self.scope.as_deref(),
+            &self.description,
+            self.body.as_deref(),
+            self.footer.as_deref(),
+            None,
+        )
+    }
+}

src/llm/prompts.rs

@@ -0,0 +1,618 @@
+use crate::config::Language;
+
+/// Get commit system prompt based on format and language
+pub(crate) 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::Japanese) => {
+            CONVENTIONAL_COMMIT_SYSTEM_PROMPT_JA
+        }
+        (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::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,
+        (crate::config::CommitFormat::Commitlint, Language::German) => COMMITLINT_SYSTEM_PROMPT_DE,
+        (crate::config::CommitFormat::Commitlint, _) => COMMITLINT_SYSTEM_PROMPT,
+    }
+}
+
+pub(crate) fn get_tag_system_prompt(language: Language) -> &'static str {
+    match language {
+        Language::Chinese => TAG_MESSAGE_SYSTEM_PROMPT_ZH,
+        Language::Japanese => TAG_MESSAGE_SYSTEM_PROMPT_JA,
+        Language::Korean => TAG_MESSAGE_SYSTEM_PROMPT_KO,
+        Language::Spanish => TAG_MESSAGE_SYSTEM_PROMPT_ES,
+        Language::French => TAG_MESSAGE_SYSTEM_PROMPT_FR,
+        Language::German => TAG_MESSAGE_SYSTEM_PROMPT_DE,
+        _ => TAG_MESSAGE_SYSTEM_PROMPT,
+    }
+}
+
+pub(crate) fn get_changelog_system_prompt(language: Language) -> &'static str {
+    match language {
+        Language::Chinese => CHANGELOG_SYSTEM_PROMPT_ZH,
+        Language::Japanese => CHANGELOG_SYSTEM_PROMPT_JA,
+        Language::Korean => CHANGELOG_SYSTEM_PROMPT_KO,
+        Language::Spanish => CHANGELOG_SYSTEM_PROMPT_ES,
+        Language::French => CHANGELOG_SYSTEM_PROMPT_FR,
+        Language::German => CHANGELOG_SYSTEM_PROMPT_DE,
+        _ => CHANGELOG_SYSTEM_PROMPT,
+    }
+}
+
+// System prompts for LLM
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT: &str = r#"You are a helpful assistant that generates conventional commit messages.
+
+Analyze the git diff provided and generate a commit message following the Conventional Commits specification.
+
+Format: <type>[optional scope]: <description>
+
+Types:
+- feat: A new feature
+- fix: A bug fix
+- docs: Documentation only changes
+- style: Changes that don't affect code meaning (formatting, semicolons, etc.)
+- refactor: Code change that neither fixes a bug nor adds a feature
+- perf: Code change that improves performance
+- test: Adding or correcting tests
+- build: Changes to build system or dependencies
+- ci: Changes to CI configuration
+- chore: Other changes that don't modify src or test files
+- revert: Reverts a previous commit
+
+Rules:
+1. Use lowercase for type and scope
+2. Keep description under 100 characters
+3. Use imperative mood ("add" not "added")
+4. Don't capitalize first letter
+5. No period at the end
+6. Include scope if the change is specific to a module/component
+
+Output ONLY the commit message, nothing else.
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_ZH: &str = r#"你是一个生成符合 Conventional Commits 规范的提交消息的助手。
+
+分析提供的 git diff，并生成符合 Conventional Commits 规范的提交消息。
+
+格式: <type>[可选作用域]: <描述>
+
+类型:
+- feat: 新功能
+- fix: 修复错误
+- docs: 仅文档更改
+- style: 不影响代码含义的更改（格式化、分号等）
+- refactor: 既不修复错误也不添加功能的代码更改
+- perf: 提高性能的代码更改
+- test: 添加或更正测试
+- build: 更改构建系统或依赖项
+- ci: 更改 CI 配置
+- chore: 其他不修改 src 或测试文件的更改
+- revert: 撤销之前的提交
+
+规则:
+1. 类型和小写使用小写
+2. 描述保持在 100 个字符以内
+3. 使用祈使语气（"添加"而不是"已添加"）
+4. 不要大写首字母
+5. 结尾不要句号
+6. 如果更改特定于模块/组件，请包含作用域
+7. 仅输出提交消息，不要输出其他内容。
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_JA: &str = r#"あなたはConventional Commits仕様に従ったコミットメッセージを生成するアシスタントです。
+
+提供されたgit diffを分析し、Conventional Commits仕様に従ったコミットメッセージを生成してください。
+
+形式: <type>[オプションのスコープ]: <説明>
+
+タイプ:
+- feat: 新機能
+- fix: バグ修正
+- docs: ドキュメントのみの変更
+- style: コードの意味に影響しない変更（フォーマット、セミコロンなど）
+- refactor: バグ修正や機能追加を伴わないコード変更
+- perf: パフォーマンスを向上させるコード変更
+- test: テストの追加または修正
+- build: ビルドシステムまたは依存関係の変更
+- ci: CI設定の変更
+- chore: srcやテストファイルを変更しないその他の変更
+- revert: 以前のコミットを取り消す
+
+ルール:
+1. タイプとスコープは小文字を使用
+2. 説明は100文字以内にする
+3. 命令形を使用する（"追加"ではなく"追加する"）
+4. 先頭を大文字にしない
+5. 最後にピリオドを付けない
+6. 変更がモジュール/コンポーネントに固有の場合はスコープを含める
+7. コミットメッセージのみを出力し、それ以外は出力しないでください。
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_KO: &str = r#"당신은 Conventional Commits 사양에 따른 커밋 메시지를 생성하는 도우미입니다.
+
+제공된 git diff를 분석하고 Conventional Commits 사양에 따른 커밋 메시지를 생성하세요.
+
+형식: <type>[선택적 범위]: <설명>
+
+유형:
+- feat: 새 기능
+- fix: 버그 수정
+- docs: 문서 변경만
+- style: 코드 의미에 영향을 주지 않는 변경(서식, 세미콜론 등)
+- refactor: 버그를 수정하거나 기능을 추가하지 않는 코드 변경
+- perf: 성능을 향상시키는 코드 변경
+- test: 테스트 추가 또는 수정
+- build: 빌드 시스템 또는 종속성 변경
+- ci: CI 구성 변경
+- chore: src 또는 테스트 파일을 수정하지 않는 기타 변경
+- revert: 이전 커밋 되돌리기
+
+규칙:
+1. 유형과 범위는 소문자 사용
+2. 설명은 100자 이내로 유지
+3. 명령형 사용("추가"가 아닌 "추가하다")
+4. 첫 글자 대문자화하지 않음
+5. 끝에 마침표 사용하지 않음
+6. 변경 사항이 모듈/구성 요소에 특정한 경우 범위 포함
+7. 커밋 메시지만 출력하고 다른 내용은 출력하지 마세요.
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_ES: &str = r#"Eres un asistente que genera mensajes de commit siguiendo la especificación Conventional Commits.
+
+Analiza el diff de git proporcionado y genera un mensaje de commit siguiendo la especificación Conventional Commits.
+
+Formato: <tipo>[alcance opcional]: <descripción>
+
+Tipos:
+- feat: Una nueva característica
+- fix: Una corrección de error
+- docs: Solo cambios en documentación
+- style: Cambios que no afectan el significado del código (formato, punto y coma, etc.)
+- refactor: Cambio de código que no corrige un error ni agrega una característica
+- perf: Cambio de código que mejora el rendimiento
+- test: Agregar o corregir pruebas
+- build: Cambios en el sistema de construcción o dependencias
+- ci: Cambios en la configuración de CI
+- chore: Otros cambios que no modifican archivos src o de prueba
+- revert: Revierte un commit anterior
+
+Reglas:
+1. Usa minúsculas para tipo y alcance
+2. Mantén la descripción bajo 100 caracteres
+3. Usa modo imperativo ("agregar" no "agregado")
+4. No capitalices la primera letra
+5. Sin punto al final
+6. Incluye alcance si el cambio es específico de un módulo/componente
+7. Genera SOLO el mensaje de commit, nada más.
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_FR: &str = r#"Vous êtes un assistant qui génère des messages de commit suivant la spécification Conventional Commits.
+
+Analysez le diff git fourni et générez un message de commit suivant la spécification Conventional Commits.
+
+Format: <type>[portée optionnelle]: <description>
+
+Types:
+- feat: Une nouvelle fonctionnalité
+- fix: Une correction de bug
+- docs: Changements de documentation uniquement
+- style: Changements qui n'affectent pas la signification du code (formatage, points-virgules, etc.)
+- refactor: Changement de code qui ne corrige pas un bug ni n'ajoute une fonctionnalité
+- perf: Changement de code qui améliore les performances
+- test: Ajout ou correction de tests
+- build: Changements du système de build ou des dépendances
+- ci: Changements de la configuration CI
+- chore: Autres changements qui ne modifient pas les fichiers src ou de test
+- revert: Révertit un commit précédent
+
+Règles:
+1. Utilisez des minuscules pour le type et la portée
+2. Gardez la description sous 100 caractères
+3. Utilisez le mode impératif ("ajouter" non "ajouté")
+4. Ne capitalisez pas la première lettre
+5. Pas de point à la fin
+6. Incluez la portée si le changement est spécifique à un module/composant
+7. Générez SEULEMENT le message de commit, rien d'autre.
+"#;
+
+const CONVENTIONAL_COMMIT_SYSTEM_PROMPT_DE: &str = r#"Sie sind ein Assistent, der Commit-Nachrichten gemäß der Conventional Commits-Spezifikation generiert.
+
+Analysieren Sie den bereitgestellten git diff und generieren Sie eine Commit-Nachricht gemäß der Conventional Commits-Spezifikation.
+
+Format: <typ>[optionaler Bereich]: <beschreibung>
+
+Typen:
+- feat: Eine neue Funktion
+- fix: Ein Bugfix
+- docs: Nur Dokumentationsänderungen
+- style: Änderungen, die die Code-Bedeutung nicht beeinflussen (Formatierung, Semikolons usw.)
+- refactor: Code-Änderung, die weder einen Bug behebt noch eine Funktion hinzufügt
+- perf: Code-Änderung, die die Leistung verbessert
+- test: Hinzufügen oder Korrigieren von Tests
+- build: Änderungen am Build-System oder Abhängigkeiten
+- ci: Änderungen an der CI-Konfiguration
+- chore: Andere Änderungen, die src- oder Testdateien nicht ändern
+- revert: Setzt einen vorherigen Commit zurück
+
+Regeln:
+1. Verwenden Sie Kleinbuchstaben für Typ und Bereich
+2. Halten Sie die Beschreibung unter 100 Zeichen
+3. Verwenden Sie den Imperativ ("hinzufügen" nicht "hinzugefügt")
+4. Großschreiben Sie den ersten Buchstaben nicht
+5. Kein Punkt am Ende
+6. Fügen Sie einen Bereich ein, wenn die Änderung spezifisch für ein Modul/Komponente ist
+7. Geben Sie NUR die Commit-Nachricht aus, nichts anderes.
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT: &str = r#"You are a helpful assistant that generates commit messages following @commitlint/config-conventional.
+
+Analyze the git diff and generate a commit message.
+
+Format: <type>[optional scope]: <subject>
+
+Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+Rules:
+1. Subject should not start with uppercase
+2. Subject should not end with period
+3. Subject should be 4-100 characters
+4. Use imperative mood
+5. Be concise but descriptive
+6. Output ONLY the commit message, nothing else.
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_ZH: &str = r#"你是一个生成符合 @commitlint/config-conventional 规范的提交消息的助手。
+
+分析 git diff 并生成提交消息。
+
+格式: <type>[可选作用域]: <主题>
+
+类型: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+规则:
+1. 主题不应以大写字母开头
+2. 主题不应以句号结尾
+3. 主题应为 4-100 个字符
+4. 使用祈使语气
+5. 简洁但描述性强
+6. 仅输出提交消息，不要输出其他额外内容。
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_JA: &str = r#"あなたは@commitlint/config-conventionalに従ったコミットメッセージを生成するアシスタントです。
+
+git diffを分析し、コミットメッセージを生成してください。
+
+形式: <type>[オプションのスコープ]: <件名>
+
+タイプ: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+ルール:
+1. 件名は大文字で始めないでください
+2. 件名はピリオドで終わらないでください
+3. 件名は4-100文字である必要があります
+4. 命令形を使用してください
+5. 簡潔ですが説明的であること
+6. コミットメッセージのみを出力し、それ以外は出力しないでください。
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_KO: &str = r#"당신은 @commitlint/config-conventional에 따른 커밋 메시지를 생성하는 도우미입니다.
+
+git diff를 분석하고 커밋 메시지를 생성하세요.
+
+형식: <type>[선택적 범위]: <제목>
+
+유형: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+규칙:
+1. 제목은 대문자로 시작하지 않아야 합니다
+2. 제목은 마침표로 끝나지 않아야 합니다
+3. 제목은 4-100자여야 합니다
+4. 명령형을 사용하세요
+5. 간결하지만 설명적이어야 합니다
+6. 커밋 메시지만 출력하고 다른 내용은 출력하지 마세요.
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_ES: &str = r#"Eres un asistente que genera mensajes de commit siguiendo @commitlint/config-conventional.
+
+Analiza el diff de git y genera un mensaje de commit.
+
+Formato: <tipo>[alcance opcional]: <asunto>
+
+Tipos: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+Reglas:
+1. El asunto no debe comenzar con mayúscula
+2. El asunto no debe terminar con punto
+3. El asunto debe tener 4-100 caracteres
+4. Usa modo imperativo
+5. Sé conciso pero descriptivo
+6. Genera SOLO el mensaje de commit, nada más.
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_FR: &str = r#"Vous êtes un assistant qui génère des messages de commit suivant @commitlint/config-conventional.
+
+Analysez le diff git et générez un message de commit.
+
+Format: <type>[portée optionnelle]: <sujet>
+
+Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+Règles:
+1. Le sujet ne doit pas commencer par une majuscule
+2. Le sujet ne doit pas se terminer par un point
+3. Le sujet doit avoir 4-100 caractères
+4. Utilisez le mode impératif
+5. Soyez concis mais descriptif
+6. Générez SEULEMENT le message de commit, rien d'autre.
+"#;
+
+const COMMITLINT_SYSTEM_PROMPT_DE: &str = r#"Sie sind ein Assistent, der Commit-Nachrichten gemäß @commitlint/config-conventional generiert.
+
+Analysieren Sie den git diff und generieren Sie eine Commit-Nachricht.
+
+Format: <typ>[optionaler Bereich]: <betreff>
+
+Typen: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+Regeln:
+1. Der Betreff sollte nicht mit einem Großbuchstaben beginnen
+2. Der Betreff sollte nicht mit einem Punkt enden
+3. Der Betreff sollte 4-100 Zeichen haben
+4. Verwenden Sie den Imperativ
+5. Seien Sie prägnant aber beschreibend
+6. Geben Sie NUR die Commit-Nachricht aus, nichts anderes.
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT: &str = r#"You are a helpful assistant that generates git tag annotation messages.
+
+Given a version number and a list of commits, generate a concise but informative tag message.
+
+The message should:
+1. Start with a brief summary of the release
+2. Group changes by type (features, fixes, etc.)
+3. Be suitable for a git annotated tag
+
+Format:
+<version> Release
+
+Summary of changes...
+
+Changes:
+- Feature: description
+- Fix: description
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_ZH: &str = r#"你是一个生成 git 标签注释消息的助手。
+
+给定版本号和提交列表，生成简洁但信息丰富的标签消息。
+
+消息应该：
+1. 以发布的简要摘要开始
+2. 按类型分组更改（功能、修复等）
+3. 适合 git 标注标签
+
+格式：
+<version> 发布
+
+更改摘要...
+
+更改：
+- 功能：描述
+- 修复：描述
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_JA: &str = r#"あなたはgitタグ注釈メッセージを生成するアシスタントです。
+
+バージョン番号とコミットのリストを考慮して、簡潔ですが情報豊富なタグメッセージを生成してください。
+
+メッセージは以下のようであるべきです：
+1. リリースの簡単な要約から始める
+2. タイプ別に変更をグループ化する（機能、修正など）
+3. git注釈タグに適している
+
+形式：
+<version> リリース
+
+変更の概要...
+
+変更：
+- 機能：説明
+- 修正：説明
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_KO: &str = r#"당신은 git 태그 주석 메시지를 생성하는 도우미입니다.
+
+버전 번호와 커밋 목록을 고려하여 간결하지만 정보가 풍부한 태그 메시지를 생성하세요.
+
+메시지는 다음과 같아야 합니다:
+1. 릴리스의 간단한 요약으로 시작
+2. 유형별로 변경 사항 그룹화(기능, 수정 등)
+3. git 주석 태그에 적합
+
+형식:
+<version> 릴리스
+
+변경 사항 요약...
+
+변경 사항:
+- 기능: 설명
+- 수정: 설명
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_ES: &str = r#"Eres un asistente que genera mensajes de anotación de etiquetas git.
+
+Dado un número de versión y una lista de commits, genera un mensaje de etiqueta conciso pero informativo.
+
+El mensaje debe:
+1. Comenzar con un resumen breve de la versión
+2. Agrupar cambios por tipo (características, correcciones, etc.)
+3. Ser adecuado para una etiqueta git anotada
+
+Formato:
+<version> Versión
+
+Resumen de cambios...
+
+Cambios:
+- Característica: descripción
+- Corrección: descripción
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_FR: &str = r#"Vous êtes un assistant qui génère des messages d'annotation de balises git.
+
+Étant donné un numéro de version et une liste de commits, générez un message de balise concis mais informatif.
+
+Le message doit :
+1. Commencer par un bref résumé de la version
+2. Grouper les changements par type (fonctionnalités, corrections, etc.)
+3. Être adapté à une balise git annotée
+
+Format :
+<version> Version
+
+Résumé des changements...
+
+Changements :
+- Fonctionnalité : description
+- Correction : description
+...
+"#;
+
+const TAG_MESSAGE_SYSTEM_PROMPT_DE: &str = r#"Sie sind ein Assistent, der git-Tag-Anmerkungsnachrichten generiert.
+
+Gegeben eine Versionsnummer und eine Liste von Commits, generieren Sie eine prägnante aber informative Tag-Nachricht.
+
+Die Nachricht sollte:
+1. Mit einer kurzen Zusammenfassung der Version beginnen
+2. Änderungen nach Typ gruppieren (Funktionen, Fixes, etc.)
+3. Für ein git-annotiertes Tag geeignet sein
+
+Format:
+<version> Version
+
+Zusammenfassung der Änderungen...
+
+Änderungen:
+- Funktion: Beschreibung
+- Fix: Beschreibung
+...
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT: &str = r#"You are a helpful assistant that generates changelog entries.
+
+Given a version and a list of commits, generate a well-formatted changelog section.
+
+Group commits by:
+- Features (feat)
+- Bug Fixes (fix)
+- Documentation (docs)
+- Other Changes
+
+Format in markdown with proper headings and bullet points.
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_ZH: &str = r#"你是一个生成变更日志条目的助手。
+
+给定版本和提交列表，生成格式良好的变更日志部分。
+
+按以下方式分组提交：
+- 功能 (feat)
+- 错误修复 (fix)
+- 文档 (docs)
+- 其他更改
+
+使用适当的标题和项目符号以 markdown 格式输出。
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_JA: &str = r#"あなたは変更ログエントリを生成するアシスタントです。
+
+バージョンとコミットのリストを考慮して、適切にフォーマットされた変更ログセクションを生成してください。
+
+コミットを以下でグループ化してください：
+- 機能 (feat)
+- バグ修正 (fix)
+- ドキュメント (docs)
+- その他の変更
+
+適切な見出しと箇条書きを使用してmarkdown形式でフォーマットしてください。
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_KO: &str = r#"당신은 변경 로그 항목을 생성하는 도우미입니다.
+
+버전과 커밋 목록을 고려하여 잘 포맷된 변경 로그 섹션을 생성하세요.
+
+다음으로 커밋을 그룹화하세요:
+- 기능 (feat)
+- 버그 수정 (fix)
+- 문서 (docs)
+- 기타 변경 사항
+
+적절한 제목과 글머리 기호를 사용하여 markdown 형식으로 포맷하세요.
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_ES: &str = r#"Eres un asistente que genera entradas de registro de cambios.
+
+Dada una versión y una lista de commits, genera una sección de registro de cambios bien formateada.
+
+Agrupa los commits por:
+- Características (feat)
+- Correcciones de errores (fix)
+- Documentación (docs)
+- Otros cambios
+
+Formatea en markdown con encabezados y viñetas apropiados.
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_FR: &str = r#"Vous êtes un assistant qui génère des entrées de journal des modifications.
+
+Étant donné une version et une liste de commits, générez une section de journal des modifications bien formatée.
+
+Groupez les commits par :
+- Fonctionnalités (feat)
+- Corrections de bugs (fix)
+- Documentation (docs)
+- Autres modifications
+
+Formatez en markdown avec des en-têtes et des puces appropriés.
+"#;
+
+const CHANGELOG_SYSTEM_PROMPT_DE: &str = r#"Sie sind ein Assistent, der Changelog-Einträge generiert.
+
+Gegeben eine Version und eine Liste von Commits, generieren Sie einen gut formatierten Changelog-Abschnitt.
+
+Gruppieren Sie Commits nach:
+- Funktionen (feat)
+- Bugfixes (fix)
+- Dokumentation (docs)
+- Andere Änderungen
+
+Formatieren Sie in Markdown mit geeigneten Überschriften und Aufzählungspunkten.
+"#;

src/llm/thinking.rs

@@ -64,18 +64,10 @@ impl Default for ThinkingStateManager {
 /// 线程安全的思考状态管理器引用
 pub type SharedThinkingState = Arc<ThinkingStateManager>;
 
-/// 创建带有默认控制台输出的思考状态管理器
+/// 创建 LLM 流式使用的共享思考状态。
-/// 在思考开始时打印 "thinking..."，在思考结束时清除该标识
+/// 进度显示由 AI 生成 spinner 负责（issue 21），此处不再附加控制台输出。
 pub fn create_console_thinking_state() -> SharedThinkingState {
-    Arc::new(
+    Arc::new(ThinkingStateManager::new())
-        ThinkingStateManager::new()
-            .on_thinking_start(|| {
-                eprint!("\rthinking...");
-            })
-            .on_thinking_end(|| {
-                eprint!("\r          \r");
-            }),
-    )
 }
 
 #[cfg(test)]

src/main.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 use anyhow::Result;
 use clap::{Parser, Subcommand};
 use std::path::PathBuf;
@@ -22,7 +20,7 @@ use quicommit::commands::{
 #[command(propagate_version = true)]
 #[command(arg_required_else_help = true)]
 struct Cli {
-    /// Enable verbose output
+    /// Increase verbosity (-v: info, -vv: debug, -vvv: trace)
     #[arg(short, long, global = true, action = clap::ArgAction::Count)]
     verbose: u8,
 
@@ -31,9 +29,17 @@ struct Cli {
     config: Option<String>,
 
     /// Disable colored output
-    #[arg(long, global = true, env = "NO_COLOR")]
+    #[arg(long, global = true)]
     no_color: bool,
 
+    /// Force emoji decorations on (overrides config)
+    #[arg(long, global = true, conflicts_with = "no_emoji")]
+    emoji: bool,
+
+    /// Disable emoji/symbol decorations
+    #[arg(long, global = true)]
+    no_emoji: bool,
+
     #[command(subcommand)]
     command: Commands,
 }
@@ -73,6 +79,31 @@ enum Commands {
 async fn main() -> Result<()> {
     let cli = Cli::parse();
 
+    // Apply the global color decision before any output is produced.
+    // --no-color disables colors; NO_COLOR follows the no-color.org spec
+    // (any presence, regardless of value, disables color).
+    let no_color = cli.no_color || std::env::var_os("NO_COLOR").is_some();
+    colored::control::set_override(!no_color);
+
+    // Resolve the decoration switch (issue 14): explicit flag > config >
+    // default; --no-color disables decorations too (ADR-0003).
+    let emoji_from_config = cli
+        .config
+        .as_deref()
+        .map(PathBuf::from)
+        .or_else(|| quicommit::config::AppConfig::default_path().ok())
+        .and_then(|path| quicommit::config::AppConfig::load(&path).ok())
+        .map(|config| config.output.emoji)
+        .unwrap_or(true);
+    let emoji_enabled = if no_color || cli.no_emoji {
+        false
+    } else if cli.emoji {
+        true
+    } else {
+        emoji_from_config
+    };
+    quicommit::utils::set_emoji_enabled(emoji_enabled);
+
     let log_level = match cli.verbose {
         0 => "warn",
         1 => "info",
@@ -80,8 +111,11 @@ async fn main() -> Result<()> {
         _ => "trace",
     };
 
+    // RUST_LOG takes precedence when set; otherwise -v decides (issue 23).
+    let filter = tracing_subscriber::EnvFilter::try_from_default_env()
+        .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new(log_level));
     tracing_subscriber::fmt()
-        .with_env_filter(log_level)
+        .with_env_filter(filter)
         .with_target(false)
         .init();
 

src/utils/keyring.rs

@@ -232,9 +232,7 @@ impl KeyringManager {
                     "Keyring is available".to_string()
                 }
             }
-            KeyringStatus::Unavailable => {
+            KeyringStatus::Unavailable => "Keyring is not available on this system.".to_string(),
-                "Keyring is not available. Set QUICOMMIT_API_KEY environment variable.".to_string()
-            }
         }
     }
 }

src/utils/mod.rs

@@ -6,48 +6,144 @@ pub mod validators;
 
 use anyhow::{Context, Result};
 use colored::Colorize;
-use std::io::{self, Write};
+use std::io;
+use std::sync::OnceLock;
+use std::time::Duration;
+
+/// Process-global decoration switch (issue 14).
+static EMOJI_ENABLED: OnceLock<bool> = OnceLock::new();
+
+/// Set whether emoji/symbol decorations are shown. Called once from `main`
+/// after resolving config + flags.
+pub fn set_emoji_enabled(enabled: bool) {
+    let _ = EMOJI_ENABLED.set(enabled);
+}
+
+/// Whether emoji/symbol decorations are shown.
+pub fn emoji_enabled() -> bool {
+    *EMOJI_ENABLED.get_or_init(|| true)
+}
+
+/// Styled decoration prefix for status lines; empty when decorations are off
+/// (ADR-0003: message text never embeds decorations).
+pub fn success_prefix() -> colored::ColoredString {
+    if emoji_enabled() {
+        "✓".green().bold()
+    } else {
+        "".normal()
+    }
+}
+
+pub fn error_prefix() -> colored::ColoredString {
+    if emoji_enabled() {
+        "✗".red().bold()
+    } else {
+        "".normal()
+    }
+}
+
+pub fn warning_prefix() -> colored::ColoredString {
+    if emoji_enabled() {
+        "⚠".yellow().bold()
+    } else {
+        "".normal()
+    }
+}
+
+pub fn info_prefix() -> colored::ColoredString {
+    if emoji_enabled() {
+        "ℹ".blue().bold()
+    } else {
+        "".normal()
+    }
+}
+
+pub fn progress_prefix() -> colored::ColoredString {
+    if emoji_enabled() {
+        "→".cyan()
+    } else {
+        "".normal()
+    }
+}
+
+fn print_decorated(prefix: colored::ColoredString, msg: &str, to_stderr: bool) {
+    if emoji_enabled() {
+        if to_stderr {
+            eprintln!("{} {}", prefix, msg);
+        } else {
+            println!("{} {}", prefix, msg);
+        }
+    } else if to_stderr {
+        eprintln!("{}", msg);
+    } else {
+        println!("{}", msg);
+    }
+}
 
 /// Print success message
 pub fn print_success(msg: &str) {
-    println!("{} {}", "✓".green().bold(), msg);
+    print_decorated(success_prefix(), msg, false);
 }
 
-/// Print error message
+/// Print error message to stderr
 pub fn print_error(msg: &str) {
-    eprintln!("{} {}", "✗".red().bold(), msg);
+    print_decorated(error_prefix(), msg, true);
 }
 
 /// Print warning message
 pub fn print_warning(msg: &str) {
-    println!("{} {}", "⚠".yellow().bold(), msg);
+    print_decorated(warning_prefix(), msg, false);
+}
+
+/// Print warning message to stderr (stdout must stay clean, e.g. exports)
+pub fn eprint_warning(msg: &str) {
+    print_decorated(warning_prefix(), msg, true);
 }
 
 /// Print info message
 pub fn print_info(msg: &str) {
-    println!("{} {}", "ℹ".blue().bold(), msg);
+    print_decorated(info_prefix(), msg, false);
 }
 
-/// Confirm action with user
+/// Print progress/status message (→ prefix when decorations are on)
-pub fn confirm(prompt: &str) -> Result<bool> {
+pub fn print_progress(msg: &str) {
-    print!("{} [y/N] ", prompt);
+    print_decorated(progress_prefix(), msg, false);
-    io::stdout().flush()?;
-
-    let mut input = String::new();
-    io::stdin().read_line(&mut input)?;
-
-    Ok(input.trim().to_lowercase().starts_with('y'))
 }
 
-/// Get user input
+/// Progress spinner for long-running operations (issue 21).
-pub fn input(prompt: &str) -> Result<String> {
+/// Degrades to a static line when stdout is not a terminal or when
-    print!("{}: ", prompt);
+/// decorations are disabled.
-    io::stdout().flush()?;
+pub struct Spinner {
+    bar: Option<indicatif::ProgressBar>,
+}
 
-    let mut input = String::new();
+impl Spinner {
-    io::stdin().read_line(&mut input)?;
+    pub fn start(msg: &str) -> Self {
+        if emoji_enabled() && std::io::IsTerminal::is_terminal(&io::stdout()) {
+            let bar = indicatif::ProgressBar::new_spinner();
+            bar.set_message(msg.to_string());
+            bar.enable_steady_tick(Duration::from_millis(100));
+            Self { bar: Some(bar) }
+        } else {
+            println!("{}", msg);
+            Self { bar: None }
+        }
+    }
 
-    Ok(input.trim().to_string())
+    /// Stop the spinner, erasing it from the terminal (no completion line).
+    pub fn finish_clear(&self) {
+        if let Some(bar) = &self.bar {
+            bar.finish_and_clear();
+        }
+    }
+
+    /// Stop the spinner and print a completion line.
+    pub fn finish_with(&self, msg: &str) {
+        if let Some(bar) = &self.bar {
+            bar.finish_and_clear();
+        }
+        println!("{}", msg);
+    }
 }
 
 /// Get password input (hidden)
@@ -59,19 +155,3 @@ pub fn password_input(prompt: &str) -> Result<String> {
         .interact()
         .context("Failed to read password")
 }
-
-/// Check if running in a terminal
-pub fn is_terminal() -> bool {
-    atty::is(atty::Stream::Stdout)
-}
-
-/// Format duration in human-readable format
-pub fn format_duration(secs: u64) -> String {
-    if secs < 60 {
-        format!("{}s", secs)
-    } else if secs < 3600 {
-        format!("{}m {}s", secs / 60, secs % 60)
-    } else {
-        format!("{}h {}m", secs / 3600, (secs % 3600) / 60)
-    }
-}

src/utils/validators.rs

@@ -1,6 +1,6 @@
 use anyhow::{Result, bail};
-use lazy_static::lazy_static;
 use regex::Regex;
+use std::sync::LazyLock;
 
 /// Conventional commit types
 pub const CONVENTIONAL_TYPES: &[&str] = &[
@@ -37,32 +37,33 @@ pub const COMMITLINT_TYPES: &[&str] = &[
     "security", // Security-related changes
 ];
 
-lazy_static! {
+/// Regex for conventional commit format
-    /// Regex for conventional commit format
+static CONVENTIONAL_COMMIT_REGEX: LazyLock<Regex> = LazyLock::new(|| {
-    static ref CONVENTIONAL_COMMIT_REGEX: Regex = Regex::new(
+    Regex::new(
-        r"^(?P<type>feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(?:\((?P<scope>[^)]+)\))?(?P<breaking>!)?: (?P<description>.+)$"
+        r"^(?P<type>feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(?:\((?P<scope>[^)]+)\))?(?P<breaking>!)?: (?P<description>.+)$",
-    ).unwrap();
+    )
+    .unwrap()
+});
 
-    /// Regex for scope validation
+/// Regex for scope validation
-    static ref SCOPE_REGEX: Regex = Regex::new(
+static SCOPE_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^[a-z0-9-]+$").unwrap());
-        r"^[a-z0-9-]+$"
-    ).unwrap();
 
-    /// Regex for version tag validation (semver)
+/// Regex for version tag validation (semver)
-    static ref SEMVER_REGEX: Regex = Regex::new(
+static SEMVER_REGEX: LazyLock<Regex> = LazyLock::new(|| {
-        r"^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$"
+    Regex::new(
-    ).unwrap();
+        r"^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$",
+    )
+    .unwrap()
+});
 
-    /// Regex for email validation
+/// Regex for email validation
-    static ref EMAIL_REGEX: Regex = Regex::new(
+static EMAIL_REGEX: LazyLock<Regex> = LazyLock::new(|| {
-        r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
+    Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap()
-    ).unwrap();
+});
 
-    /// Regex for GPG key ID validation
+/// Regex for GPG key ID validation
-    static ref GPG_KEY_ID_REGEX: Regex = Regex::new(
+static GPG_KEY_ID_REGEX: LazyLock<Regex> =
-        r"^[A-F0-9]{16,40}$"
+    LazyLock::new(|| Regex::new(r"^[A-F0-9]{16,40}$").unwrap());
-    ).unwrap();
-}
 
 /// Validate conventional commit message
 pub fn validate_conventional_commit(message: &str) -> Result<()> {

tests/gitignore_tests.rs

@@ -0,0 +1,268 @@
+use quicommit::git::GitRepo;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+use tempfile::TempDir;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/// Run a git command in the given directory, returning stdout as a String.
+/// Panics if the command fails.
+fn git(dir: &Path, args: &[&str]) -> String {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(dir)
+        .output()
+        .expect("Failed to execute git command");
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        panic!("git {:?} failed in {:?}: {}", args, dir, stderr);
+    }
+    String::from_utf8_lossy(&output.stdout).to_string()
+}
+
+/// Initialize a new git repo in the given directory and configure a local
+/// user identity so commits can be created.
+fn init_repo(dir: &Path) {
+    git(dir, &["init"]);
+    git(dir, &["config", "user.name", "Test User"]);
+    git(dir, &["config", "user.email", "test@example.com"]);
+    // Disable commit signing in case the global config enables it.
+    git(dir, &["config", "commit.gpgsign", "false"]);
+}
+
+/// Write a file with the given content, creating parent directories as needed.
+fn write_file(dir: &Path, rel_path: &str, content: &str) {
+    let file_path = dir.join(rel_path);
+    if let Some(parent) = file_path.parent() {
+        fs::create_dir_all(parent).expect("Failed to create parent directories");
+    }
+    fs::write(&file_path, content).expect("Failed to write file");
+}
+
+/// Get the list of files in the index as a String (one path per line).
+fn ls_files(dir: &Path) -> String {
+    git(dir, &["ls-files"])
+}
+
+// ---------------------------------------------------------------------------
+// Tests for is_path_ignored
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_is_path_ignored_with_ignored_path() {
+    let temp_dir = TempDir::new().unwrap();
+    let repo_path = temp_dir.path();
+    init_repo(repo_path);
+
+    write_file(repo_path, ".gitignore", "__pycache__/\n");
+    write_file(repo_path, "__pycache__/foo.pyc", "bytecode");
+    write_file(repo_path, "subdir/__pycache__/bar.pyc", "more bytecode");
+
+    let repo = GitRepo::open(repo_path).expect("Failed to open repo");
+
+    // Top-level ignored file
+    assert!(
+        repo.is_path_ignored("__pycache__/foo.pyc").unwrap(),
+        "__pycache__/foo.pyc should be ignored"
+    );
+
+    // Nested ignored file under a subdirectory
+    assert!(
+        repo.is_path_ignored("subdir/__pycache__/bar.pyc").unwrap(),
+        "subdir/__pycache__/bar.pyc should be ignored"
+    );
+}
+
+#[test]
+fn test_is_path_ignored_with_non_ignored_path() {
+    let temp_dir = TempDir::new().unwrap();
+    let repo_path = temp_dir.path();
+    init_repo(repo_path);
+
+    write_file(repo_path, ".gitignore", "__pycache__/\n");
+    write_file(repo_path, "src/main.rs", "fn main() {}");
+
+    let repo = GitRepo::open(repo_path).expect("Failed to open repo");
+
+    assert!(
+        !repo.is_path_ignored("src/main.rs").unwrap(),
+        "src/main.rs should not be ignored"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Tests for stage_all
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_stage_all_removes_ignored_tracked_files() {
+    let temp_dir = TempDir::new().unwrap();
+    let repo_path = temp_dir.path();
+    init_repo(repo_path);
+
+    // Create and commit __pycache__/foo.pyc so it becomes a tracked file.
+    write_file(repo_path, "__pycache__/foo.pyc", "original bytecode");
+    git(repo_path, &["add", "__pycache__/foo.pyc"]);
+    git(repo_path, &["commit", "-m", "initial commit"]);
+
+    // Add a .gitignore that now ignores __pycache__/.
+    write_file(repo_path, ".gitignore", "__pycache__/\n");
+
+    // Modify the tracked file so the working tree has unstaged changes.
+    write_file(repo_path, "__pycache__/foo.pyc", "modified bytecode");
+
+    let repo = GitRepo::open(repo_path).expect("Failed to open repo");
+    let messages = quicommit::i18n::Messages::new(quicommit::config::Language::English);
+    let removed = repo.stage_all(&messages).expect("stage_all should succeed");
+
+    assert!(
+        removed.iter().any(|f| f == "__pycache__/foo.pyc"),
+        "stage_all should return __pycache__/foo.pyc in removed list, got: {:?}",
+        removed
+    );
+
+    // Verify the file is no longer in the index.
+    let files = ls_files(repo_path);
+    assert!(
+        !files.lines().any(|l| l == "__pycache__/foo.pyc"),
+        "__pycache__/foo.pyc should no longer be in the index, got: {}",
+        files
+    );
+}
+
+#[test]
+fn test_stage_all_no_ignored_files_returns_empty() {
+    let temp_dir = TempDir::new().unwrap();
+    let repo_path = temp_dir.path();
+    init_repo(repo_path);
+
+    write_file(repo_path, ".gitignore", "*.log\n");
+    write_file(repo_path, "src/main.rs", "fn main() {}");
+
+    let repo = GitRepo::open(repo_path).expect("Failed to open repo");
+    let messages = quicommit::i18n::Messages::new(quicommit::config::Language::English);
+    let removed = repo.stage_all(&messages).expect("stage_all should succeed");
+
+    assert!(
+        removed.is_empty(),
+        "stage_all should return empty Vec when no ignored files are tracked, got: {:?}",
+        removed
+    );
+
+    // Verify src/main.rs was staged.
+    let files = ls_files(repo_path);
+    assert!(
+        files.lines().any(|l| l == "src/main.rs"),
+        "src/main.rs should be in the index, got: {}",
+        files
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Tests for stage_files
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_stage_files_skips_ignored_paths() {
+    let temp_dir = TempDir::new().unwrap();
+    let repo_path = temp_dir.path();
+    init_repo(repo_path);
+
+    write_file(repo_path, ".gitignore", "__pycache__/\n");
+    write_file(repo_path, "__pycache__/foo.pyc", "bytecode");
+    write_file(repo_path, "src/main.rs", "fn main() {}");
+
+    let repo = GitRepo::open(repo_path).expect("Failed to open repo");
+    let skipped = repo
+        .stage_files(&["__pycache__/foo.pyc", "src/main.rs"])
+        .expect("stage_files should succeed");
+
+    assert!(
+        skipped.iter().any(|f| f == "__pycache__/foo.pyc"),
+        "skipped list should contain __pycache__/foo.pyc, got: {:?}",
+        skipped
+    );
+    assert!(
+        !skipped.iter().any(|f| f == "src/main.rs"),
+        "skipped list should not contain src/main.rs, got: {:?}",
+        skipped
+    );
+
+    let files = ls_files(repo_path);
+    assert!(
+        files.lines().any(|l| l == "src/main.rs"),
+        "src/main.rs should be staged, got: {}",
+        files
+    );
+    assert!(
+        !files.lines().any(|l| l == "__pycache__/foo.pyc"),
+        "__pycache__/foo.pyc should not be staged, got: {}",
+        files
+    );
+}
+
+#[test]
+fn test_stage_files_all_paths_ignored() {
+    let temp_dir = TempDir::new().unwrap();
+    let repo_path = temp_dir.path();
+    init_repo(repo_path);
+
+    write_file(repo_path, ".gitignore", "__pycache__/\n");
+    write_file(repo_path, "__pycache__/foo.pyc", "bytecode");
+
+    let repo = GitRepo::open(repo_path).expect("Failed to open repo");
+    let skipped = repo
+        .stage_files(&["__pycache__/foo.pyc"])
+        .expect("stage_files should succeed");
+
+    assert!(
+        skipped.iter().any(|f| f == "__pycache__/foo.pyc"),
+        "skipped list should contain __pycache__/foo.pyc, got: {:?}",
+        skipped
+    );
+
+    // Verify the index remains empty (the file was not staged).
+    let files = ls_files(repo_path);
+    assert!(
+        files.trim().is_empty(),
+        "index should be empty, got: {}",
+        files
+    );
+}
+
+#[test]
+fn test_stage_files_normal_paths_unchanged_behavior() {
+    let temp_dir = TempDir::new().unwrap();
+    let repo_path = temp_dir.path();
+    init_repo(repo_path);
+
+    // No .gitignore (or one that does not match these paths).
+    write_file(repo_path, "src/main.rs", "fn main() {}");
+    write_file(repo_path, "src/lib.rs", "pub fn lib() {}");
+
+    let repo = GitRepo::open(repo_path).expect("Failed to open repo");
+    let skipped = repo
+        .stage_files(&["src/main.rs", "src/lib.rs"])
+        .expect("stage_files should succeed");
+
+    assert!(
+        skipped.is_empty(),
+        "skipped list should be empty, got: {:?}",
+        skipped
+    );
+
+    let files = ls_files(repo_path);
+    assert!(
+        files.lines().any(|l| l == "src/main.rs"),
+        "src/main.rs should be staged, got: {}",
+        files
+    );
+    assert!(
+        files.lines().any(|l| l == "src/lib.rs"),
+        "src/lib.rs should be staged, got: {}",
+        files
+    );
+}

tests/integration_tests.rs

@@ -258,6 +258,190 @@ mod config_command {
             .success()
             .stdout(predicate::str::contains("config.toml"));
     }
+
+    #[test]
+    fn test_no_color_disables_ansi() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = cargo_bin_cmd!("quicommit");
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        let mut cmd = cargo_bin_cmd!("quicommit");
+        cmd.args(&[
+            "config",
+            "show",
+            "--no-color",
+            "--config",
+            config_path.to_str().unwrap(),
+        ]);
+
+        let output = cmd.output().unwrap();
+        assert!(output.status.success());
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        assert!(
+            !stdout.contains("\x1b["),
+            "ANSI color codes present despite --no-color"
+        );
+    }
+
+    #[test]
+    fn test_emoji_switch_precedence() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = cargo_bin_cmd!("quicommit");
+        cmd.env_remove("NO_COLOR");
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        let set_format = |extra: &[&str], cfg: &std::path::Path| {
+            let mut c = cargo_bin_cmd!("quicommit");
+            c.env_remove("NO_COLOR");
+            c.args(&["config", "set", "commit.format", "conventional"])
+                .args(extra)
+                .args(&["--config", cfg.to_str().unwrap()]);
+            c.output().unwrap()
+        };
+
+        // Default (config true): decorations shown
+        let out = set_format(&[], &config_path);
+        assert!(out.status.success());
+        assert!(String::from_utf8_lossy(&out.stdout).contains("✓"));
+
+        // Config output.emoji=false: no decorations
+        let mut cmd = cargo_bin_cmd!("quicommit");
+        cmd.env_remove("NO_COLOR");
+        cmd.args(&[
+            "config",
+            "set",
+            "output.emoji",
+            "false",
+            "--config",
+            config_path.to_str().unwrap(),
+        ]);
+        cmd.assert().success();
+
+        let out = set_format(&[], &config_path);
+        assert!(out.status.success());
+        assert!(!String::from_utf8_lossy(&out.stdout).contains("✓"));
+
+        // Explicit --emoji overrides config false
+        let out = set_format(&["--emoji"], &config_path);
+        assert!(out.status.success());
+        assert!(String::from_utf8_lossy(&out.stdout).contains("✓"));
+
+        // Config back to true, then --no-emoji overrides
+        let mut cmd = cargo_bin_cmd!("quicommit");
+        cmd.env_remove("NO_COLOR");
+        cmd.args(&[
+            "config",
+            "set",
+            "output.emoji",
+            "true",
+            "--config",
+            config_path.to_str().unwrap(),
+        ]);
+        cmd.assert().success();
+
+        let out = set_format(&["--no-emoji"], &config_path);
+        assert!(out.status.success());
+        assert!(!String::from_utf8_lossy(&out.stdout).contains("✓"));
+    }
+
+    #[test]
+    fn test_chinese_output_smoke() {
+        let temp_dir = TempDir::new().unwrap();
+        let repo_path = temp_dir.path().to_path_buf();
+        setup_test_repo_with_file(&repo_path, "test.txt", "content");
+
+        let config_path = repo_path.join("config.toml");
+        init_quicommit(&repo_path, &config_path);
+
+        let mut cmd = cargo_bin_cmd!("quicommit");
+        cmd.env_remove("NO_COLOR");
+        cmd.args(&[
+            "config",
+            "set",
+            "language.output_language",
+            "zh",
+            "--config",
+            config_path.to_str().unwrap(),
+        ]);
+        cmd.assert().success();
+
+        let mut cmd = cargo_bin_cmd!("quicommit");
+        cmd.env_remove("NO_COLOR");
+        cmd.args(&[
+            "commit",
+            "--manual",
+            "-m",
+            "feat: 中文冒烟",
+            "--dry-run",
+            "--yes",
+            "--config",
+            config_path.to_str().unwrap(),
+        ])
+        .current_dir(&repo_path);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("试运行"));
+    }
+
+    #[test]
+    fn test_rust_log_env() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = cargo_bin_cmd!("quicommit");
+        cmd.env_remove("NO_COLOR");
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        let mut cmd = cargo_bin_cmd!("quicommit");
+        cmd.env_remove("NO_COLOR");
+        cmd.env("RUST_LOG", "debug");
+        cmd.args(&["config", "path", "--config", config_path.to_str().unwrap()]);
+
+        cmd.assert()
+            .success()
+            .stdout(predicate::str::contains("Starting quicommit"));
+    }
+
+    #[test]
+    fn test_auto_generate_defaults_true() {
+        // Documents the unified --yes semantics (issue 05): with default
+        // config, --yes still AI-generates; deterministic output needs
+        // --no-generate (changelog) or -m (tag).
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+
+        let mut cmd = cargo_bin_cmd!("quicommit");
+        cmd.env_remove("NO_COLOR");
+        cmd.args(&["init", "--yes", "--config", config_path.to_str().unwrap()]);
+        cmd.assert().success();
+
+        for key in [
+            "commit.auto_generate",
+            "tag.auto_generate",
+            "changelog.auto_generate",
+        ] {
+            let mut cmd = cargo_bin_cmd!("quicommit");
+            cmd.env_remove("NO_COLOR");
+            cmd.args(&[
+                "config",
+                "get",
+                key,
+                "--config",
+                config_path.to_str().unwrap(),
+            ]);
+            cmd.assert()
+                .success()
+                .stdout(predicate::str::contains("true"));
+        }
+    }
 }
 
 mod commit_command {
@@ -438,6 +622,8 @@ mod tag_command {
             "tag",
             "--name",
             "v0.1.0",
+            "-m",
+            "Release v0.1.0",
             "--dry-run",
             "--yes",
             "--config",
@@ -469,6 +655,8 @@ mod tag_command {
             "--think",
             "--name",
             "v0.2.0",
+            "-m",
+            "Release v0.2.0",
             "--dry-run",
             "--yes",
             "--config",
@@ -528,6 +716,7 @@ mod changelog_command {
             "changelog",
             "--dry-run",
             "--yes",
+            "--no-generate",
             "--config",
             config_path.to_str().unwrap(),
         ])