🔒

Rusty Commit

AI-powered commit message generator in Rust. Supports 16+ AI providers (Claude, OpenAI, Ollama, etc.), conventional commits, GitMoji, OAuth, and MCP server for editors.

0 installs

Trust: 34 — Low

Security

Ask AI about Rusty Commit

I know everything about Rusty Commit. Ask me about installation, configuration, usage, or troubleshooting.

0/500

Loading tools...

Reviews

Documentation

🦀 Rusty Commit (`rco`)

AI-powered commit message generator written in Rust

Generate conventional commits, GitMoji messages, and PR descriptions using 100+ AI providers

🚀 Fast · 🔒 Secure · 🏠 Local-first · 🔌 Editor integrations via MCP

Installation · Quick Start · Features · Providers · Configuration

✨ Why Rusty Commit?

⚡ Blazing Fast

Native Rust binary with instant startup time. No Node.js bloat, no waiting.

🤖 100+ AI Providers

Works with OpenAI, Claude, Groq, Cerebras, DeepSeek, GitHub Copilot, Ollama, and 90+ more.

🔐 Secure by Default

Optional keychain storage keeps your API keys safe. OAuth support for major providers.

🎨 Flexible Formats

Conventional commits, GitMoji, or custom templates. Multi-language support.

🔄 Multi-Account Support

Seamlessly switch between work and personal accounts, different providers, or models.

📖 Smart Context Awareness

Reads AGENTS.md, CLAUDE.md, GEMINI.md, commitlint configs, and Cargo.toml to generate context-aware commits.

🔌 Editor Integration

MCP server for Cursor, VS Code, Claude Code, and other AI-powered editors.

📦 Installation

One-liner (recommended)

curl -fsSL https://raw.githubusercontent.com/hongkongkiwi/rusty-commit/main/install.sh | bash

🔐 Security-conscious? Verify first

# Download and inspect
curl -fsSL https://raw.githubusercontent.com/hongkongkiwi/rusty-commit/main/install.sh -o install.sh
# Verify with SHA256 checksums, Cosign, GPG, or GitHub attestations
# See: docs/INSTALL-SCRIPT-VERIFICATION.md

Verify release binaries with GPG:

# Download release files
wget https://github.com/hongkongkiwi/rusty-commit/releases/download/v1.0.0/rusty-commit-v1.0.0-x86_64-unknown-linux-musl.tar.gz
wget https://github.com/hongkongkiwi/rusty-commit/releases/download/v1.0.0/rusty-commit-v1.0.0-x86_64-unknown-linux-musl.tar.gz.asc
wget https://github.com/hongkongkiwi/rusty-commit/releases/download/v1.0.0/SHA256SUMS.txt
wget https://github.com/hongkongkiwi/rusty-commit/releases/download/v1.0.0/SHA256SUMS.txt.asc

# Verify GPG signature
gpg --verify SHA256SUMS.txt.asc

# Verify checksums
sha256sum -c SHA256SUMS.txt

Or verify individual files directly:

gpg --verify rusty-commit-v1.0.0-x86_64-unknown-linux-musl.tar.gz.asc

GPG Public Key: 0x0EC2DFF577818B86 (full: 0EC2DFF577818B86BA38DA3F164E3F90E425B2AD)

📦 Package Managers

Platform	Command	Repo
Homebrew	`brew tap hongkongkiwi/rusty-commit && brew install rusty-commit`	homebrew-rusty-commit
Cargo	`cargo install rusty-commit --features secure-storage`	-
Debian/Ubuntu	`wget .../rusty-commit_amd64.deb && sudo dpkg -i rusty-commit_amd64.deb`	-
Fedora/RHEL	`sudo dnf install https://.../rusty-commit.x86_64.rpm`	-
Alpine	`wget .../rusty-commit-x86_64.apk && sudo apk add --allow-untrusted rusty-commit-x86_64.apk`	-
Arch Linux (AUR)	`yay -S rusty-commit` or `paru -S rusty-commit`	Community
Nix/NixOS	`nix-env -iA nixpkgs.rusty-commit` or via flake	nixpkgs-overlays
Windows (Scoop)	`scoop bucket add rusty-commit && scoop install rusty-commit`	scoop-rusty-commit
Windows (Winget)	`winget install hongkongkiwi.rusty-commit`	Community (via winget-pkgs)
Windows (Chocolatey)	`choco install rusty-commit`	Community
Windows (Binary)	Download from releases	-

