Content
# Welcome to my-ai-tools 👋
[](https://github.com/jellydn/my-ai-tools/stargazers)
[](https://github.com/jellydn/my-ai-tools/blob/main/LICENSE)
[](https://github.com/jellydn/my-ai-tools/pulls)
> **Comprehensive configuration management for AI coding tools** - Replicate my complete setup for Claude Code, OpenCode, Amp, Kilo CLI, Codex, Kimi Code, Gemini CLI, Antigravity CLI, Pi, GitHub Copilot CLI, Cursor Agent CLI, Factory Droid, Cline, Grok CLI, MiMo-Code, Qoder CLI, Kiro CLI, Codiff, ctx, Open Code Review, and CCS with custom configurations, MCP servers, skills, plugins, and commands.
📖 **[View Documentation Website](https://ai-tools.itman.fyi)** - Interactive landing page with full documentation and search.
## ✨ Features
- 🚀 **One-line installer** - Get started in seconds
- 🔄 **Bidirectional sync** - Install configs or export your current setup
- 🤖 **Multiple AI tools** - Claude Code, OpenCode, Amp, CCS, Kimi Code, Gemini, Antigravity, Grok, MiMo-Code, Qoder CLI, Kiro CLI, Codiff, ctx, Open Code Review, and more
- 🔌 **MCP Server integration** - Context7, Sequential-thinking, qmd, agentmemory, sem
- 🎯 **Custom agents & skills** - Pre-configured for maximum productivity
- 🤝 **Agent Teams** - Coordinate specialized agents for complex workflows (code review, testing, docs)
- 📦 **Plugin support** - Official and community plugins
- 🛡️ **Git Guard Hook** - Prevents dangerous git commands (force push, hard reset, etc.)
## ⭐ Top 5 Skills
The most-used skills across Claude Code, OpenCode, and other AI tools:
| Skill | What it does | When to use it |
| -------------------------------------- | ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| **adr** | Generate Architecture Decision Records from design discussions | Before implementing significant technical changes — captures the why, alternatives considered, and consequences |
| **codemap** | Parallel codebase analysis producing 7 structured documents | Onboarding to a new project, or before major refactoring — gives you the full picture fast |
| **thermo-nuclear-code-quality-review** | Extremely strict maintainability and structural code quality review | Before merging PRs — catches issues that regular linters miss |
| **babysit-pr** | Continuously monitor open PRs, auto-fix CI failures, surface review feedback | After pushing a PR — hands-off monitoring until it's ready to merge |
| **improve** | Audit any codebase and write implementation plans for cheaper models to execute | When you want a senior-level code review with actionable, self-contained plans |
## 🔌 MCP Servers & Plugins Overview
| Tool | MCP Servers | Plugins/Extensions |
| --------------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Claude Code** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | Official + Community (plannotator, claude-hud, worktrunk, codex) |
| **OpenCode** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | @plannotator/opencode, opencode-chrome-annotation |
| **Codex** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, node_repl, ctx | - |
| **Kimi Code** | context7, sequential-thinking, qmd, agentmemory, fff, logpilot, sem, ctx | Skills, MCP servers, and hooks via `~/.kimi-code/` |
| **Pi** | context7, sequential-thinking, qmd, fff, react-grab-mcp, agentmemory, sem, ctx | Packages (pi-extension, autoresearch, hooks, fff, mcp-adapter, simplify, todo, btw, code-previews, codex-goal, dynamic-workflows, commandcode-provider, pi-web-access, footer, tps-meter) |
| **Amp** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | - |
| **Gemini** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | Deprecated for Google One/unpaid tiers; migrate to Antigravity |
| **Antigravity** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx (via plugin) | my-ai-tools-gemini-migration |
| **Kilo** | (uses OpenCode config) | (uses OpenCode plugins) |
| **CommandCode** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | - |
| **Copilot** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | - |
| **Cursor** | context7 (via bunx), sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | - |
| **Conductor** | Per-harness (Claude Code, Codex, Cursor MCP configs) | Orchestrates parallel agents in isolated workspaces |
| **Factory** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | core, security-engineer, droid-evolved, autoresearch |
| **Orca** | - | Agent hooks (claude, gemini, codex, cursor, droid) |
| **Cline** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | Global rules (AGENTS.md → ~/.cline/rules/, ~~/.agents/AGENTS.md), universal skills (~~/.agents/skills) |
| **Grok** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | Kanagawa palette staged (`tokyonight` until built-in) |
| **MiMo-Code** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | @plannotator/opencode, opencode-chrome-annotation |
| **Qoder CLI** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | - |
| **Kiro CLI** | context7, sequential-thinking, qmd, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx | Steering files (AGENTS.md), slash commands, MCP servers, ACP |
| **Codiff** | — (desktop app — uses configured agent backend via settings) | — |
### 📋 MCP Server Details
| Server | Purpose | Package |
| --------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| `context7` | Documentation lookup for any library | `@upstash/context7-mcp` |
| `sequential-thinking` | Multi-step reasoning for complex analysis | `@modelcontextprotocol/server-sequential-thinking` |
| `qmd` | Knowledge management with AI-powered search | `qmd` |
| `agentmemory` | "Persistent memory" per the tool; we use it session-only (qmd = durable; see `MEMORY.md`) | `@agentmemory/mcp` |
| `fff` | Fast file search with frecency ranking | `fff-mcp` |
| `react-grab-mcp` | React component capture and inspection | `@react-grab/mcp` |
| `logpilot` | AI-powered log analysis and tmux monitoring | `logpilot` |
| `sem` | Semantic version control - entity-level diffs, blame, and impact analysis | `sem-mcp` (via [Ataraxy-Labs/sem](https://github.com/Ataraxy-Labs/sem)) |
| `ctx` | Local agent-history search across coding sessions | `ctx mcp serve` |
## 🎬 Demo
[](https://github.com/jellydn/itman-channel)
[](https://www.youtube.com/watch?v=ESudSFAyuuw)
## 📋 Prerequisites
### All Platforms
- **Bash 3.0+** - Shell interpreter for `cli.sh` and `generate.sh` (the scripts use bash-only syntax — process substitution, arrays, pattern-parameter expansion — that `sh`/`dash` cannot parse; the entry-point scripts `source` [`lib/require_bash.sh`](./lib/require_bash.sh) which auto-relaunches under bash if invoked via `sh`/`dash` — see [Shell Interpreter](#-shell-interpreter) below)
- **Bun or Node.js LTS** - Runtime for tools and scripts
- **Git** - Version control
- **Claude Code subscription** or use [CCS](#-ccs---claude-code-switch-optional) with affordable providers (GLM, MiniMax)
### Windows-Specific
- **Git for Windows** - Required for Git Bash support
- Download: https://git-scm.com/download/win
- Make sure to select "Git from the command line and also from 3rd-party software" during installation
- **PowerShell 5.1+** - For the PowerShell installer
- **jq** - Will be auto-installed via winget if available, or download from [GitHub releases](https://github.com/jqlang/jq/releases)
## 🚀 Quick Start
### One-Line Installer (Recommended)
Install directly without cloning the repository:
```bash
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash
```
> **Security Note:** Review the script before running:
>
> ```bash
> curl -fsSL https://ai-tools.itman.fyi/install.sh -o install.sh
> cat install.sh # Review the script
> bash install.sh
> ```
**Options:**
```bash
# Preview changes without making them
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash -s -- --dry-run
# Backup existing configs before installing
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash -s -- --backup
# Skip backup prompt
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash -s -- --no-backup
# One-step Gemini→Antigravity CLI migration
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash -s -- --migrate-gemini
```
### Manual Installation
Clone the repository and run the installer:
```bash
git clone https://github.com/jellydn/my-ai-tools.git
cd my-ai-tools
./cli.sh
```
**Options:**
- `--dry-run` - Preview changes without making them
- `--backup` - Backup existing configs before installing
- `--no-backup` - Skip backup prompt
- `--migrate-gemini` - One-step Gemini→Antigravity CLI migration
## 🔄 Bidirectional Config Sync
### Forward: Install to Home (`cli.sh`)
Copy configurations from this repository to your home directory (`~/.claude/`, `~/.config/opencode/`, etc.):
```bash
./cli.sh [--dry-run] [--backup] [--no-backup] [--migrate-gemini]
```
### Reverse: Generate from Home (`generate.sh`)
Export your current configurations back to this repository for version control:
```bash
./generate.sh [--dry-run]
```
> **Tip:** Use `generate.sh` after customizing your local setup to save changes back to this repo.
## 🐚 Shell Interpreter
`cli.sh` and `generate.sh` use bash-only syntax (process substitution, arrays, pattern-parameter expansion) and **require bash**. Both scripts `source` [`lib/require_bash.sh`](./lib/require_bash.sh) as their first non-shebang line; that shim is intentionally POSIX-compatible so `sh`/`dash` can source it and transparently re-launch the script under `bash` before `lib/common.sh` is reached. Prefer one of these invocations for clarity:
```bash
./cli.sh # Uses the #!/bin/bash shebang (recommended)
bash cli.sh # Explicit bash
bash generate.sh # Explicit bash for the reverse-sync script
```
> If `bash` is not on `PATH`, the guard falls back to a clear error: `Error: cli.sh requires bash, but bash was not found in PATH`. See `lib/require_bash.sh` for the canonical guard implementation.
## 🪟 Windows Installation
The installer supports Windows via PowerShell or Git Bash.
### Prerequisites for Windows
1. **Git for Windows** - Includes Git Bash (required for running shell scripts)
- Download from: https://git-scm.com/download/win
- During installation, choose "Use Git and optional Unix tools from the Command Prompt" to add Git Bash to PATH
2. **jq** (JSON processor) - Auto-installed via winget if available
- Manual install: `winget install -e --id jqlang.jq`
### Option 1: PowerShell (Recommended for Windows)
```powershell
# Run directly from the published URL
irm https://ai-tools.itman.fyi/install.ps1 | iex
# To pass options, download first, then run the local file:
irm https://ai-tools.itman.fyi/install.ps1 -OutFile install.ps1
.\install.ps1 -DryRun
```
**Local execution:**
```powershell
# Clone and run locally
git clone https://github.com/jellydn/my-ai-tools.git
cd my-ai-tools
.\install.ps1
```
### Option 2: Git Bash
```bash
# Open Git Bash (from right-click menu or Start menu)
git clone https://github.com/jellydn/my-ai-tools.git
cd my-ai-tools
bash ./cli.sh
```
> **Note:** If `bash` is not recognized in PowerShell, add Git to your PATH:
>
> ```powershell
> [Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\Program Files\Git\bin", "User")
> ```
---
Primary AI coding assistant with extensive customization.
### Installation
```bash
curl -fsSL https://claude.ai/install.sh | bash
```
### MCP Servers Setup
#### Automatic Setup (Recommended)
Run the setup script to configure MCP servers:
```bash
./cli.sh
```
The script will prompt you to install each MCP server:
- [`context7`](https://github.com/upstash/context7) - Documentation lookup for any library
- [`sequential-thinking`](https://mcp.so/server/sequentialthinking) - Multi-step reasoning for complex analysis
- [`qmd`](https://github.com/tobi/qmd) - Quick Markdown Search with AI-powered knowledge management
- [`agentmemory`](https://github.com/rohitg00/agentmemory) - "Persistent memory" per the tool's branding; we use it session-only (qmd is the durable KB; see `~/.ai-tools/MEMORY.md`)
- [`fff`](https://github.com/dmtrKovalenko/fff.nvim) - Fast file search with built-in memory for AI agents
- [`react-grab-mcp`](https://github.com/nyan-left/react-grab-mcp) - React component extraction and analysis
- [`logpilot`](https://github.com/jellydn/logpilot) - AI-powered log analysis and tmux session monitoring
#### Manual Setup
##### For Claude Code
Configuration in [`~/.claude/mcp-servers.json`](configs/claude/mcp-servers.json):
```json
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp@latest"]
},
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"qmd": {
"command": "qmd",
"args": ["mcp"]
},
"agentmemory": {
"command": "npx",
"args": ["-y", "@agentmemory/mcp"]
},
"fff": {
"type": "stdio",
"command": "fff-mcp",
"args": []
},
"react-grab-mcp": {
"command": "npx",
"args": ["-y", "@react-grab/mcp", "--stdio"]
},
"logpilot": {
"command": "logpilot",
"args": ["mcp-server"]
}
}
}
```
Or use the CLI (installed globally for all projects):
```bash
claude mcp add --scope user --transport stdio context7 -- npx -y @upstash/context7-mcp@latest
claude mcp add --scope user --transport stdio sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking
claude mcp add --scope user --transport stdio qmd -- qmd mcp
claude mcp add --scope user --transport stdio agentmemory -- npx -y @agentmemory/mcp
claude mcp add --scope user --transport stdio fff -- fff-mcp # Requires: curl -fsSL https://dmtrkovalenko.dev/install-fff-mcp.sh | bash
claude mcp add --scope user --transport stdio logpilot -- logpilot mcp-server # Requires: cargo install logpilot
claude mcp add --scope user --transport stdio sem -- sem-mcp # Requires: cargo install --git https://github.com/Ataraxy-Labs/sem sem-mcp
```
> **MCP Scopes:**
>
> - `--scope user` (global): Available across all projects
> - `--scope local` (default): Only in current project directory
> - `--scope project`: Stored in `.mcp.json` for team sharing
#### Managing MCP Servers
```bash
# List all configured servers
claude mcp list
# Remove an MCP server
claude mcp remove context7
# Get details for a specific server
claude mcp get qmd
```
#### Knowledge Management
Replace deprecated `claude-mem` with **qmd-based knowledge system**:
- Project-specific knowledge bases in `~/.ai-knowledges/`
- AI-powered search via qmd MCP server
- No repository pollution
- See [qmd Knowledge Management Guide](docs/qmd-knowledge-management.md)
### Plugins
#### Prerequisites
Before installing plugins, ensure:
1. **Claude Code subscription** - Active subscription with plugin support
2. **Plugin marketplace access** - Verify marketplace is enabled for your repository
3. **Network connectivity** - Required for downloading marketplace plugins
To check marketplace availability:
```bash
# Verify Claude CLI supports plugins
claude plugin list
# If the above fails, check your Claude Code installation and subscription
```
#### Installation
The setup script (`./cli.sh`) automatically checks marketplace availability before installing plugins. If marketplace is unavailable, it will offer to install local plugins only.
**Automated installation (recommended):**
```bash
./cli.sh # Includes marketplace check and fallback to local plugins
```
**Manual installation** (requires marketplace access):
```bash
# First, add the official marketplace
claude plugin marketplace add anthropics/claude-plugins-official
# Official plugins
claude plugin install typescript-lsp@claude-plugins-official
claude plugin install pyright-lsp@claude-plugins-official
claude plugin install context7@claude-plugins-official
claude plugin install frontend-design@claude-plugins-official
claude plugin install learning-output-style@claude-plugins-official
claude plugin install swift-lsp@claude-plugins-official
claude plugin install lua-lsp@claude-plugins-official
claude plugin install code-simplifier@claude-plugins-official
claude plugin install rust-analyzer-lsp@claude-plugins-official
claude plugin install claude-md-management@claude-plugins-official
# Community plugins (add marketplace first)
# Plugin installation format: plugin-name@marketplace-name
# Example: The repository 'backnotprop/plannotator' registers as marketplace 'plannotator',
# then you install plugin 'plannotator' from that marketplace
claude plugin marketplace add backnotprop/plannotator
claude plugin install plannotator@plannotator
claude plugin marketplace add jarrodwatts/claude-hud
claude plugin install claude-hud@claude-hud
claude plugin marketplace add max-sixty/worktrunk
claude plugin install worktrunk@worktrunk
claude plugin marketplace add openai/codex-plugin-cc
claude plugin install codex@openai-codex
# Install skills from this repository (jellydn/my-ai-tools)
# Recommended: Install all skills at once using npx skills add
npx skills add jellydn/my-ai-tools --yes --global --agent claude-code
# Or install interactively (select which skills to install)
npx skills add jellydn/my-ai-tools --global --agent claude-code
# Available skills: prd, ralph, qmd-knowledge, codemap, adr, handoffs, pickup, pr-review, slop, tdd, thermo-nuclear-code-quality-review, commit-atomic, draft-pull-request, docs-update, llm-wiki, plannotator-setup-goal, portless-local, tmux
# Skills are installed to ~/.agents/skills/ with symlinks in ~/.claude/skills/
```
#### Troubleshooting
**Skills installation issues?**
If you encounter issues:
1. **Check npx availability**: Ensure Node.js and npx are installed (`npx --version`)
2. **Use local skills**: The setup script automatically falls back to local skills from `skills/` folder
3. **Manual installation**: Copy skill folders directly to `~/.claude/skills/`
4. **Interactive mode**: Run without `--yes` flag to select specific skills
**Common issues:**
- "npx not found" → Install Node.js to use remote skill installation, or use local skills via `./cli.sh`
- "Permission denied" → Try running without sudo, or use `--global` flag
- "Skills already installed" → Remove existing skills first with `npx skills remove --global`
#### Plugin List
| Plugin | Description | Source |
| ------------------------------------ | --------------------------------------- | ----------------- |
| `typescript-lsp` | TypeScript language server | Official |
| `pyright-lsp` | Python language server | Official |
| `context7` | Documentation lookup | Official |
| `frontend-design` | UI/UX design assistance | Official |
| `learning-output-style` | Interactive learning mode | Official |
| `swift-lsp` | Swift language support | Official |
| `lua-lsp` | Lua language support | Official |
| `code-simplifier` | Code simplification | Official |
| `rust-analyzer-lsp` | Rust language support | Official |
| `claude-md-management` | Markdown management | Official |
| `plannotator` | Plan annotation tool | Community |
| `plannotator-setup-goal` | Turn ideas into goal packages | Local Marketplace |
| `prd` | Product Requirements Documents | Local Marketplace |
| `ralph` | PRD to JSON converter | Local Marketplace |
| `qmd-knowledge` | Project knowledge management | Local Marketplace |
| `codemap` | Parallel codebase analysis | Local Marketplace |
| `thermo-nuclear-code-quality-review` | Extremely strict maintainability review | Local Marketplace |
| `claude-hud` | Status line with usage monitoring | Community |
| `worktrunk` | Work management | Community |
| `codex` | Codex code review & task delegation | Community |
#### Key Marketplace Plugins
**`codemap`** - Orchestrates parallel codebase analysis producing 7 structured documents in `.planning/codebase/`:
- `STACK.md` - Technologies, dependencies, configuration
- `INTEGRATIONS.md` - 3rd party APIs, databases, auth
- `ARCHITECTURE.md` - System patterns, layers, data flow
- `STRUCTURE.md` - Directory layout, key locations
- `CONVENTIONS.md` - Code style, patterns, error handling
- `TESTING.md` - Framework, structure, mocking, coverage
- `CONCERNS.md` - Tech debt, bugs, security issues
**`prd`** - Generate Product Requirements Documents
**`ralph`** - Convert PRDs to JSON for autonomous agent execution
**`qmd-knowledge`** - Project-specific knowledge management ([guide](docs/qmd-knowledge-management.md))
### Hooks & Status Line
Configure in [`~/.claude/settings.json`](configs/claude/settings.json):
#### PostToolUse Hooks
Auto-format after file edits:
```json
{
"hooks": {
"PostToolUse": [
{
"matcher": "Write|Edit|MultiEdit",
"hooks": [
{
"type": "command",
"command": "jq -r '.tool_input.file_path' | { read file_path; if echo \"$file_path\" | grep -q '\\.(ts|tsx|js|jsx)$'; then biome check --write \"$file_path\"; fi; }"
},
{
"type": "command",
"command": "if [[ \"$( jq -r .tool_input.file_path )\" =~ \\.go$ ]]; then gofmt -w \"$( jq -r .tool_input.file_path )\"; fi"
},
{
"type": "command",
"command": "jq -r '.tool_input.file_path' | { read file_path; if echo \"$file_path\" | grep -q '\\.(md|mdx)$'; then npx prettier --write \"$file_path\"; fi; }"
},
{
"type": "command",
"command": "if [[ \"$( jq -r .tool_input.file_path )\" =~ \\.py$ ]]; then ruff format \"$( jq -r .tool_input.file_path )\"; fi"
},
{
"type": "command",
"command": "if [[ \"$( jq -r .tool_input.file_path )\" =~ \\.rs$ ]]; then rustfmt \"$( jq -r .tool_input.file_path )\"; fi"
},
{
"type": "command",
"command": "if [[ \"$( jq -r .tool_input.file_path )\" =~ \\.sh$ ]]; then shfmt -w \"$( jq -r .tool_input.file_path )\"; fi"
},
{
"type": "command",
"command": "if [[ \"$( jq -r .tool_input.file_path )\" =~ \\.lua$ ]]; then stylua \"$( jq -r .tool_input.file_path )\"; fi"
}
]
}
]
}
}
```
**Supported Formatters:**
- **biome** - TypeScript/JavaScript files (`.ts`, `.tsx`, `.js`, `.jsx`) - includes linting
- **gofmt** - Go files (`.go`)
- **prettier** - Markdown files (`.md`, `.mdx`)
- **ruff** - Python files (`.py`) - modern, fast formatter
- **rustfmt** - Rust files (`.rs`)
- **shfmt** - Shell scripts (`.sh`)
- **stylua** - Lua files (`.lua`)
**Installation:** The setup script (`./cli.sh`) automatically checks and installs these tools with mise priority:
- `jq` - JSON parsing (required)
- `biome` - JavaScript/TypeScript formatting
- `gofmt` - Go formatting (requires Go installation)
- `prettier` - Markdown formatting (used via `npx`)
- `ruff` - Python formatting (installed via mise, pipx, or pip)
- `rustfmt` - Rust formatting (installed via mise or rustup)
- `shfmt` - Shell script formatting (installed via mise, brew, or go install)
- `stylua` - Lua formatting (installed via mise, brew, or cargo)
#### PreToolUse Hooks
##### Git Guard Hook
Prevents dangerous git commands from being executed:
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [
{
"type": "command",
"command": "bun ~/.claude/hooks/index.ts PreToolUse"
}
]
}
]
}
}
```
**Blocked commands:**
- `git push --force` / `-f` (without lease protection)
- `git reset --hard` (destroys uncommitted changes)
- `git clean -fd` (removes untracked files)
- `git branch -D` (force delete branch)
- `git rebase -i` (interactive rebase)
- `git checkout --force` / `-f` (force checkout)
- `git stash drop/clear` (removes stashes)
- And more...
The implementation can be found in `configs/claude/hooks/index.ts` and `configs/claude/hooks/git-guard.ts`.
##### WebSearch Transformer
Transform WebSearch queries:
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "WebSearch",
"hooks": [
{
"type": "command",
"command": "node \"~/.ccs/hooks/websearch-transformer.cjs\"",
"timeout": 120
}
]
}
]
}
}
```
#### Status Line
Using claude-hud plugin:
```json
{
"statusLine": {
"type": "command",
"command": "bash -c 'node \"$(ls -td ~/.claude/plugins/cache/claude-hud/claude-hud/*/ 2>/dev/null | head -1)dist/index.js\"'"
}
}
```
<img width="1058" height="138" alt="Claude HUD Status Line" src="https://github.com/user-attachments/assets/afab87bb-d78f-4cc8-9e1b-f3948a7e6fe6" />
> **Tip:** Auto-compact is disabled. Use `claude-hud` to monitor context usage.
### Custom Commands, Agents & Skills
#### Custom Commands
Located in [`configs/claude/commands/`](configs/claude/commands/):
- `/ccs` - CCS delegation and profile management
- `/ultrathink` - Deep thinking mode
#### Custom Agents
Located in [`configs/claude/agents/`](configs/claude/agents/):
- `ai-slop-remover` - Remove AI-generated boilerplate and improve code quality
- `code-reviewer` - Comprehensive code quality and security review
- `test-generator` - Generate meaningful tests with edge case coverage
- `documentation-writer` - Create clear, helpful documentation
- `feature-team-coordinator` - Coordinate specialized agents for complex workflows
📖 **[Agent Teams Guide](docs/claude-code-teams.md)** - Learn how to use Agent Teams to coordinate multiple specialized agents for complex tasks like feature development, code review, and documentation.
#### Skills
**Local Marketplace Plugins** - Installed by `cli.sh` from [`skills/`](skills/):
- `adr` - Architecture Decision Records
- `codemap` - Parallel codebase analysis producing structured documentation
- `commit-atomic` - Atomic commits by logically grouping changes with commitizen convention (no `git add -A`)
- `draft-pull-request` - Create draft pull requests using gh CLI with what/why/how template
- `handoffs` - Create handoff plans for continuing work (provides `/handoffs` command)
- `llm-wiki` - Build and maintain a persistent, compounding knowledge wiki from raw sources (Karpathy's LLM Wiki pattern)
- `pickup` - Resume work from previous handoff sessions (provides `/pickup` command)
- `plannotator-setup-goal` - Turn an idea into a structured goal package via Plannotator-gated discovery, fact sheet, and plan
- `docs-update` - Automated documentation synchronization with code changes (Mintlify, Docusaurus, GitBook, Fumadocs, etc.)
- `portless-local` - Named .localhost URLs for local development - replaces port numbers with stable URLs
- `pr-review` - Pull request review workflows
- `prd` - Generate Product Requirements Documents
- `qmd-knowledge` - Project knowledge management
- `ralph` - Convert PRDs to JSON for autonomous agent execution
- `slop` - AI slop detection and removal
- `tdd` - Test-Driven Development workflows
- `thermo-nuclear-code-quality-review` - Extremely strict maintainability and structural code quality reviews
- `tmux` - Remote control tmux sessions for interactive CLIs (python, node, gdb, etc.)
#### Projects Built with AI
Real-world projects built using these AI tools:
| Project | Description | Tools Used |
| ------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ------------------------------------------- |
| - [Oak](https://github.com/jellydn/oak) | Lightweight macOS focus companion for deep work with notch-first UI | Ralph + OpenCode + Codex GPT 5.2 |
| - [Prosody](https://github.com/jellydn/prosody) | Mobile app for English speaking rhythm coaching with AI feedback | Ralph + OpenCode + GLM + Amp/Codex (review) |
| - [Keybinder](https://github.com/jellydn/keybinder) | macOS app for managing skhd keyboard shortcuts | Claude + spec-kit |
| - [SealCode](https://github.com/jellydn/vscode-seal-code) | VS Code extension for AI-powered code review | Amp + Ralph |
| - [Ralph](https://github.com/jellydn/ralph) | Autonomous AI agent loop for PRD-driven development | TypeScript |
| - [AI Launcher](https://github.com/jellydn/ai-launcher) | Fast launcher for switching between AI coding assistants | TypeScript |
| - [Tiny Coding Agent](https://github.com/jellydn/tiny-coding-agent) | Minimal coding agent focused on simplicity | TypeScript |
| - [dotenv-tui](https://github.com/jellydn/dotenv-tui) | Terminal UI for managing `.env` files across projects | Go + Bubble Tea |
| - [tiny-cloak.nvim](https://github.com/jellydn/tiny-cloak.nvim) | Neovim plugin that masks sensitive data in `.env` files | Lua + Neovim |
| - [tiny-term.nvim](https://github.com/jellydn/tiny-term.nvim) | Minimal terminal plugin for Neovim 0.11+ | Lua + Neovim |
| - [Sky Alert](https://github.com/jellydn/sky-alert) | Real-time flight monitoring Telegram bot | OpenCode + GLM 4.7 + Amp + Codex CLI |
| - [Docklight](https://github.com/jellydn/docklight) | Minimal, self-hosted web UI for managing a single-node Dokku server | Ralph + OpenCode |
| - [Little Writing](https://github.com/jellydn/little-writing) | A handwriting tracing app for kids built with React, react-konva, and Capacitor | Claude + spec-kit + GLM 5 |
| - [Zed Codemux](https://github.com/jellydn/zed-codemux) | Open Zed terminals inside tmux or zellij — port of vscode-mux to the Zed editor | Ralph |
| - [HermesHub](https://github.com/jellydn/hermes-hub) | Web app for deploying and managing a self-hosted Hermes AI Agent on any VPS | GPT-5.5 + Grok CLI Composer 2.5 |
📖 **[Learning Stories](docs/learning-stories.md)** - Detailed notes on development approaches, key takeaways, and tools I've tried.
#### Recommended Community Skills
Official and community-maintained skill collections for specific frameworks:
| Framework | Skills Repository | Description |
| -------------------------- | ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **UI/UX Design** | [Interface Design](https://interface-design.dev/) | Comprehensive guide to interface design patterns and best practices for anyone working with UI/UX development. |
| **Expo** | [expo/skills](https://github.com/expo/skills) | Official Expo skills for React Native development. Includes app creation, building, debugging, EAS updates, and config management workflows. |
| **Next.js** | [vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills) | Vercel's agent skills for Next.js and React development. Includes project creation, component generation, and deployment workflows. |
| **React Patterns** | [factory-ai/factory-plugins](https://skills.sh/factory-ai/factory-plugins/no-use-effect) | No-use-effect skill: 5 patterns to replace useEffect with better alternatives - derived state, data-fetching libraries, event handlers, useMountEffect, and key prop resets. |
| **Andrej Karpathy** | [forrestchang/andrej-karpathy-skills](https://github.com/forrestchang/andrej-karpathy-skills) | Community skills inspired by Andrej Karpathy's coding principles and practices for AI-focused development workflows. |
| **Humanizer** | [blader/humanizer](https://github.com/blader/humanizer) | Removes signs of AI-generated writing from text. Based on Wikipedia's AI writing detection guide, it detects 24 patterns to make text sound more natural and human. |
| **Claude Skills** | [jezweb/claude-skills](https://github.com/jezweb/claude-skills) | 97 production-ready skills for Claude Code CLI including Cloudflare, React, AI integrations, and more. Includes context-mate for project analysis and workflow management. |
| **OZ Skills** | [warpdotdev/oz-skills](https://github.com/warpdotdev/oz-skills) | 14 production-ready skills by Warp. Covers CI fix, PR creation, web testing, accessibility audits, and more. |
| **Auto-Review** | [openclaw/agent-skills](https://github.com/openclaw/agent-skills/blob/main/skills/autoreview/SKILL.md) | Auto-review skill for structured and actionable pull request feedback workflows. |
| **Skills Discovery** | [vercel-labs/skills/find-skills](https://github.com/vercel-labs/skills/blob/main/skills/find-skills/SKILL.md) | Skill discovery helper. Search and install skills from skills.sh when users ask about capabilities. Uses `npx skills find [query]`. |
| **Matt Pocock** | [mattpocock/skills](https://github.com/mattpocock/skills) | Community skills by Matt Pocock. Includes `grill-with-docs` for docs-grounded plan stress-testing, `improve-codebase-architecture` for finding deepening opportunities, and more. |
| **Mitsuhiko** | [mitsuhiko/agent-stuff](https://github.com/mitsuhiko/agent-stuff) | Skills and extensions by Armin Ronacher. Includes tmux session control, GitHub CLI, web browser automation, Sentry integration, mermaid diagrams, and more. |
| **Git Stacked PRs** | [github/gh-stack](https://github.com/github/gh-stack) | GitHub CLI extension for managing stacked branches and pull requests. Create, push, rebase, sync, and navigate stacks of dependent PRs for incremental code review workflows. |
| **Facts** | [av/facts](https://github.com/av/facts) | Track project specs and facts in a `.facts` file. Lifecycle stages (`@draft` → `@spec` → `@implemented`) with shell-command verification. Ships four skills: `facts`, `facts-discover`, `facts-refine`, and `facts-implement`. |
| **Modern Web Guidance** | [GoogleChrome/modern-web-guidance](https://github.com/GoogleChrome/modern-web-guidance) | Search tool for modern web development best practices (HTML, CSS, accessibility, and client-side JS APIs). |
| **Plannotator Setup Goal** | [backnotprop/plannotator](https://github.com/backnotprop/plannotator) | Turn ideas into structured goal packages with fact sheets and execution plans, gated by Plannotator annotation |
| **Codex PR Babysitter** | [openai/codex](https://github.com/openai/codex/blob/main/.codex/skills/babysit-pr/SKILL.md) | Continuously monitor open PRs: poll review comments and CI runs, auto-fix branch-related failures, retry flaky checks, and surface fresh review feedback until merged or user help is required |
| **Last 30 Days** | [mvanhorn/last30days-skill](https://github.com/mvanhorn/last30days-skill) | Research what people actually say about any topic in the last 30 days. Pulls from Reddit, X, YouTube, TikTok, HN, Polymarket, GitHub, and the web. |
| **Improve** | [shadcn/improve](https://github.com/shadcn/improve) | Audit any codebase and write implementation plans for cheaper models to execute. Uses expensive model for planning, cheap model for execution. |
| **Engram** | [Gentleman-Programming/engram](https://github.com/Gentleman-Programming/engram) | Persistent agent memory via single Go binary — SQLite + FTS5, 20 MCP tools, zero dependencies, TUI, and git-based cross-machine sync. |
| **mac-OCR** | [privatenumber/mac-ocr](https://github.com/privatenumber/mac-ocr) | macOS CLI for OCR and searchable PDFs using Apple's Vision framework |
**Installation:**
```bash
# Install skills using npx skills add
npx skills add expo/skills --global --agent claude-code
npx skills add vercel-labs/agent-skills --global --agent claude-code
npx skills add factory-ai/factory-plugins --skill no-use-effect --global --agent claude-code
npx skills add blader/humanizer --global --agent claude-code
npx skills add jezweb/claude-skills --global --agent claude-code
npx skills add mattpocock/skills --skill grill-with-docs --global --agent claude-code
npx skills add mattpocock/skills --skill improve-codebase-architecture --global --agent claude-code
npx skills add privatenumber/mac-ocr --skill mac-ocr --global --agent claude-code
npx skills add mitsuhiko/agent-stuff --global --agent claude-code
npx skills add github/gh-stack --global --agent claude-code
npx skills add openclaw/agent-skills --skill autoreview --global --agent claude-code
npx skills add av/facts --global --agent claude-code
npx skills add GoogleChrome/modern-web-guidance --skill modern-web-guidance --global --agent claude-code
npx skills add openai/codex --skill babysit-pr --global --agent claude-code
npx skills add mvanhorn/last30days-skill --global --agent claude-code
npx skills add shadcn/improve --global --agent claude-code
npx skills add Gentleman-Programming/engram --skill engram-memory --global --agent claude-code
npx skills add ctxrs/ctx --global --agent claude-code
```
### Configuration Files
All configuration files are located in the [`configs/claude/`](configs/claude/) directory:
- [`settings.json`](configs/claude/settings.json) - Main Claude Code settings
- [`mcp-servers.json`](configs/claude/mcp-servers.json) - MCP server configurations
- [`commands/`](configs/claude/commands/) - Custom slash commands
- [`agents/`](configs/claude/agents/) - Custom agent definitions
Local marketplace plugins are in [`skills/`](skills/).
#### Tips & Tricks
- **OpusPlan Mode**: Use opusplan mode to plan with Opus and implement with Sonnet, then use Plannotator to review plans
- **Session Management**: Disable auto-compact in settings. Monitor context usage with `claude-hud`. Press `Ctrl+C` to quit or `/clear` to reset between coding sessions. Create a plan with `/handoffs` and resume with `/pickup` when approaching 90% context limit on big tasks.
- **Git Worktree**: Use git worktree with `try` CLI. For tmux users, use `claude-squash` to manage sessions efficiently. Use [superset.sh](https://superset.sh/) to run multiple AI agents in parallel across worktrees
- **Neovim Integration**: Check out [tiny-nvim](https://github.com/jellydn/tiny-nvim) for a complete setup with [sidekick.nvim](https://github.com/folke/sidekick.nvim) or [claudecode.nvim](https://github.com/coder/claudecode.nvim)
- **Cost Optimization**: Use [CCS](https://ccs.kaitran.ca/) to switch between affordable providers.
- **OpenRouter Provider**: To route Claude Code through OpenRouter instead of Anthropic directly, add these to `~/.claude/settings.json` under `"env"`:
```json
{
"env": {
"ANTHROPIC_BASE_URL": "https://openrouter.ai/api",
"ANTHROPIC_API_KEY": "your-openrouter-api-key",
"ANTHROPIC_DEFAULT_OPUS_MODEL": "openrouter/owl-alpha",
"ANTHROPIC_DEFAULT_SONNET_MODEL": "openrouter/owl-alpha",
"ANTHROPIC_DEFAULT_HAIKU_MODEL": "openrouter/owl-alpha"
}
}
```
This repo's `configs/claude/settings.json` intentionally does **not** hardcode provider credentials, so you can choose your preferred provider via environment variables. See [OpenRouter free models](https://openrouter.ai/collections/free-models) for no-cost options.
---
## 🎨 OpenCode (Optional)
OpenAI-powered AI coding assistant. [Homepage](https://opencode.ai)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
curl -fsSL https://opencode.ai/install | bash
```
### Configuration
Copy [`configs/opencode/opencode.json`](configs/opencode/opencode.json) to `~/.config/opencode/`:
```json
{
"$schema": "https://opencode.ai/config.json",
"instructions": ["~/.ai-tools/best-practices.md", "~/.ai-tools/MEMORY.md"],
"theme": "kanagawa",
"default_agent": "plan",
"mcp": {
"context7": {
"type": "remote",
"url": "https://mcp.context7.com/mcp",
"enabled": true
},
"qmd": {
"type": "local",
"command": ["qmd", "mcp"],
"enabled": true
},
"fff": {
"type": "local",
"command": ["fff-mcp"],
"enabled": true
},
"sequential-thinking": {
"type": "local",
"command": [
"npx",
"-y",
"@modelcontextprotocol/server-sequential-thinking"
],
"enabled": true
},
"react-grab-mcp": {
"type": "local",
"command": ["npx", "-y", "@react-grab/mcp", "--stdio"],
"enabled": true
},
"logpilot": {
"type": "local",
"command": ["logpilot", "mcp-server"],
"enabled": true
},
"agentmemory": {
"type": "local",
"command": ["npx", "-y", "@agentmemory/mcp"],
"enabled": true
}
},
"agent": {
"build": {
"permission": {
"bash": {
"git push": "ask",
"qmd": "allow",
"qmd query": "allow",
"qmd get": "allow",
"qmd search": "allow",
"$HOME/.config/opencode/skill/qmd-knowledge/scripts/record.sh": "allow",
"$HOME/.claude/skills/qmd-knowledge/scripts/record.sh": "allow"
}
}
}
},
"plugin": [
"@plannotator/opencode@latest",
"opencode-chrome-annotation@latest"
],
"formatter": {
"biome": {
"command": ["biome", "check", "--write", "$FILE"],
"extensions": [".ts", ".tsx", ".js", ".jsx"]
},
"gofmt": {
"command": ["gofmt", "-w", "$FILE"],
"extensions": [".go"]
},
"prettier": {
"command": ["npx", "prettier", "--write", "$FILE"],
"extensions": [".md", ".mdx"]
},
"ruff": {
"command": ["ruff", "format", "$FILE"],
"extensions": [".py"]
},
"rustfmt": {
"command": ["rustfmt", "$FILE"],
"extensions": [".rs"]
},
"shfmt": {
"command": ["shfmt", "-w", "$FILE"],
"extensions": [".sh"]
},
"stylua": {
"command": ["stylua", "$FILE"],
"extensions": [".lua"]
}
}
}
```
**Formatters**: OpenCode automatically formats code after edits using:
- **biome** for TypeScript/JavaScript files (`.ts`, `.tsx`, `.js`, `.jsx`)
- **gofmt** for Go files (`.go`)
- **prettier** for Markdown files (`.md`, `.mdx`)
- **ruff** for Python files (`.py`)
- **rustfmt** for Rust files (`.rs`)
- **shfmt** for shell scripts (`.sh`)
- **stylua** for Lua files (`.lua`)
Similar to Claude Code's PostToolUse hooks, formatters run automatically after write/edit operations.
### Plugins
OpenCode supports community plugins that enhance functionality:
- **[@plannotator/opencode](https://github.com/backnotprop/plannotator)** - Interactive code planning and annotation
- **[opencode-chrome-annotation](https://www.npmjs.com/package/opencode-chrome-annotation)** - Chrome-based annotation for plan reviews
Plugins are automatically installed on next OpenCode launch.
### Custom Agents
Located in [`configs/opencode/agent/`](configs/opencode/agent/):
- `ai-slop-remover` - Remove AI-generated boilerplate
- `docs-update` - Automated documentation synchronization with code changes
- `docs-writer` - Generate documentation
- `review` - Code review
- `security-audit` - Security auditing
### Custom Providers
OpenCode supports custom model providers via OpenAI-compatible endpoints:
| Provider | Models | Endpoint |
| --------- | ----------------------------------- | ----------------------------------------------- |
| cursorapi | `composer-2.5`, `composer-2.5-fast` | `http://127.0.0.1:8788/v1` (local Cursor proxy) |
| llama.cpp | GLM-4.7-Flash (local inference) | `http://192.168.1.11:8000/v1` |
| ollama | minimax-m2.5:cloud | `http://127.0.0.1:11434/v1` |
These are configured in `opencode.json` under the `provider` key with custom model limits.
### Custom Commands
Located in [`configs/opencode/command/`](configs/opencode/command/):
- `simplify` - Simplify over-engineered code for clarity and maintainability
- `batch` - Run multiple tasks in parallel as worker tasks
</details>
---
## 🚀 Command Code (Optional)
AI coding assistant that continuously learns your taste of writing code. [Homepage](https://commandcode.ai)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### 📋 Installation
```bash
npm install -g command-code
```
### 🔧 Configuration
Run the setup script to install configurations to `~/.commandcode/`:
```bash
./cli.sh
```
The setup script automatically configures MCP servers and copies agent guidelines.
### ✨ Key Features
- **Taste Learning** - Learn your code style preferences from repositories
- **MCP Servers** - Extend functionality with Model Context Protocol servers
- **Skills** - Manage agent skills from GitHub repositories
- **Slash Commands** - Built-in commands like `/resume`, `/taste`, `/review`, `/mcp`, etc.
### 🔌 MCP Servers
Configuration in @configs/commandcode/mcp.json:
````json
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp@latest"]
},
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"qmd": {
"command": "qmd",
"args": ["mcp"]
},
"fff": {
"command": "fff-mcp",
"args": []
},
"react-grab-mcp": {
"command": "npx",
"args": ["-y", "@react-grab/mcp", "--stdio"]
},
"logpilot": {
"command": "logpilot",
"args": ["mcp-server"]
},
"agentmemory": {
"command": "npx",
"args": ["-y", "@agentmemory/mcp"]
}
}
}
Located in @configs/commandcode/agents/:
- `ai-slop-remover` - Remove AI-generated boilerplate
- `review` - Code review
### ⌨️ Custom Commands
Located in @configs/commandcode/commands/:
- `simplify` - Simplify over-engineered code
- `pr-review` - Pull request review workflows
### 📖 Agent Guidelines
Installed to `~/.commandcode/AGENTS.md` with instructions for:
- Session management with tmux
- Using fff MCP for file search
- Following best practices from `~/.ai-tools/best-practices.md`
- qmd knowledge management integration
- Git safety guidelines
</details>
---
## 🎯 Amp (Optional)
AI coding assistant by Modular. [Homepage](https://ampcode.com)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
curl -fsSL https://ampcode.com/install.sh | bash
````
### Configuration
Copy [`configs/amp/settings.json`](configs/amp/settings.json) to `~/.config/amp/`:
```json
{
"amp.dangerouslyAllowAll": true,
"amp.experimental.autoHandoff": { "context": 90 },
"amp.mcpServers": {
"context7": {
"url": "https://mcp.context7.com/mcp"
},
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"qmd": {
"command": "qmd",
"args": ["mcp"]
},
"fff": {
"command": "fff-mcp",
"args": []
},
"react-grab-mcp": {
"command": "npx",
"args": ["-y", "@react-grab/mcp", "--stdio"]
},
"logpilot": {
"command": "logpilot",
"args": ["mcp-server"]
},
"agentmemory": {
"command": "npx",
"args": ["-y", "@agentmemory/mcp"]
}
},
"amp.terminal.theme": "kanagawa"
}
```
See [`configs/amp/AGENTS.md`](configs/amp/AGENTS.md) for agent guidelines.
</details>
---
## 🔄 CCS - Claude Code Switch (Optional)
Universal AI profile manager for Claude Code. [Homepage](https://ccs.kaitran.ca) | [Documentation](https://docs.ccs.kaitran.ca)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
npm install -g @kaitranntt/ccs
```
### What It Does
CCS lets you run Claude, Gemini, GLM, and any Anthropic-compatible API - concurrently, without conflicts.
**Three Main Capabilities:**
1. **Multiple Claude Accounts** - Run work + personal Claude subscriptions simultaneously
2. **OAuth Providers** - Gemini, Codex, Antigravity, Qwen, iFLY, Kiro, GitHub Copilot (zero API keys needed)
3. **API Profiles** - GLM, Ollama, or any Anthropic-compatible API
### Quick Start
1. **Open Dashboard**:
```bash
ccs config
# Opens http://localhost:3000
```
2. **Configure Your Accounts** via the visual dashboard:
- Claude Accounts (work, personal, client)
- OAuth Providers (one-click auth)
- API Profiles (configure with your keys)
- Health Monitor (real-time status)
3. **Start Using**:
```bash
ccs # Default Claude session
ccs gemini # Gemini (OAuth)
ccs codex # OpenAI Codex (OAuth)
ccs agy # Antigravity (OAuth)
ccs qwen # Qwen (OAuth)
ccs iflow # iFLY (OAuth)
ccs kiro # Kiro (OAuth)
ccs ghcp # GitHub Copilot (OAuth)
ccs glm # GLM (API key)
ccs ollama # Local Ollama
```
### Configuration
CCS auto-creates config on install (currently version 8). Dashboard is the recommended way to manage settings.
**Config location**: [`~/.ccs/config.yaml`](configs/ccs/config.yaml)
Key features from the current config:
- **CLIProxy OAuth providers**: gemini, codex, agy, qwen, iflow, kiro, ghcp
- **API Profiles**: glm, ollama-cloud (cloud-hosted), ollama (local)
- **WebSearch fallback chain**: Gemini → OpenCode → Grok (automatic fallback for third-party providers)
- **Copilot API proxy**: Optional GitHub Copilot integration via `npx copilot-api auth` (disabled by default)
- **Thinking modes**: auto, off, manual with tier defaults (opus=high, sonnet=medium, haiku=low)
See [`configs/ccs/config.yaml`](configs/ccs/config.yaml) for the full configuration.
**Advanced**: The `websearch` section enables CLI-based web search for third-party profiles that don't have Anthropic's WebSearch tool. Fallback chain tries providers in order until one succeeds.
</details>
---
## 🤖 OpenAI Codex CLI (Optional)
OpenAI's command-line coding assistant. [Homepage](https://developers.openai.com/codex/cli)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
npm install -g @openai/codex
```
### Configuration
Located in [`configs/codex/`](configs/codex/):
- [`config.toml`](configs/codex/config.toml) - Main TOML configuration with MCP servers
- [`AGENTS.md`](configs/codex/AGENTS.md) - Agent guidelines
### MCP Servers
```toml
[mcp_servers.context7]
command = "npx"
args = [ "-y", "@upstash/context7-mcp" ]
[mcp_servers.sequential-thinking]
command = "npx"
args = [ "-y", "@modelcontextprotocol/server-sequential-thinking" ]
[mcp_servers.qmd]
command = "qmd"
args = [ "mcp" ]
[mcp_servers.fff]
command = "fff-mcp"
args = []
[mcp_servers.react-grab-mcp]
command = "npx"
args = [ "-y", "@react-grab/mcp", "--stdio" ]
[mcp_servers.logpilot]
command = "logpilot"
args = ["mcp-server"]
[mcp_servers.node_repl]
args = []
command = "/Applications/Codex.app/Contents/Resources/node_repl"
startup_timeout_sec = 120
[mcp_servers.node_repl.env]
CODEX_HOME = "$HOME/.codex"
NODE_REPL_NODE_PATH = "/Applications/Codex.app/Contents/Resources/node"
```
### Usage
```bash
# Start Codex CLI
codex
# Use with Ollama (local models)
codex --oss
# Use with a specific task
codex "Explain this code"
```
</details>
---
## 🔷 Google Gemini CLI (Deprecated for Google One / unpaid tiers)
> ⚠️ **DEPRECATION NOTICE — June 18, 2026**
> Gemini CLI will **stop serving requests** to Google One and unpaid (free) tiers on **June 18, 2026**.
> API-key-based workflows are **not affected**.
>
> 👉 **Migrate now:** [Antigravity CLI](https://antigravity.google/product/antigravity-cli) | [Migration guide](https://goo.gle/gemini-cli-migration)
> 👉 This repo's Antigravity setup: see the [Antigravity CLI section](#-antigravity-cli-optional) below.
Google's AI agent that brings the power of Gemini directly into your terminal. [Homepage](https://github.com/google-gemini/gemini-cli)
> **Archival note:** This repository still keeps Gemini CLI configs for existing installations, API-key workflows, and migration/export compatibility. The section is maintained for reference but new users should use Antigravity CLI instead.
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
npm install -g @google/gemini-cli
```
Or using Homebrew (macOS/Linux):
```bash
brew install gemini-cli
```
### Authentication
Gemini CLI supports multiple authentication methods:
**Option 1: Login with Google (OAuth)**
```bash
gemini
# Follow the browser authentication flow
```
**Option 2: Gemini API Key**
```bash
export GEMINI_API_KEY="YOUR_API_KEY"
gemini
```
Get your API key from [Google AI Studio](https://aistudio.google.com/apikey).
### Configuration
Located in [`configs/gemini/`](configs/gemini/):
- [`settings.json`](configs/gemini/settings.json) - Main configuration with MCP servers and experimental features
- [`GEMINI.md`](configs/gemini/GEMINI.md) - Agent guidelines
- [`AGENTS.md`](configs/gemini/AGENTS.md) - Additional agent guidelines
- [`agents/`](configs/gemini/agents/) - Custom agent definitions (`.md` format with YAML frontmatter)
- `ai-slop-remover.md` - Clean up AI-generated code patterns
- `docs-writer.md` - Generate comprehensive documentation
- `review.md` - Code review with best practices
- `security-audit.md` - Security vulnerability assessment
- [`commands/`](configs/gemini/commands/) - Custom slash commands (`.toml` format)
- `ultrathink.toml` - Deep thinking mode
### Key Features
- 🆓 **Free tier**: 60 requests/min and 1,000 requests/day with personal Google account
- 🧠 **Powerful models**: Access to Gemini 2.5 Flash and Pro with 1M token context window
- 🔧 **Built-in tools**: Google Search grounding, file operations, shell commands
- 🔌 **MCP support**: Extensible via Model Context Protocol
- 💻 **Terminal-first**: Designed for command-line developers
### Usage
```bash
# Start Gemini CLI
gemini
# Include multiple directories
gemini --include-directories ../lib,../docs
# Use specific model
gemini -m gemini-2.5-flash
# Non-interactive mode for scripts
gemini -p "Explain the architecture of this codebase"
```
### Custom Commands
Custom commands are stored in `~/.gemini/commands/` as TOML files. Example:
```bash
# Run the ultrathink command
/ultrathink What is the best approach to optimize this database query?
```
### MCP Servers
Configure MCP servers in `~/.gemini/settings.json` to extend functionality:
```json
{
"mcpServers": {
"context7": {
"url": "https://mcp.context7.com/mcp"
},
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"qmd": {
"command": "qmd",
"args": ["mcp"]
},
"fff": {
"command": "fff-mcp",
"args": []
},
"react-grab-mcp": {
"command": "npx",
"args": ["-y", "@react-grab/mcp", "--stdio"]
},
"logpilot": {
"command": "logpilot",
"args": ["mcp-server"]
},
"agentmemory": {
"command": "npx",
"args": ["-y", "@agentmemory/mcp"]
}
},
"experimental": {
"enableAgents": true
}
}
```
> **Note:** Custom agents in `~/.gemini/agents/` are automatically discovered when `experimental.enableAgents` is set to `true`.
</details>
---
## 🛸 Antigravity CLI (Optional)
Google's Antigravity CLI for terminal-first agent workflows. This repository installs Antigravity as a first-class tool and stages migrated Gemini CLI configuration under `~/.gemini/antigravity-cli/`. Antigravity is the migration target for Google One and unpaid-tier Gemini CLI users.
<details>
<summary><strong>Installation, Migration & Configuration</strong></summary>
### Installation
```bash
# Mac/Linux
curl -fsSL https://antigravity.google/cli/install.sh | bash
# Windows PowerShell
irm https://antigravity.google/cli/install.ps1 | iex
```
Or run this repo's installer:
```bash
./cli.sh
```
### Gemini CLI / gcli Migration
Antigravity CLI stores its config in `~/.gemini/antigravity-cli/` and can import existing Gemini CLI extensions as Antigravity plugins:
```bash
agy plugin import gemini
```
This repository also ships a source-controlled migrated plugin at `configs/antigravity-cli/plugins/my-ai-tools-gemini-migration/` with:
- Gemini MCP servers converted to Antigravity `mcp_config.json`
- Gemini agents staged as Antigravity plugin agents
- Gemini `AGENTS.md` and `GEMINI.md` staged as plugin rules
Global Gemini skills in `~/.gemini/skills/` are shared with Antigravity CLI, so no separate skill copy is required.
### Usage
- [https://antigravity.google/docs/cli-using](https://antigravity.google/docs/cli-using)
- [https://antigravity.google/docs/cli-features](https://antigravity.google/docs/cli-features)
- [https://antigravity.google/docs/gcli-migration](https://antigravity.google/docs/gcli-migration)
```bash
# Start Antigravity CLI
agy
# Manage plugins, MCP, skills, and settings from inside the TUI
/mcp
/skills
/config
```
### Configuration Files
- `~/.gemini/antigravity-cli/settings.json` - CLI settings, sandbox, permissions
- `~/.gemini/antigravity-cli/keybindings.json` - optional keybindings
- `~/.gemini/antigravity-cli/plugins/<plugin_name>/` - plugins with `plugin.json`, `mcp_config.json`, agents, skills, hooks, and rules
If you already use CCS in this repository, you can launch the Antigravity profile directly:
```bash
ccs agy
```
</details>
---
## 🎯 Kilo CLI (Optional)
AI coding assistant built on top of OpenCode with powerful productivity features. [Homepage](https://kilo.ai)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
npm install -g @kilocode/cli
```
Kilo provides both `kilo` and `kilocode` commands.
### Configuration
Kilo CLI uses its own configuration directory at `~/.config/kilo/`:
- [`config.json`](configs/kilo/config.json) - Main configuration with permissions and settings
Configuration is managed through:
1. `/connect` command for provider setup (interactive)
2. Config files directly at `~/.config/kilo/config.json`
3. `kilo auth` for credential management
### MCP Servers
Kilo delegates to OpenCode's MCP configuration. See [OpenCode MCP Servers](#mcp-servers-1) for the full list (context7, sequential-thinking, qmd, fff, react-grab-mcp, logpilot, agentmemory).
### Key Features
- 🚀 **Built on OpenCode**: Full compatibility with OpenCode configuration and plugins
- 🤖 **300+ AI Models**: Access to Claude, GPT, Gemini, DeepSeek, Llama, and more
- 🥔 **Giga Potato Model**: Free stealth model optimized for agentic programming with vision support
- 🔌 **Plugin ecosystem**: Compatible with OpenCode plugins
- 📝 **Custom agents**: Same agent system as OpenCode
- 🎨 **Terminal UI**: Enhanced terminal interface for productivity
### Usage
```bash
# Start Kilo CLI
kilo
# Or use the kilocode alias
kilocode
# Use with specific model
kilo --model kilo/giga-potato
# Non-interactive mode
kilo run "Refactor this component to use hooks"
```
</details>
---
## 🌙 Kimi Code (Optional)
Moonshot AI's terminal-native coding agent. [Homepage](https://www.kimi.com/code/en)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash
```
### Configuration
Kimi Code stores user-level configs in `~/.kimi-code/`:
- [`AGENTS.md`](configs/kimi-code/AGENTS.md) - Global Kimi-specific instructions
- [`config.toml`](configs/kimi-code/config.toml) - Runtime settings (models, permissions, loop control)
- [`mcp.json`](configs/kimi-code/mcp.json) - User-level MCP server declarations
### Usage
```bash
# Start Kimi Code
kimi
```
</details>
---
## 🥧 Pi (Optional)
AI coding agent built for agentic coding workflows. [Homepage](https://pi.dev)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
curl -fsSL https://pi.dev/install.sh | sh
```
### Configuration
Pi uses `~/.pi/agent/settings.json` for global user settings and `.pi/settings.json` in project roots for project-level configuration.
Located in [`configs/pi/`](configs/pi/):
- [`settings.json`](configs/pi/settings.json) - Global settings with package registrations
- [`models.json`](configs/pi/models.json) - Provider and model definitions (google-antigravity, ollama)
Installer copies the repo-managed files `configs/pi/settings.json` and `configs/pi/models.json` to `~/.pi/agent/settings.json` and `~/.pi/agent/models.json` respectively. The default settings configure `clinepass` as the default provider with `deepseek-v4-flash` as the default model. You can inspect or edit them at `~/.pi/agent/settings.json` after installation.
**Key Settings:**
- **Default Model**: `deepseek-v4-flash`
- **Default Provider**: `clinepass`
- **Default Thinking Level**: `high`
- **Theme**: `kanagawa`
- **Permission Level**: `high`
- **Quiet Startup**: Enabled (skips changelog on launch)
- **Hide Thinking Block**: Enabled (hides thinking process)
### Pi Packages
Pi uses a package-based extension system (not MCP). Install packages with:
```bash
pi install pi-flow-enforcer
pi install pi-agent-pack
```
Then register them in `~/.pi/agent/settings.json`:
```json
{
"packages": [
{
"source": "npm:@plannotator/pi-extension",
"skills": []
},
"https://github.com/davebcn87/pi-autoresearch",
"npm:@ff-labs/pi-fff",
"npm:pi-mcp-adapter",
"npm:pi-simplify",
"npm:pi-manage-todo-list",
"npm:pi-btw",
"npm:pi-code-previews",
"npm:pi-codex-goal",
"npm:pi-dynamic-workflows",
"npm:pi-commandcode-provider",
"npm:pi-footer",
"npm:pi-tps-meter",
"npm:@juicesharp/rpiv-advisor",
"npm:pi-cursor-sdk",
"npm:pi-web-access",
"npm:pi-clinepass-provider",
"npm:@juicesharp/rpiv-ask-user-question",
"npm:@yofriadi/pi-antigravity-oauth"
]
}
```
**Package Overview:**
| Package | Description |
| ------------------------------------ | ------------------------------------------------------------------ |
| `@plannotator/pi-extension` | Interactive plan review with visual annotation |
| `pi-autoresearch` | Autonomous experiment loop for optimization targets |
| `@ff-labs/pi-fff` | FFF-powered fuzzy file and content search |
| `pi-mcp-adapter` | MCP (Model Context Protocol) adapter for Pi |
| `pi-simplify` | Reviews changed code for clarity, consistency, and maintainability |
| `pi-manage-todo-list` | GitHub Copilot-style todo list management tool |
| `pi-btw` | Parallel side conversations with `/btw` command |
| `pi-code-previews` | Live previews of code changes during editing |
| `pi-codex-goal` | Codex-style goal management integration |
| `pi-dynamic-workflows` | Dynamic workflow automation for Pi |
| `pi-commandcode-provider` | CommandCode model provider integration for Pi |
| `pi-web-access` | Web access and content fetching for AI models |
| `pi-footer` | Customizable status footer for the Pi TUI |
| `pi-tps-meter` | Live tokens-per-second meter for the Pi TUI status bar |
| `@juicesharp/rpiv-advisor` | Second opinion from a stronger reviewer model before taking action |
| `pi-cursor-sdk` | Pi provider extension backed by @cursor/sdk local agents |
| `pi-clinepass-provider` | ClinePass model provider for Pi |
| `@juicesharp/rpiv-ask-user-question` | Structured question-asking tool for user clarification |
| `@yofriadi/pi-antigravity-oauth` | Antigravity OAuth authentication for Pi; see the caveat below |
> **Antigravity OAuth caveat:** If you're experimenting with Pi, there's an OAuth plugin available for Antigravity. Be aware that Google currently states that using third-party software with Antigravity OAuth may violate its Terms of Service and could result in account restrictions. For the lowest-risk setup, prefer an official API key from AI Studio or Vertex AI when Pi supports it, and avoid OAuth plugins that reuse an Antigravity login in third-party clients unless Google changes its policy.
### Enabled Models
Pi is configured with multi-provider model access (`settings.json` `enabledModels`):
| Provider | Models |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
| cursor | `auto`, `composer-2.5` |
| openai-codex | `gpt-5.4`, `gpt-5.4-mini`, `gpt-5.3-codex-spark`, `gpt-5.5` |
| clinepass | `deepseek-v4-pro`, `deepseek-v4-flash`, `kimi-k2.7-code`, `glm-5.2`, `kimi-k2.6`, `minimax-m3`, `qwen3.7-max`, `qwen3.7-plus` |
| google-antigravity | `gemini-3.5-flash`, `gemini-3-pro`, `claude-opus-4-6` |
| commandcode | `deepseek/deepseek-v4-pro` |
### Pi Antigravity Rotator
For multi-account rotation, local model routing, and quota management across Google Antigravity accounts, [pi-antigravity-rotator](https://github.com/tuxevil/pi-antigravity-rotator) is available, but it may carry the same Antigravity OAuth third-party access risk described above.
It runs as a local proxy on port `51200` and supports per-model routing, real-time quota tracking, and automatic token management.
```bash
npm install -g pi-antigravity-rotator
pi-antigravity-rotator login
pi-antigravity-rotator start
```
Once running, Pi connects automatically via the configured provider (`google-antigravity`) in [`configs/pi/models.json`](configs/pi/models.json).
### Usage
```bash
# Start Pi
pi
# Run a task non-interactively
pi "Refactor this function to be more readable"
```
</details>
---
## 🐙 GitHub Copilot CLI (Optional)
GitHub Copilot in the terminal — agentic coding assistant that brings AI capabilities directly to your command line. [Best Practices](https://docs.github.com/en/copilot/how-tos/copilot-cli/cli-best-practices) | [Docs](https://docs.github.com/en/copilot/using-github-copilot/using-github-copilot-in-the-command-line)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Prerequisites
Requires an active GitHub Copilot subscription and Node.js/npm.
### Installation
```bash
npm install -g @github/copilot
```
### Configuration
Copilot CLI configs are stored in [`configs/copilot/`](configs/copilot/) and installed to the official global paths under `~/.copilot/`.
- [`AGENTS.md`](configs/copilot/AGENTS.md) - Agent guidelines and best practices, installed to `~/.copilot/copilot-instructions.md`
- [`mcp-config.json`](configs/copilot/mcp-config.json) - MCP server configuration, installed to `~/.copilot/mcp-config.json`
### MCP Servers
```json
{
"mcpServers": {
"context7": {
"type": "local",
"command": "npx",
"args": ["-y", "@upstash/context7-mcp@latest"]
},
"sequential-thinking": {
"type": "local",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"fff": {
"type": "local",
"command": "fff-mcp",
"args": []
},
"qmd": {
"type": "local",
"command": "qmd",
"args": ["mcp"]
},
"react-grab-mcp": {
"type": "local",
"command": "npx",
"args": ["-y", "@react-grab/mcp", "--stdio"],
"env": {},
"tools": ["*"]
},
"logpilot": {
"type": "local",
"command": "logpilot",
"args": ["mcp-server"]
},
"agentmemory": {
"type": "local",
"command": "npx",
"args": ["-y", "@agentmemory/mcp"]
}
}
}
```
### Usage
```bash
# Start a Copilot CLI session
copilot
# Use plan mode for complex tasks (or press Shift+Tab to toggle)
/plan Add OAuth2 authentication with Google and GitHub providers
# Delegate tangential tasks to the cloud agent
/delegate Update documentation for the new API endpoints
# Select model based on task complexity
/model
# Work across multiple repositories
/add-dir /path/to/other-repo
```
</details>
---
## 🖱️ Cursor Agent CLI (Optional)
Cursor's background agent CLI — run AI-powered coding tasks directly from your terminal. [Docs](https://cursor.com/docs/cli/using)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Prerequisites
Requires the [Cursor](https://cursor.com) desktop application to be installed.
### Installation
The `cursor` CLI is bundled with the Cursor desktop app. After installing Cursor, add it to your PATH via the Command Palette:
```
Shell Command: Install 'cursor' command in PATH
```
### Configuration
Cursor Agent CLI configs are stored in [`configs/cursor/`](configs/cursor/) and installed to the official paths under `~/.cursor/`.
- [`AGENTS.md`](configs/cursor/AGENTS.md) - Agent guidelines and best practices, installed to `~/.cursor/rules/general.mdc`
- [`agents/`](configs/cursor/agents/) - Custom agents, installed to `~/.cursor/agents/`
### 📋 MCP Servers
Cursor supports MCP servers via `@~/.cursor/mcp.json`:
```json
{
"mcpServers": {
"context7": {
"command": "bunx",
"args": ["-y", "@upstash/context7-mcp@latest"]
},
"fff": {
"command": "fff-mcp",
"args": []
},
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"qmd": {
"command": "qmd",
"args": ["mcp"]
},
"react-grab-mcp": {
"command": "npx",
"args": ["-y", "@react-grab/mcp", "--stdio"]
},
"logpilot": {
"command": "logpilot",
"args": ["mcp-server"]
},
"agentmemory": {
"command": "npx",
"args": ["-y", "@agentmemory/mcp"]
}
}
}
```
### Custom Commands
Located in [`configs/cursor/commands/`](configs/cursor/commands/):
- `deslop` - Remove AI-generated boilerplate and improve code quality
### Custom Agents
Located in [`configs/cursor/agents/`](configs/cursor/agents/):
- `thermo-nuclear-code-quality-review` - Run a strict maintainability and structural quality audit
### Usage
```bash
# Open a project in Cursor
cursor .
# Open a specific file
cursor /path/to/file
# Check the CLI version
cursor --version
```
</details>
---
## ⚡ Conductor (Optional)
Orchestrate parallel AI coding agents (Claude Code, Codex, Cursor, OpenCode) in isolated workspaces. [Docs](https://www.conductor.build/docs)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Prerequisites
- macOS (Conductor is a macOS desktop app)
- GitHub authentication via `gh auth status`
- At least one agent provider (Claude Code, Codex, or Cursor API key)
### Installation
Download Conductor from [conductor.build](https://www.conductor.build) or use Homebrew:
```bash
brew install conductorbuild/tap/conductor
```
### Configuration
Conductor configs are stored in [`configs/conductor/`](configs/conductor/) and installed to `~/.conductor/`.
- [`settings.toml`](configs/conductor/settings.toml) — User-level settings (model defaults, git behavior, harness config)
- [`AGENTS.md`](configs/conductor/AGENTS.md) — Agent guidelines and best practices
Project-level settings go in `.conductor/settings.toml` at the repository root:
```toml
"$schema" = "https://conductor.build/schemas/settings.repo.schema.json"
[scripts]
setup = "prek install"
```
**User-level settings** in `~/.conductor/settings.toml`:
```toml
"$schema" = "https://conductor.build/schemas/settings.schema.json"
claude_provider = "custom"
enterprise_data_privacy = true
[git]
archive_on_merge = true
branch_prefix_type = "github_username"
delete_branch_on_archive = false
[models]
default = "opencode:opencode/deepseek-v4-flash-free"
default_plan_mode = true
review = "gpt-5.5"
visible_provider_models = "{\"claude\":[],\"codex\":[],\"cursor\":[],\"opencode\":[\"opencode:deepseek/deepseek-v4-flash\",\"opencode:deepseek/deepseek-v4-pro\",\"opencode:google/gemini-3.5-flash\",\"opencode:opencode/deepseek-v4-flash-free\"],\"pi\":[]}"
[models.codex]
default_thinking_level = "high"
personality = "pragmatic"
review_thinking_level = "xhigh"
```
### 📋 MCP Servers
Conductor does not define its own MCP config format. MCP servers are configured per harness:
- **Claude Code**: `~/.claude.json` or `.mcp.json` at repo root
- **Codex**: `~/.codex/config.toml` or `codex mcp add`
- **Cursor**: `~/.cursor/mcp.json` or `.cursor/mcp.json` at repo root
When you open a Conductor workspace in Cursor, Cursor reads project-level MCP config from that workspace checkout.
### Usage
```bash
# Open Conductor app
open -a Conductor
# Create a new workspace with a task
conductor start "Implement user authentication"
# List active workspaces
conductor list
# Open workspace in Cursor
conductor open --cursor
```
</details>
---
## 🏭 Factory Droid (Optional)
Factory's AI coding agent — end-to-end feature development from your terminal. [Homepage](https://factory.ai) | [Docs](https://docs.factory.ai/cli/getting-started/quickstart)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
npm install -g @factory/cli
```
After installation, navigate to your project and start the droid CLI:
```bash
cd /path/to/your/project
droid
```
### BYOK Setup (Bring Your Own Key)
Factory Droid supports using your own AI provider API keys. See the [BYOK documentation](https://docs.factory.ai/cli/byok/overview) for supported providers and configuration.
Set your API key via environment variable:
```bash
export FACTORY_API_KEY=your_api_key_here
```
Or use the interactive login:
```bash
droid /login
```
### Configuration
Factory Droid configs are stored in `configs/factory/` and installed to `~/.factory/`:
- [`AGENTS.md`](configs/factory/AGENTS.md) - Global agent guidelines
- [`mcp.json`](configs/factory/mcp.json) - MCP server configurations
- [`settings.json`](configs/factory/settings.json) - Factory Droid settings
- [`config.json`](configs/factory/config.json) - Custom model definitions
- `droids/` - Optional user-created directory for custom droid definitions
### Plugins
Factory Droid includes plugins that enhance functionality:
| Plugin | Description |
| ----------------------------------- | -------------------------------------------------- |
| `core@factory-plugins` | Core Factory functionality |
| `security-engineer@factory-plugins` | Security-focused code review engine |
| `droid-evolved@factory-plugins` | Advanced droid capabilities with improved autonomy |
| `autoresearch@factory-plugins` | Autonomous research and experiment loop |
### Custom Models
Factory Droid supports custom models via any OpenAI-compatible endpoint:
```json
{
"customModels": [
{
"model": "minimax-m2.5:cloud",
"id": "custom:minimax-m2.5:cloud-0",
"baseUrl": "http://127.0.0.1:11434/v1",
"apiKey": "ollama",
"displayName": "minimax-m2.5:cloud",
"maxOutputTokens": 128000,
"provider": "generic-chat-completion-api"
},
{
"model": "glm-4.7",
"id": "custom:GLM-4.7-[Z.AI-Coding-Plan]-0",
"baseUrl": "https://api.z.ai/api/coding/paas/v4",
"displayName": "GLM-4.7 [Z.AI Coding Plan]",
"maxOutputTokens": 131072,
"provider": "generic-chat-completion-api"
}
]
}
```
### MCP Servers
```json
{
"mcpServers": {
"context7": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@upstash/context7-mcp@latest"]
},
"sequential-thinking": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"fff": {
"type": "stdio",
"command": "fff-mcp",
"args": []
},
"qmd": {
"type": "stdio",
"command": "qmd",
"args": ["mcp"]
},
"react-grab-mcp": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@react-grab/mcp", "--stdio"]
},
"logpilot": {
"type": "stdio",
"command": "logpilot",
"args": ["mcp-server"]
},
"agentmemory": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@agentmemory/mcp"]
}
}
}
```
### Usage
```bash
# Start interactive mode
droid
# Start with an initial prompt
droid "review app.tsx"
# Run non-interactively
droid exec "analyze this file"
# Resume last session
droid --resume
# Check for updates
droid update
```
</details>
---
## 💻 Cline (Optional)
AI coding assistant that runs in your terminal — built for high-performance agentic coding with support for multiple providers. [Homepage](https://cline.bot) | [Docs](https://docs.cline.bot)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
npm install -g cline
```
### Authentication
Cline supports multiple authentication methods:
**Option 1: OAuth (Cline Account)**
```bash
cline
# Follow the browser authentication flow
```
**Option 2: API Keys**
Configure API keys via the Cline dashboard or set environment variables:
```bash
export FIREWORKS_API_KEY="your_key_here"
export OPENAI_API_KEY="your_key_here"
```
### Configuration
Cline configs are stored in `configs/cline/` and installed to `~/.cline/`:
- [`AGENTS.md`](configs/cline/AGENTS.md) - Global agent guidelines (tmux, AI tool usage, best practices), installed to `~/.cline/rules/01-guidelines.md` and the cross-tool `~/.agents/AGENTS.md` (Cline reads both via its rules search paths)
- [`mcp-settings.json`](configs/cline/mcp-settings.json) - MCP server configurations, installed to `~/.cline/data/settings/cline_mcp_settings.json`
- [`models.json`](configs/cline/models.json) - Model configurations
- [`providers.json`](configs/cline/providers.json.example) - Provider credentials (copy from example and fill in your keys)
- [`kanban-config.json`](configs/cline/kanban-config.json) - Kanban board settings
Skills are shared via the universal `~/.agents/skills/` directory, which Cline searches natively. `~/.cline/skills` is symlinked to it for consistency with the other tools.
### MCP Servers
```json
{
"mcpServers": {
"context7": {
"alwaysAllow": [],
"url": "https://mcp.context7.com/mcp"
},
"sequential-thinking": {
"alwaysAllow": [],
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"qmd": {
"alwaysAllow": [],
"command": "qmd",
"args": ["mcp"]
},
"fff": {
"alwaysAllow": [],
"command": "fff-mcp",
"args": []
},
"react-grab-mcp": {
"alwaysAllow": [],
"command": "npx",
"args": ["-y", "@react-grab/mcp", "--stdio"]
},
"logpilot": {
"alwaysAllow": [],
"command": "logpilot",
"args": ["mcp-server"]
},
"agentmemory": {
"alwaysAllow": [],
"command": "npx",
"args": ["-y", "@agentmemory/mcp"]
}
}
}
```
### Usage
```bash
# Start Cline interactive mode
cline
# Run a specific task
cline "Refactor this component to use TypeScript"
# Use with specific model
cline --model accounts/fireworks/routers/kimi-k2p5-turbo
# List available commands
cline --help
```
### Skills
Cline uses the universal skills directory at `~/.agents/skills/`. The installer automatically manages skills from the [`skills/`](skills/) folder.
</details>
---
## 🤖 Grok CLI (Optional)
xAI's AI coding assistant for the terminal. [Homepage](https://x.ai/cli) | [Docs](https://docs.x.ai/build/overview)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### 📋 Installation
```bash
npm install -g @xai-official/grok
```
Alternatively, use the curl installer:
```bash
curl -fsSL https://x.ai/cli/install.sh | bash
```
### 🔧 Configuration
Run the setup script to install configurations to `~/.grok/`:
```bash
./cli.sh
```
The setup script automatically deploys MCP servers and agent guidelines.
### ✨ Key Features
- **Claude Code / AGENTS.md compatible** — Grok respects the same `AGENTS.md` format used by Claude Code
- **Universal skills** — Compatible with Claude Code AGENTS.md skills and `~/.agents/` conventions
- **MCP Servers** — Extend functionality via Model Context Protocol using config.toml
- **Headless scripting** — Run Grok non-interactively for CI/CD and automation pipelines
- **Modes** — Multiple interaction modes via modes and commands system
### 🔌 MCP Servers
Configuration in `configs/grok/config.toml`:
```toml
[mcp_servers.context7]
command = "npx"
args = ["-y", "@upstash/context7-mcp"]
[mcp_servers.sequential-thinking]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-sequential-thinking"]
[mcp_servers.qmd]
command = "qmd"
args = ["mcp"]
[mcp_servers.fff]
command = "fff-mcp"
args = []
[mcp_servers.react-grab-mcp]
command = "npx"
args = ["-y", "@react-grab/mcp", "--stdio"]
[mcp_servers.logpilot]
command = "logpilot"
args = ["mcp-server"]
[mcp_servers.agentmemory]
command = "npx"
args = ["-y", "@agentmemory/mcp"]
[ui]
theme = "auto"
auto_dark_theme = "tokyonight"
auto_light_theme = "grokday"
```
### 🎨 Theme (Kanagawa)
Grok Build 0.2.22 ships five built-in dark themes (`groknight`, `tokyonight`, `rosepine-moon`, `oscura-midnight`, plus `grokday` for light). It does not include Kanagawa yet.
This repo stages the **Kanagawa Wave** palette under [`configs/grok/themes/`](configs/grok/themes/) (`kanagawa.toml` + `kanagawa.tmTheme`, shared with Codex/Pi). `cli.sh` installs them to `~/.grok/themes/`.
Until Grok adds a `kanagawa` built-in (or loads custom theme files), `[ui]` uses `theme = "auto"` with `auto_dark_theme = "tokyonight"` — the closest Japanese-inspired built-in. Switch themes in the TUI with `/theme` or set `theme = "tokyonight"` directly in `config.toml`.
### 📖 Agent Guidelines
Installed to `~/.grok/AGENTS.md` with instructions for:
- Session management with tmux
- Using fff MCP for file search
- Following best practices from `~/.ai-tools/best-practices.md`
- qmd knowledge management integration
- Git safety guidelines
### Usage
```bash
# Start Grok CLI
grok
# Run non-interactively (headless mode)
grok -p "Analyze the test coverage for this project"
# Use with a specific task
grok "Explain the architecture of this codebase"
```
</details>
---
## 🏮 MiMo-Code (Optional)
Xiaomi's open-source, terminal-native AI coding assistant with persistent memory, agentic orchestration, and self-improvement capabilities. Forked from OpenCode. [Homepage](https://mimo.xiaomi.com) | [GitHub](https://github.com/XiaomiMiMo/MiMo-Code)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### 📋 Installation
```bash
npm install -g @mimo-ai/cli
```
Alternatively, use the curl installer:
```bash
curl -fsSL https://mimo.xiaomi.com/install | bash
```
### 🔧 Configuration
Run the setup script to install configurations to `~/.config/mimocode/`:
```bash
./cli.sh
```
The setup script automatically deploys config files, commands, and agent guidelines.
### ✨ Key Features
- **Persistent Cross-Session Memory** — SQLite-powered system that maintains project understanding across sessions (saves `MEMORY.md`, checkpoints, task history)
- **Intelligent Context Management** — Auto-creates checkpoints, ranks and injects relevant past knowledge when resuming
- **Agentic Orchestration** — Multiple agents (`build`, `plan`, `compose`) with on-demand subagents
- **Goal Tracking** — `/goal` command with independent judge model to verify completion
- **Self-Improvement** — `/dream` extracts knowledge from session traces; `/distill` packages workflows into reusable skills
- **Voice Input** — Real-time voice commands via TenVAD and MiMo ASR
- **OpenCode Compatible** — Inherits OpenCode's architecture; uses the same config schema, MCP servers, formatters, and plugin system
### 🔌 MCP Servers
Configuration in [`configs/mimo/mimocode.jsonc`](configs/mimo/mimocode.jsonc):
```jsonc
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"context7": {
"enabled": true,
"type": "remote",
"url": "https://mcp.context7.com/mcp",
},
"qmd": {
"command": ["qmd", "mcp"],
"enabled": true,
"type": "local",
},
"fff": {
"type": "local",
"command": ["fff-mcp"],
"enabled": true,
},
"sequential-thinking": {
"type": "local",
"command": [
"npx",
"-y",
"@modelcontextprotocol/server-sequential-thinking",
],
"enabled": true,
},
"react-grab-mcp": {
"type": "local",
"command": ["npx", "-y", "@react-grab/mcp", "--stdio"],
"enabled": true,
},
"logpilot": {
"type": "local",
"command": ["logpilot", "mcp-server"],
"enabled": true,
},
"agentmemory": {
"type": "local",
"command": ["npx", "-y", "@agentmemory/mcp"],
"enabled": true,
},
},
}
```
### 🎨 Theme
MiMo-Code uses the **Kanagawa** theme by default (no custom theme file shipped).
### ⌨️ Custom Commands
Located in [`configs/mimo/command/`](configs/mimo/command/):
- `rmslop` - Remove AI-generated boilerplate and redundant code
### 📖 Agent Guidelines
Installed to `~/.config/mimocode/AGENTS.md` with instructions for:
- Session management with tmux
- Using fff MCP for file search
- Following best practices from `~/.ai-tools/best-practices.md`
- qmd knowledge management integration
- Git safety guidelines
### Usage
```bash
# Start MiMo-Code
mimo
# Run non-interactively
mimo -p "Analyze the test coverage for this project"
# Use with a specific task
mimo "Explain the architecture of this codebase"
```
### 🚀 MiMo Open Platform — Xiaomi's Most Powerful AI
Invite builders to try the **MiMo Open Platform** — Xiaomi's most powerful AI lineup including **MiMo V2.5** and more. Sign up with the invite code below: both you and your friend get **$2 in API credits** plus **10% off your first plan**.
| Offer | Details |
| ------------------------------ | ----------------------------------------------- |
| Friend signs up with your code | Both get **$2 API credits** · first 30 sign-ups |
| Friend's first plan purchase | Friend gets **10% off** · you earn **10% back** |
| Referral window | **40 days** from their sign-up date |
**Invite Code:** `EAEGUP`
👉 [Sign up at platform.xiaomimimo.com](https://platform.xiaomimimo.com?ref=EAEGUP) — code auto-filled on sign-up
</details>
---
## 🚀 herdr (Optional)
Terminal-native agent multiplexer — like `tmux` but agent-aware. Manage workspaces, tabs, and panes, each running its own shell, agent, server, or log stream, with automatic agent status tracking and a local socket API. [Homepage](https://herdr.dev/) | [Docs](https://herdr.dev/docs/) | [GitHub](https://github.com/ogulcancelik/herdr)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Prerequisites
- Bash 3.0+ (or any POSIX shell)
- A terminal emulator with multiplexer support
### Installation
```bash
# Mac/Linux
curl -fsSL https://herdr.dev/install.sh | bash
# Windows PowerShell
irm https://herdr.dev/install.ps1 | iex
```
Or run this repo's installer:
```bash
./cli.sh
```
### Configuration
herdr configs are stored in [`configs/herdr/`](configs/herdr/) and installed to `~/.config/herdr/`:
- [`AGENTS.md`](configs/herdr/AGENTS.md) — Agent guidelines and best practices
User configuration is generated by herdr itself:
- `~/.config/herdr/config.toml` — Main config (generate defaults with `herdr --default-config`)
- `~/.config/herdr/agent-detection/<agent>.toml` — Per-agent detection overrides
Changes require a reload: `herdr server reload-config` or the global menu.
### Integrations
herdr installs integrations for detected coding agents to enable session restoration and richer state tracking:
```bash
herdr integration install claude # Claude Code
herdr integration install codex # OpenAI Codex CLI
herdr integration install copilot # GitHub Copilot CLI
herdr integration status # Check installed integrations
```
The Claude Code integration writes a hook (`herdr-agent-state.sh`) to `~/.claude/hooks/` and updates `settings.json` — this is managed by herdr itself, not by this repo.
### Agent Skill
The official agent skill file teaches agents how to control herdr from inside a herdr-managed pane. Install it from the upstream source of truth:
- Docs: https://herdr.dev/docs/agent-skill/
- Source: https://github.com/ogulcancelik/herdr/blob/master/SKILL.md
For agents with a skill system, install as a skill named `herdr`. The skill activates when `HERDR_ENV=1` is set (agent is running inside a herdr-managed pane).
### Usage
```bash
# Start herdr
herdr
# List panes in current workspace
herdr pane list
# Split a pane to the right and run a command
herdr pane split 1-2 --direction right --no-focus
herdr pane run 1-3 "npm run dev"
# Wait for an agent to finish
herdr wait agent-status 1-1 --status done --timeout 60000
# Read another pane's output
herdr pane read 1-1 --source recent --lines 50
```
See the full [herdr docs](https://herdr.dev/docs/) for details.
</details>
---
## 🧠 Qoder CLI (Optional)
Qoder's agentic coding CLI. Reads `AGENTS.md` for context, supports MCP servers via `qodercli mcp add`, and ships TUI slash commands like `/init`, `/memory`, `/mcp`, `/status`, `/effort`. [Homepage](https://qoder.com/cli) | [Docs](https://docs.qoder.com/en/cli/quick-start)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
# Mac/Linux
curl -fsSL https://qoder.com/install | bash
# Windows PowerShell
irm https://qoder.com/install.ps1 | iex
```
Or run this repo's installer:
```bash
./cli.sh
```
### Configuration
Qoder CLI configs are stored in [`configs/qodercli/`](configs/qodercli/) and installed to `~/.qoder/`:
- [`AGENTS.md`](configs/qodercli/AGENTS.md) — Agent guidelines (read by Qoder from `~/.qoder/AGENTS.md`)
- [`settings.json`](configs/qodercli/settings.json) — MCP server configuration (installed to `~/.qoder/settings.json`; reload in TUI with `/mcp reload`)
### 🔌 MCP Servers
```json
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@upstash/context7-mcp@latest"]
},
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"qmd": { "command": "qmd", "args": ["mcp"] },
"fff": { "type": "stdio", "command": "fff-mcp", "args": [] },
"react-grab-mcp": {
"command": "npx",
"args": ["-y", "@react-grab/mcp", "--stdio"]
},
"logpilot": { "command": "logpilot", "args": ["mcp-server"] },
"agentmemory": { "command": "npx", "args": ["-y", "@agentmemory/mcp"] },
"sem": { "command": "sem-mcp", "args": [] }
}
}
```
> MCP servers are shipped via `settings.json`. Users who already have `~/.qoder/settings.json` get a `.bak` backup before the repo version is installed.
**Config Locations:**
| Scope | Path |
| ----------------------------------- | -------------------------------------- |
| User settings | `~/.qoder/settings.json` |
| Project settings | `<project>/.qoder/settings.json` |
| Project local settings (gitignored) | `<project>/.qoder/settings.local.json` |
| User AGENTS.md | `~/.qoder/AGENTS.md` |
| Project AGENTS.md | `<project>/AGENTS.md` |
| Project AGENTS.local.md | `<project>/AGENTS.local.md` |
Inside a project, run `/init` to scaffold a starter `AGENTS.md` and manage it with `/memory` in the TUI.
### Usage
```bash
# Start Qoder CLI
qodercli
# Non-interactive single prompt
qodercli -p "Explain the architecture of this codebase"
# Print mode for CI / automation
qodercli --print --output-format=json
# Add an MCP server (global)
qodercli mcp add context7 -- npx -y @upstash/context7-mcp@latest
# Inspect current session / model
qodercli status
```
See the full [Qoder CLI docs](https://docs.qoder.com/en/cli/quick-start) for details.
</details>
---
## 🥷 Kiro CLI (Optional)
Kiro Dev's AI coding assistant with native MCP support, steering files (AGENTS.md), and ACP (Agent Client Protocol) integration. Ships with `/model`, `/editor`, `/usage`, and custom agents. [Homepage](https://kiro.dev/) | [Docs](https://kiro.dev/docs/cli/installation/) | [GitHub](https://github.com/kirodotdev/Kiro)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
# Mac/Linux
curl -fsSL https://cli.kiro.dev/install | bash
# Windows PowerShell
irm https://kiro.dev/install.ps1 | iex
```
Or run this repo's installer:
```bash
./cli.sh
```
### Configuration
Kiro CLI configs are stored in [`configs/kiro/`](configs/kiro/) and installed to `~/.kiro/`:
- [`AGENTS.md`](configs/kiro/AGENTS.md) — Agent guidelines (Kiro uses steering files to guide agent behavior)
- MCP servers are configured via `kiro mcp add <name> -- <command>` or hand-edited in `~/.kiro/settings.json`
**Config Locations:**
| Scope | Path |
| -------------- | ------------------------------------------ |
| User config | `~/.kiro/` |
| Steering files | `~/.kiro/AGENTS.md`, `<project>/AGENTS.md` |
| Conversations | `~/.kiro/conversations/` |
### Usage
```bash
# Start Kiro CLI
kiro
# Non-interactive single prompt (headless mode)
kiro --print "Explain the architecture of this codebase"
# Select model
kiro /model
# Add an MCP server (global)
kiro mcp add context7 -- npx -y @upstash/context7-mcp@latest
# Check context usage
kiro /usage
```
See the full [Kiro CLI docs](https://kiro.dev/docs/cli/installation/) for details.
## </details>
## 🎨 Codiff (Optional)
Beautiful, minimal local diff viewer with LLM-powered walkthroughs. Review Git changes, comment on PRs/MRs inline, and share walkthroughs. [GitHub](https://github.com/nkzw-tech/codiff) | [Homepage](https://codiff.app)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
# macOS (Homebrew)
brew install --cask nkzw-tech/tap/codiff
# Then run: Codiff > Install Terminal Helper (for `codiff` CLI command)
```
Or run this repo's installer:
```bash
./cli.sh
```
### Configuration
Codiff config is stored in [`configs/codiff/`](configs/codiff/) and installed to `~/.codiff/`:
- [`codiff.jsonc`](configs/codiff/codiff.jsonc) — Settings (agent backend, theme, diff style, font) and keymap overrides
**Config Location:**
| Scope | Path |
| ----------- | ------------------------ |
| User config | `~/.codiff/codiff.jsonc` |
### Usage
```bash
# Launch Codiff
codiff
# Review current repository
codiff .
# Generate LLM walkthrough of the diff
codiff -w
# Review a GitHub PR
codiff pr 75
```
See the full [Codiff docs](https://github.com/nkzw-tech/codiff#readme) for details.
</details>
## 🔎 ctx (Optional)
Open-source local agent-history search CLI. Indexes your past coding-agent sessions into local SQLite and lets you search, inspect, and cite prior work from the terminal. [Homepage](https://ctx.rs) | [GitHub](https://github.com/ctxrs/ctx)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
curl -fsSL https://ctx.rs/install | sh
```
> **Security Note:** Review the script before running:
>
> ```bash
> curl -fsSL https://ctx.rs/install -o install-ctx.sh
> cat install-ctx.sh # Review the script
> sh install-ctx.sh
> ```
Or run this repo's installer:
```bash
./cli.sh
```
### Configuration
ctx configs are stored in [`configs/ctx/`](configs/ctx/) and installed to `~/.ctx/`:
- [`config.toml`](configs/ctx/config.toml) — Upgrade channel/interval defaults
ctx also stores runtime data under `~/.ctx/`:
- `~/.ctx/work.sqlite` — local index database
- `~/.ctx/config.toml` — ctx config (managed by this repo, then used by `ctx setup/status/search`)
### Usage
```bash
# Initialize local index
ctx setup
# Search prior sessions
ctx search "failed migration"
```
See the full [ctx docs](https://ctx.rs/first-search) for details.
### MCP Server
ctx provides a read-only MCP server over stdio. It exposes six tools for searching and inspecting your local agent index:
| Tool | Description |
| -------------- | ---------------------------------- |
| `status` | Index status |
| `sources` | List discovered history sources |
| `search` | Search by query or file path |
| `sql` | Run read-only SQL against index |
| `show_session` | Get session transcript |
| `show_event` | Get event with surrounding context |
Start the MCP server:
```bash
ctx mcp serve
```
The ctx MCP server is configured for all supported AI tools via this repo's config files and the central MCP registry (`configs/mcp-registry.json`):
- **Claude Code**, **Cursor**, **Cline**, **Factory Droid**, **Kimi Code**, **CommandCode**, **Kiro**, **Copilot**, **Qoder CLI**, **Pi**, **Antigravity** — registered in tool-specific `mcpServers` JSON config
- **OpenCode**, **Kilo** — registered in `mcp.ctx` (array-command format)
- **Codex**, **Grok** — registered in TOML `[mcp_servers.ctx]` format
- **Claude Code**, **OpenCode**, **Codex**, **Amp**, **Gemini**, **Antigravity**, **CommandCode**, **Copilot**, **Cursor**, **Factory**, **Cline**, **Grok**, **MiMo-Code**, **Qoder CLI**, **Kiro** — also covered by the central `mcp-registry.json` for automatic setup.
To manually configure for any other MCP-aware tool, add:
```json
{
"command": "ctx",
"args": ["mcp", "serve"]
}
```
</details>
## 🔍 Open Code Review (Optional)
AI-powered code review CLI from Alibaba. Reads Git diffs, sends changed files to a configurable LLM, and generates structured review comments with line-level precision. [Homepage](https://alibaba.github.io/open-code-review/) | [GitHub](https://github.com/alibaba/open-code-review)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### 📋 Installation
```bash
npm install -g @alibaba-group/open-code-review
```
Alternatively, install via `./cli.sh` (automated):
```bash
./cli.sh
```
### 🔧 LLM Configuration (Required)
**You must configure an LLM endpoint before using `ocr`.** Without it, reviews will fail with:
```
Error: resolve LLM endpoint: no valid LLM endpoint configured
```
**Option A: Interactive config (recommended)**
```bash
ocr config set llm.url https://api.anthropic.com/v1/messages
ocr config set llm.auth_token your-api-key-here
ocr config set llm.model claude-opus-4-6
ocr config set llm.use_anthropic true
```
**Option B: Environment variables**
```bash
export OCR_LLM_URL=https://api.anthropic.com/v1/messages
export OCR_LLM_TOKEN=your-api-key-here
export OCR_LLM_MODEL=claude-opus-4-6
export OCR_USE_ANTHROPIC=true
```
**Option C: Claude Code compatible** — auto-detects from `ANTHROPIC_BASE_URL`, `ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_MODEL` and parses `~/.zshrc` / `~/.bashrc` for those exports.
> **Anthropic API keys (`sk-ant-*`):** You must also set `llm.auth_header` to `x-api-key`:
>
> ```bash
> ocr config set llm.auth_header x-api-key
> ```
Config is stored in `~/.opencodereview/config.json`.
### ✨ Key Features
- **Deterministic + Agent Hybrid** — Engineering logic for file selection and bundling, agent for dynamic review decisions
- **Smart File Bundling** — Groups related files into review units with isolated context per bundle
- **Line-Level Precision** — External positioning and reflection modules improve location accuracy
- **Custom Review Rules** — JSON rules matched per file path with four-layer priority chain
- **CI/CD Integration** — `--format json` output for pipeline automation
### 🚀 Usage
```bash
# Review all staged, unstaged, and untracked changes
ocr review
# Review branch diff
ocr review --from main --to feature-branch
# Review a specific commit
ocr review --commit abc123
# Preview which files will be reviewed (no LLM calls)
ocr review --preview
# Test LLM connectivity
ocr llm test
# Launch web viewer for review sessions
ocr viewer
```
### 🧩 Integration with Coding Agents
OCR can be installed as a skill or plugin for your AI coding agent:
```bash
# As a skill (works with Claude Code, OpenCode, etc.)
npx skills add alibaba/open-code-review --skill open-code-review
# As a Claude Code plugin
/plugin marketplace add alibaba/open-code-review
/plugin install open-code-review@open-code-review
```
### 📝 Custom Review Rules
Create `.opencodereview/rule.json` in your project root:
```json
{
"rules": [
{
"path": "**/*.java",
"rule": "Check for null safety and resource leak patterns"
},
{
"path": "**/*.{ts,tsx}",
"rule": "Verify TypeScript strict mode compliance"
}
]
}
```
Rules support `include`/`exclude` patterns and follow a four-layer priority chain: CLI flag > project config > global config > system default.
</details>
---
## 🔄 AI Launcher (Optional)
Fast launcher for switching between AI coding assistants. [Homepage](https://github.com/jellydn/ai-launcher)
<details>
<summary><strong>Installation & Configuration</strong></summary>
### Installation
```bash
curl -fsSL https://raw.githubusercontent.com/jellydn/ai-launcher/main/install.sh | sh
```
### Configuration
Copy [`configs/ai-launcher/config.json`](configs/ai-launcher/config.json) to `~/.config/ai-launcher/`:
**Tools:**
| Tool | Aliases | Description |
| ---------- | --------- | --------------------- |
| `claude` | `c` | Anthropic Claude CLI |
| `codex` | `co` | OpenAI Codex CLI |
| `opencode` | `o`, `oc` | OpenCode AI assistant |
| `amp` | `a` | Amp by Modular |
| `pi` | `p` | Pi coding agent |
**Templates:**
| Template | Aliases | Description |
| ------------------------------- | -------------------------- | -------------------------------------- |
| `review` | `rev`, `code-review` | Code review with OpenCode |
| `commit-zen` | `zen`, `logical-commit` | Generate commitizen commit messages |
| `commit-atomic` | `ac`, `auto-commit` | Atomic commit messages |
| `architecture-explanation` | `arch`, `arch-explanation` | Explain codebase architecture |
| `draft-pull-request` | `pr`, `draft-pr` | Create draft PR via gh CLI |
| `types` | `typescript` | Enhance TypeScript types |
| `test` | `spec`, `tests` | Generate tests (Arrange-Act-Assert) |
| `docs` | `document` | Add JSDoc documentation |
| `explain` | `wtf`, `explain-code` | Explain code in detail |
| `review-security` | `sec`, `security` | Security-focused review |
| `review-refactor` | `refactor` | Refactoring recommendations |
| `review-performance` | `perf`, `optimize` | Performance analysis |
| `remove-verbal` | `verbal`, `comments` | Clean verbal comments |
| `remove-ai-slop` | `slop`, `clean-ai` | Remove AI-generated code patterns |
| `tidy-first` | `tidy` | Apply Tidy First principles |
| `simplify` | `simple` | Simplify over-engineered code |
| `simplifier` | `simplify-code` | Code simplification plugin |
| `logical-grouping-pull-request` | `split-pr` | Create PR with logical commit grouping |
</details>
---
## 🛠️ Companion Tools
<details>
<summary><strong>Additional Tools & Integrations</strong></summary>
### Plannotator
[**Plannotator**](https://plannotator.ai/) - Annotate plans outside the terminal for better collaboration. ([GitHub](https://github.com/backnotprop/plannotator))
### Claude-Mem
⚠️ **DEPRECATED** - Use [qmd Knowledge Management](docs/qmd-knowledge-management.md) instead.
### qmd Knowledge Skill
**qmd Knowledge Skill** is an experimental memory/context management system:
- No repository pollution (external storage)
- AI-powered semantic search
- Multi-project support
- Simple & reliable
See [GitHub Issue #11](https://github.com/jellydn/my-ai-tools/issues/11) for details.
### Claude HUD
[**Claude HUD**](https://github.com/jarrodwatts/claude-hud) - Status line monitoring for context usage, tools, agents, and todos.
```bash
# Inside Claude Code
/claude-hud:setup
```
### Try
[**Try**](https://github.com/tobi/try) - Fresh directories for every vibe. ([Interactive Demo](https://asciinema.org/a/ve8AXBaPhkKz40YbqPTlVjqgs))
### Claude Squad
[**Claude Squad**](https://github.com/smtg-ai/claude-squad) - Manage multiple AI agents in separate workspaces with isolated git worktrees.
### cmux
[**cmux**](https://github.com/manaflow-ai/cmux) - Ghostty-based macOS terminal with vertical tabs and notifications for AI coding agents.
### Helmor
[**Helmor**](https://helmor.ai/) - Powerful workspace manager for AI coding agents with worktree isolation and automated setup.
### Spec Kit
[**Spec Kit**](https://github.com/github/spec-kit) - Toolkit for Spec-Driven Development. ([GitHub](https://github.com/github/spec-kit))
### Backlog.md
[**Backlog.md**](https://github.com/MrLesk/Backlog.md) - Markdown-native task manager and Kanban visualizer. ([npm](https://www.npmjs.com/package/backlog.md))
### OpenWiki
[**OpenWiki**](https://github.com/langchain-ai/openwiki) - CLI for generating and maintaining repository documentation for AI agents.
### Agent Browser
[**agent-browser**](https://github.com/vercel-labs/agent-browser) - Headless browser automation CLI for AI agents.
```bash
npx skills add vercel-labs/agent-browser
```
### Dev Browser
[**Dev Browser**](https://github.com/SawyerHood/dev-browser) - Browser automation plugin with persistent page state for Claude Code.
```bash
/plugin marketplace add sawyerhood/dev-browser
/plugin install dev-browser@sawyerhood/dev-browser
```
### React Tools
For React developers:
- [**React Grab**](https://www.react-grab.com/) - MCP server for extracting and analyzing React components (`@react-grab/mcp`)
- [**React Scan**](https://react-scan.com/) - Detect performance issues in your React app automatically
### Orca
[**Orca**](https://onOrca.dev) - Next-gen desktop IDE for orchestrating AI coding agents with worktree isolation, multi-agent terminals, and built-in source control. ([GitHub](https://github.com/stablyai/orca))
```bash
brew install --cask stablyai/orca/orca
```
This repository backs up Orca agent hook scripts under `configs/orca/agent-hooks/` and restores them to `~/Library/Application Support/orca/agent-hooks/` during `./cli.sh`. Hook scripts are available for Claude Code, Gemini CLI, Codex CLI, Cursor, and Factory Droid — each sends lifecycle events to Orca's hook endpoint for session tracking.
</details>
---
## 📚 Best Practices
Setup includes the following shared configuration files installed by `./cli.sh`:
**Software Development Best Practices** — [`configs/best-practices.md`](configs/best-practices.md):
- Kent Beck's "Tidy First?" principles
- Kent C. Dodds' programming wisdom
- Testing Trophy approach
- Performance optimization patterns
**Agent Memory Guidelines** — [`configs/agent-memory-guidelines.md`](configs/agent-memory-guidelines.md) (→ `~/.ai-tools/agent-memory.md`):
- Auto-capture learnings, debugging discoveries, and user preferences as you work
- Persist non-trivial bug fixes immediately for future sessions
- Keep memories concise and actionable — facts and patterns over narrative
These are automatically referenced by all 15+ AI tool AGENTS.md configurations installed by this repo.
---
## 📖 Resources
- [Claude Code Documentation](https://claude.com/claude-code) - Official docs
- [OpenCode Documentation](https://opencode.ai/docs) - Guide with agents and skills
- [Antigravity CLI Docs](https://antigravity.google/docs) - Official documentation (getting started, commands, features, migration)
- [MCP Servers Directory](https://mcp.so) - Model Context Protocol servers
- [Context7 Documentation](https://context7.com/docs) - Library documentation lookup
- [CCS Documentation](https://github.com/kaitranntt/ccs) - Claude Code Switch
- [Claude Code Showcase](https://github.com/ChrisWiles/claude-code-showcase) - Community examples
- [Everything Claude Code](https://github.com/affaan-m/everything-claude-code) - Production configs
- [Claude Code Best Practice](https://github.com/shanraisshan/claude-code-best-practice) - Best practices and tips for Claude Code
- [Why I switched to Claude Code 2.0](https://blog.silennai.com/claude-code)
- [Llama.cpp Setup with Claude/Codex CLI](https://tammam.io/blog/llama-cpp-setup-with-claude-codex-cli/) - Local model setup guide
- [Modern Web Guidance](https://developer.chrome.com/docs/modern-web-guidance) - Chrome's best practices for modern web development
- [xAI CLI](https://x.ai/cli) - Grok CLI official page
- [Grok Build Docs](https://docs.x.ai/build/overview) - Getting started and configuration
- [MiMo-Code](https://github.com/XiaomiMiMo/MiMo-Code) - MiMo-Code repository and documentation
---
## 👤 Author
**Dung Huynh**
- Website: [productsway.com](https://productsway.com)
- YouTube: [IT Man Channel](https://www.youtube.com/@it-man)
- GitHub: [@jellydn](https://github.com/jellydn)
---
## ⭐ Show your support
Give a ⭐️ if this project helped you!
[](https://github.com/jellydn/my-ai-tools/stargazers)
[](https://ko-fi.com/dunghd)
[](https://github.com/sponsors/jellydn)
---
## 📝 Contributing
Contributions, issues and feature requests are welcome! See [CONTRIBUTING.md](CONTRIBUTING.md).
---
Made with ❤️ by [Dung Huynh](https://productsway.com)
Connection Info
You Might Also Like
everything-claude-code
Complete Claude Code configuration collection - agents, skills, hooks,...
markitdown
MarkItDown-MCP is a lightweight server for converting URIs to Markdown.
firecrawl
Firecrawl MCP Server enables web scraping, crawling, and content extraction.
cc-switch
All-in-One Assistant for Claude Code, Codex & Gemini CLI across platforms.
servers
Model Context Protocol Servers
servers
Model Context Protocol Servers