🚀 Quick Start

Interactive Setup

rco setup              # Quick interactive wizard (recommended)
rco setup --advanced   # Full configuration
rco setup --defaults   # Non-interactive with sensible defaults

Quick Setup asks for:

AI Provider - Choose from 30+ providers (100+ total supported)
API Key - Securely stored in your system's keychain
Commit Format - Conventional commits, GitMoji, or simple

Generate Your First Commit

git add .
rco                    # Interactive mode with review

⚡ Common Options

rco --dry-run          # Preview without committing
rco --edit             # Open in $EDITOR before committing
rco --clipboard        # Copy to clipboard instead
rco --generate 3       # Generate 3 variations
rco --fgm              # Full GitMoji specification
rco -y                 # Auto-commit without confirmation
rco -c "context"       # Add extra context

🔄 Multi-Account Workflow

# Add multiple provider accounts
rco config add-provider                    # Interactive wizard
rco config add-provider --provider openai --alias work-openai

# Switch between them
rco config use-account work-openai
git add . && rco

rco config use-account personal-anthropic
git add . && rco

🎯 Features

Feature	Command
Interactive mode	`rco`
Auto-commit	`rco -y`
Dry-run preview	`rco --dry-run`
Edit in $EDITOR	`rco --edit`
Copy to clipboard	`rco --clipboard`
Generate variations	`rco -g 3`
Add context	`rco -c "Fix OAuth"`
Full GitMoji	`rco --fgm`
Show prompt	`rco --show-prompt`
Debug logging	`RUST_LOG=debug rco`

🤖 Providers

Rusty Commit supports 100+ AI providers. Configure interactively with rco setup or manually:

🔑 OAuth (No API Key)

Provider	Command
Claude (Anthropic)	`rco auth login`
GitHub Copilot	`rco auth login --provider github-copilot`

🔐 API Key Providers

🌟 Popular Providers

Provider	Setup
OpenAI	`rco config set RCO_AI_PROVIDER=openai RCO_API_KEY=sk-... RCO_MODEL=gpt-4o-mini`
Anthropic	`rco config set RCO_AI_PROVIDER=anthropic RCO_API_KEY=sk-ant-... RCO_MODEL=claude-3-5-haiku-20241022`
Google Gemini	`rco config set RCO_AI_PROVIDER=gemini RCO_API_KEY=... RCO_MODEL=gemini-2.5-flash`
xAI/Grok	`rco config set RCO_AI_PROVIDER=xai RCO_API_KEY=... RCO_MODEL=grok-2`
DeepSeek	`rco config set RCO_AI_PROVIDER=deepseek RCO_API_KEY=sk-... RCO_MODEL=deepseek-chat`

⚡ Ultra-Fast Inference

Provider	Setup
Groq	`rco config set RCO_AI_PROVIDER=groq RCO_API_KEY=gsk_... RCO_MODEL=llama-3.3-70b-versatile`
Cerebras	`rco config set RCO_AI_PROVIDER=cerebras RCO_API_KEY=... RCO_MODEL=llama-3.3-70b`
SambaNova	`rco config set RCO_AI_PROVIDER=sambanova RCO_API_KEY=... RCO_MODEL=Meta-Llama-3.3-70B-Instruct`
Nebius	`rco config set RCO_AI_PROVIDER=nebius RCO_API_KEY=...`

🌐 Multi-Model Aggregators

Provider	Setup
OpenRouter	`rco config set RCO_AI_PROVIDER=openrouter RCO_API_KEY=sk-or-...`
Together AI	`rco config set RCO_AI_PROVIDER=together RCO_API_KEY=...`
Fireworks	`rco config set RCO_AI_PROVIDER=fireworks RCO_API_KEY=...`
Replicate	`rco config set RCO_AI_PROVIDER=replicate RCO_API_KEY=...`
DeepInfra	`rco config set RCO_AI_PROVIDER=deepinfra RCO_API_KEY=...`
Novita	`rco config set RCO_AI_PROVIDER=novita RCO_API_KEY=...`

🏢 Enterprise Providers

Provider	Setup
Azure OpenAI	`rco config set RCO_AI_PROVIDER=azure RCO_API_KEY=... RCO_API_URL=https://<resource>.openai.azure.com`
AWS Bedrock	`rco config set RCO_AI_PROVIDER=bedrock`
Google Vertex AI	`rco config set RCO_AI_PROVIDER=vertex`
Mistral	`rco config set RCO_AI_PROVIDER=mistral RCO_API_KEY=... RCO_MODEL=mistral-small-latest`
Cohere	`rco config set RCO_AI_PROVIDER=cohere RCO_API_KEY=... RCO_MODEL=command-r`
AI21 Labs	`rco config set RCO_AI_PROVIDER=ai21 RCO_API_KEY=... RCO_MODEL=jamba-1.5-mini`
Perplexity	`rco config set RCO_AI_PROVIDER=perplexity RCO_API_KEY=...`

🏠 Local/Self-Hosted

Provider	Setup
Ollama	`rco config set RCO_AI_PROVIDER=ollama RCO_MODEL=llama3.2 RCO_API_URL=http://localhost:11434`
LM Studio	`rco config set RCO_AI_PROVIDER=lmstudio RCO_API_URL=http://localhost:1234/v1`
llama.cpp	`rco config set RCO_AI_PROVIDER=llamacpp RCO_API_URL=http://localhost:8080/v1`

🌏 China-based Providers

Provider	Setup
Moonshot/Kimi	`rco config set RCO_AI_PROVIDER=moonshot RCO_API_KEY=...`
SiliconFlow	`rco config set RCO_AI_PROVIDER=siliconflow RCO_API_KEY=...`
Zhipu AI	`rco config set RCO_AI_PROVIDER=zhipu RCO_API_KEY=...`
MiniMax	`rco config set RCO_AI_PROVIDER=minimax RCO_API_KEY=...`
Alibaba Qwen	`rco config set RCO_AI_PROVIDER=dashscope RCO_API_KEY=...`

📋 All 100+ Supported Providers

GPU Cloud & Inference: Cerebras, SambaNova, Nebius, Lambda, Hyperbolic, Kluster, Together, Fireworks, Replicate, Novita, Predibase, TensorOps, Baseten, Chutes, IO.Net, Scaleway, OVHcloud, Friendli, ModelScope

Enterprise & Specialized: Cohere, AI21 Labs, Upstage/Solar, Jina AI, Abacus AI, Bailing, Poe

AI Gateways & Proxies: Helicone, Cloudflare Workers AI, Vercel AI Gateway, Requesty

China-based: Moonshot, SiliconFlow, Zhipu, MiniMax, Baichuan, 01.AI, Dashscope/Alibaba

Local/Self-hosted: Ollama, LM Studio, llama.cpp, KoboldCpp, Text Generation WebUI, Tabby

Additional Providers: Venice, Cortecs, Synthetic, NanoGPT, ZenMux, V0, Morph, Corcel, CyberNative, Edgen, GigaChat, Hydra, Lingyi, Monica, Pollinations, ShuttleAI, Teknium, TheB, TryLeap, Targon, 302.AI, SAP AI Core

🔒 Secure Storage

When built with --features secure-storage:

macOS: Keychain
Linux: Secret Service (GNOME Keyring, KWallet, KeePassXC)
Windows: Credential Manager

Falls back to config file if keychain is unavailable.

⚙️ Configuration

Interactive Configuration

rco setup              # Quick setup (essential settings)
rco setup --advanced   # Advanced setup (all settings)
rco setup --tui        # Force TUI mode (interactive terminal UI)
rco setup --no-tui     # Force dialoguer prompts (no TUI)

The setup wizard automatically detects whether to use TUI mode based on your terminal. Use --tui or --no-tui to override.

TUI Features:

Arrow key navigation through menus
Real-time preview of commit message formats
Visual confirmation of selections
Color-coded provider categories

Configuration Priority

Per-repo config > Global config > Environment variables > Defaults

Manual Config Commands

rco config status                          # Check secure storage status
rco config set RCO_AI_PROVIDER=anthropic   # Set provider
rco config set RCO_MODEL=claude-3-5-haiku  # Set model
rco config get RCO_AI_PROVIDER             # Get current value
rco config describe                        # Show all options
rco config reset --all                     # Reset to defaults

🔧 Common Configuration Options

Key	Description	Default
Provider Settings
`RCO_AI_PROVIDER`	AI backend	`anthropic`
`RCO_MODEL`	Model name	Provider-specific
`RCO_API_KEY`	API key	-
`RCO_API_URL`	Custom endpoint	-
Commit Format
`RCO_COMMIT_TYPE`	Commit format (`conventional`, `gitmoji`)	`conventional`
`RCO_EMOJI`	Include emojis	`false`
`RCO_LANGUAGE`	Output language	`en`
`RCO_DESCRIPTION`	Add description	`false`
`RCO_DESCRIPTION_CAPITALIZE`	Capitalize description	`true`
`RCO_DESCRIPTION_ADD_PERIOD`	Add period to description	`false`
`RCO_DESCRIPTION_MAX_LENGTH`	Max description length	`100`
Context & Learning
`RCO_READ_CONTEXT`	Read `.rco/context.txt`	`true`
`RCO_READ_AGENT_FILES`	Read AGENTS.md, CLAUDE.md, GEMINI.md	`true`
`RCO_READ_COMMITLINT`	Read commit style configs	`true`
`RCO_READ_PROJECT_CONFIG`	Read Cargo.toml, package.json	`true`
`RCO_LEARN_FROM_HISTORY`	Learn from git history	`false`
`RCO_HISTORY_COMMITS_COUNT`	Commits to analyze	`50`
Output Control
`RCO_MAX_TOKENS`	Max response tokens	`1024`
`RCO_TEMPERATURE`	Response creativity	`0.7`
`RCO_ENABLE_COMMIT_BODY`	Add commit body	`false`
`RCO_GENERATE_COUNT`	Variations to generate	`1`
`RCO_ONE_LINE_COMMIT`	Single line message	`false`
Integration
`RCO_CLIPBOARD_ON_TIMEOUT`	Copy to clipboard on timeout	`true`
`RCO_ACTION_ENABLED`	Enable action mode	`false`

🎣 Git Hooks

Install/Uninstall

rco hook set    # Install prepare-commit-msg hook
rco hook unset  # Remove hook

Once installed, git commit (without -m) automatically generates commit messages!

⚙️ Advanced Hooks

# Pre-generation hook
rco config set RCO_PRE_GEN_HOOK="just lint; just test -q"

# Pre-commit hook
rco config set RCO_PRE_COMMIT_HOOK="./scripts/tweak_commit.sh"

# Post-commit hook
rco config set RCO_POST_COMMIT_HOOK="git push"

# Hook behavior
rco config set RCO_HOOK_STRICT=false       # Allow hook failures
rco config set RCO_HOOK_TIMEOUT_MS=60000   # Timeout in ms

Skip Hooks (Per-Run):

rco --no-pre-hooks      # Skip pre-gen + pre-commit hooks
rco --no-post-hooks     # Skip post-commit hooks

🧠 Advanced Features

📝 Commit Body Generation

Enable detailed commit messages with body explaining the "why":

rco config set RCO_ENABLE_COMMIT_BODY=true

Output:

feat(auth): implement OAuth2 PKCE flow

- Add secure token storage with automatic refresh
- Support GitHub, GitLab, and generic OAuth2 providers
- Handle token expiration gracefully

🧠 Style Learning from History

Automatically learn and match your team's commit style:

rco config set RCO_LEARN_FROM_HISTORY=true
rco config set RCO_HISTORY_COMMITS_COUNT=100  # Analyze last 100 commits

Analyzes your git history to detect:

Common commit types and scopes
Average description length
Capitalization preferences
Gitmoji usage patterns
Period usage in descriptions
Subject vs body formatting

Configure how many commits to analyze:

rco config set RCO_HISTORY_COMMITS_COUNT=100  # More commits = better patterns
rco config set RCO_HISTORY_COMMITS_COUNT=20   # Faster, less accurate

😄 GitMoji Support

25+ emojis from gitmoji.dev:

Emoji	Meaning	Use Case
✨	`:sparkles:`	New feature
🐛	`:bug:`	Bug fix
📝	`:memo:`	Documentation
🎨	`:art:`	Code structure/format
♻️	`:recycle:`	Refactoring
⚡	`:zap:`	Performance
✅	`:white_check_mark:`	Tests
🔒	`:lock:`	Security fix
⬆️	`:arrow_up:`	Upgrade dependencies
🔥	`:fire:`	Remove code/files
🚀	`:rocket:`	Deployment
💥	`:boom:`	Breaking changes

📂 Repository Context Awareness

Rusty Commit automatically detects project context to generate better commit messages. Control which sources are read via configuration:

# Enable/disable context reading
rco config set RCO_READ_CONTEXT=true           # Read .rco/context.txt
rco config set RCO_READ_AGENT_FILES=true       # Read AGENTS.md, CLAUDE.md, GEMINI.md
rco config set RCO_READ_PROJECT_CONFIG=true    # Read Cargo.toml, package.json
rco config set RCO_READ_COMMITLINT=true        # Read commit style configs

Context Sources (by priority):

Priority	Source	Description
1	`.rco/context.txt`	Custom project description (highest priority)
2	`AGENTS.md`	AI agent specification (highest priority)
3	`CLAUDE.md`	Claude Code specification
4	`GEMINI.md`	Gemini specification
5	Commit style config	commitlint, cz, conventionalcommits rules
6	`Cargo.toml`	Rust project description
7	`package.json`	Node.js project description

Commit Style Configuration Detection:

Rusty Commit reads existing commit style configurations to match your project's conventions:

File	Format
`commitlint.config.js`	Commitlint (JS)
`commitlint.config.ts`	Commitlint (TypeScript)
`.commitlintrc.js`	Commitlint (legacy)
`.commitlintrc.ts`	Commitlint (legacy TS)
`.commitlintrc.json`	Commitlint (legacy JSON)
`.commitlintrc`	Commitlint (legacy YAML)
`conventionalcommits.yaml`	Conventional Commits
`conventionalcommits.yml`	Conventional Commits
`.czrc`	Cz CLI config
`.cz.json`	Cz JSON config

When detected, rusty-commit learns:

Supported commit types (feat, fix, docs, etc.)
Scope requirements
Header length constraints
Breaking change format

🎨 Custom Skills

Create reusable commit message templates:

rco skills list                           # List available skills
rco skills create my-template             # Create a new skill
rco skills create my-team-style --project # Project-specific skill
rco skills show my-team-style             # Show skill details
rco skills remove my-team-style           # Remove a skill
rco --skill my-team-template              # Use a skill

📥 Import Skills from External Sources

Import skills from various AI tool formats:

# Import from Claude Code
rco skills available claude-code              # List available skills
rco skills import claude-code --name <skill-name>

# Import from Cline
rco skills import cline:/path/to/.cline/skills

# Import from Roo Code
rco skills import roo:owner/repo              # From GitHub repository
rco skills import roo:gist:gist-id            # From GitHub Gist

# Import from Kilo
rco skills import kilo:owner/repo             # From GitHub repository
rco skills import kilo:gist:gist-id           # From GitHub Gist

# Import from .codex directory
rco skills import codex:/path/to/.codex

# Import from GitHub
rco skills import github:owner/repo

# Import from GitHub Gist
rco skills import gist:<gist-id>

# Import from URL
rco skills import https://example.com/skill-definition.md

📝 Custom Prompt Template

Create ~/.config/rustycommit/skills/my-skill/prompt.md:

# Custom Commit Prompt

Analyze this {language} code change:

{diff}

Context: {context}
Format: {commit_type}
Max length: {max_length}

Generate a commit message following our team conventions:
- Use present tense
- Include ticket number if obvious from branch name

🔌 MCP Server

Rusty Commit includes an MCP (Model Context Protocol) server for editor integrations.

rco mcp server --port 3000   # TCP Mode (Cursor, VS Code)
rco mcp stdio                # STDIO Mode (Direct integration)

Cursor: Settings > Features > MCP > Add Server → Type: HTTP → URL: http://localhost:3000

Claude Code: rco mcp stdio | claude-code connect stdio

📋 PR Description Generation

rco pr generate             # Generate PR description for current branch
rco pr generate --base main # Compare against main branch
rco pr browse               # Generate and open PR creation page

🚫 File Exclusion

Exclude files from AI analysis via .rcoignore:

# Dependencies
node_modules/
vendor/

# Build artifacts
*.min.js
*.map
dist/
build/

# IDE
.idea/
.vscode/

# OS
.DS_Store

Or via command line: rco -x "*.lock" -x "*.min.js"

🔄 Updates

rco update --check          # Check for updates
rco update                  # Update to latest
rco update --force          # Force update
rco update --version 1.0.2  # Install specific version

🏃 GitHub Action

- uses: hongkongkiwi/rusty-commit@v1
  with:
    provider: 'anthropic'
    api-key: ${{ secrets.ANTHROPIC_API_KEY }}
    auto-commit: 'true'

🤝 Contributing

See CONTRIBUTING.md for development setup and contribution guidelines.

📄 License

MIT License - see LICENSE for details.

⬆ Back to Top

Made with 🦀 by the Rusty Commit Contributors