my-ai-tools

KO | EN

gitlite — search

#typescript #ai-agents #ai #dsh-plugin #deepseek-harness #open-source #cli #claude-code #codex #developer-tools #react #windows

★ 114 Open GitHub ↗

Comprehensive configuration management for AI coding tools - Replicate my complete setup for Claude Code, OpenCode, Amp, Li, Codex and Claude Code Switch with custom configurations, MCP servers, plugins, and commands.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Welcome to my-ai-tools 👋

[![GitHub stars](https://img.shields.io/github/stars/jellydn/my-ai-tools)](https://github.com/jellydn/my-ai-tools/stargazers)
[![GitHub license](https://img.shields.io/github/license/jellydn/my-ai-tools)](https://github.com/jellydn/my-ai-tools/blob/main/LICENSE)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](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, Devin CLI, Kimi Code, Gemini CLI, Antigravity CLI, Pi, Oh My Pi, GitHub Copilot CLI, Cursor Agent CLI, Factory Droid, Cline, Grok CLI, MiMo-Code, Qoder CLI, Kiro CLI, Hunk, Codiff, ctx, Open Code Review, CCS, and Reasonix 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, Devin, Kimi Code, Gemini, Antigravity, Grok, MiMo-Code, Qoder CLI, Kiro CLI, Hunk, Codiff, ctx, Open Code Review, Reasonix, and more
- 🔌 **MCP Server integration** - Context7, Sequential-thinking, qmd, codebase-memory-mcp, agentmemory, sem, ctx
- 🎯 **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.)

## 🖥️ Devin CLI (Optional)

Cognition AI's autonomous coding agent with deep cloud integration. [Homepage](https://devin.ai) | [Docs](https://docs.devin.ai)

<details>
<summary>Installation & Configuration</summary>

### Installation

```bash
curl -fsSL https://cli.devin.ai/install.sh | bash
```

### Configuration

Run the setup script to install configurations to `~/.config/devin/`:

```bash
./cli.sh
```

The setup script automatically deploys MCP servers and agent guidelines.

### MCP Servers

Configuration in [`configs/devin/config.json`](configs/devin/config.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": {
			"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": []
		},
		"ctx": {
			"command": "ctx",
			"args": ["mcp", "serve"]
		},
		"codebase-memory-mcp": {
			"command": "codebase-memory-mcp",
			"args": []
		}
	}
}
```

### Agent Guidelines

Installed to `~/.config/devin/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 Devin CLI
devin

# Run with a specific task
devin -- "check out this code and suggest a feasible, helpful feature"
```

</details>

## ⭐ 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                      |
| **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**                       | Frontier model plans, cheap model executes — audit and plan improvements     | When you need senior-level analysis with actionable plans for cheaper models to run (from shadcn)               |
| **improve-codebase-architecture** | Codebase architecture deepening — find structural improvement opportunities  | When you want to improve modularity, patterns, and architecture of an existing codebase (from Matt Pocock)      |

## 🧭 Fusion Orchestration

Inspired by [opencode-fusion](https://github.com/mihneaptu/opencode-fusion) and complementary evidence-gating ideas from [Gentle AI](https://github.com/Gentleman-Programming/gentle-ai), the `orchestrating-fusion` skill separates senior planning and review from lower-cost mechanical implementation. The installer provides native `fusion-lead` and `fusion-executor` roles for active tools and shares the portable workflow with every assistant through `~/.agents/skills/`.

| Tool         | Start Fusion                                                                  | Enforced boundary                                                                                                 |
| ------------ | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| **OpenCode** | Select the `fusion-lead` primary                                              | Lead has no edit or shell permission and delegates directly to `fusion-executor`                                  |
| **Amp**      | Select the `fusion` agent mode                                                | Lead's tool surface omits mutation/shell and exposes `fusion_executor`                                            |
| **Codex**    | Ask the root session to run `fusion-lead`, then its sibling `fusion-executor` | Lead uses a read-only sandbox; the writable root mediates sibling execution                                       |
| **Pi**       | Ask the root `Agent` tool for `fusion-lead`, then `fusion-executor`           | `pi-subagents` enforces role tool allowlists; the root mediates sibling execution and non-inspection verification |
| **Others**   | Invoke the `orchestrating-fusion` skill                                       | Uses native delegation when available; otherwise the split is prompt-advisory                                     |

The lead hands off exact skill paths plus `OBJECTIVE / FILES / INTERFACES / CONSTRAINTS / VERIFICATION`. The executor returns an evidence envelope covering changes, verification, skills loaded, risks, questions, and key learnings. The lead reads artifacts back, permits one targeted correction, and stops rather than entering an unbounded fix loop. Durable PRDs or plans remain opt-in when they materially reduce ambiguity.

## 🔌 MCP Servers & Plugins Overview

| Tool            | MCP Servers                                                                                                                | Plugins/Extensions                                                                                                                                                                                                                             |
| --------------- | -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Claude Code** | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | Official + Community (plannotator, claude-hud, worktrunk, codex)                                                                                                                                                                               |
| **OpenCode**    | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | @plannotator/opencode                                                                                                                                                                                                                          |
| **Codex**       | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, node_repl, ctx   | -                                                                                                                                                                                                                                              |
| **Kimi Code**   | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, logpilot, sem, ctx                              | Skills, MCP servers, and hooks via `~/.kimi-code/`                                                                                                                                                                                             |
| **Pi**          | context7, sequential-thinking, qmd, codebase-memory-mcp, fff, react-grab-mcp, agentmemory, sem, ctx                        | Packages (pi-extension, pi-subagents, autoresearch, fff, mcp-adapter, simplify, rpiv-todo, btw, code-previews, codex-goal, commandcode-provider, pi-web-access, footer, tps-meter, pi-qwencloud-provider, pi-cursor-sdk) |
| **Oh My Pi**  | Pi-compatible layout; MCP servers via `~/.omp/agent/mcp.json` when present                                                  | Pi fork (`@oh-my-pi/pi-coding-agent`); configs managed under `configs/omp/`                                                                                                                                          |
| **Amp**         | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | Agent modes: fusion, glm-5.2, grok45, inkling, cursor-composer-2.5; plannotator; orca-agent-status                                                                                                                                             |
| **Gemini**      | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | Deprecated for Google One/unpaid tiers; migrate to Antigravity                                                                                                                                                                                 |
| **Antigravity** | context7, sequential-thinking, qmd, codebase-memory-mcp, 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, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | -                                                                                                                                                                                                                                              |
| **Copilot**     | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | -                                                                                                                                                                                                                                              |
| **Cursor**      | context7 (via bunx), sequential-thinking, qmd, codebase-memory-mcp, 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, codebase-memory-mcp, 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, codebase-memory-mcp, 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, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | Default model `grok-4.5` (high reasoning); UI auto + `rosepine-moon`; Kanagawa theme staged                                                                                                                                                    |
| **MiMo-Code**   | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | @plannotator/opencode, opencode-chrome-annotation                                                                                                                                                                                              |
| **Qoder CLI**   | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | -                                                                                                                                                                                                                                              |
| **Kiro CLI**    | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | Steering files (AGENTS.md), slash commands, MCP servers, ACP                                                                                                                                                                                   |
| **Reasonix**    | context7, sequential-thinking, qmd, codebase-memory-mcp, agentmemory, fff, react-grab-mcp, logpilot, sem, ctx              | DeepSeek-native; prefix-cache loop; `[[plugins]]` MCP in config.toml; ACP (`reasonix acp`); `REASONIX.md`/`AGENTS.md` memory; Kanagawa theme staged                                                                                            |
| **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`                                                                   |
| `codebase-memory-mcp` | High-performance code intelligence and structural search                                  | `codebase-memory-mcp`                                                   |
| `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

[![IT Man Channel](https://img.shields.io/badge/YouTube-IT%20Man%20Channel-red?logo=youtube)](https://github.com/jellydn/itman-channel)

[![IT Man - My AI Setup in 2026](https://i.ytimg.com/vi/ESudSFAyuuw/mqdefault.jpg)](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

# Non-interactive mode (auto-approve, only processes your active tools)
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash -s -- --yes

# 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
- `-y` / `--yes` - Non-interactive mode; only installs/configures your active tool set (amp, codex, ctx, cursor, kilo, opencode, open_code_review, pi, omp, antigravity, ai-switcher, claude, reasonix). Shared infra (plugins, skills, global tools) still installed. Auto-activated in CI/piped input.
- `--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] [-y|--yes] [--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.

## 🤖 Chat with the repo

The landing page includes a repository assistant that answers questions from the indexed README, docs, configs, and scripts.

To run it locally:

```bash
cp .env.example .env
# Add OPENAI_API_KEY, OPENAI_BASE_URL, OPENAI_MODEL, and OPENAI_EMBEDDING_MODEL to .env
npm install
npm run index          # build data/index.json (server mode)
npm run index:browser  # build public/index-browser.json (browser mode)
source .env            # load OPENAI_BASE_URL for server mode
npm run dev            # serve http://localhost:3000
```

The assistant only answers from the retrieved repository excerpts, cites the source file paths, and says "This is not documented in the repository." when the context is insufficient.

The landing page also has a browser mode that runs the embedding and an instruction-tuned model (Qwen2.5-Coder-0.5B-Instruct) in the browser via WebGPU. Browser mode downloads the ~9 MB index and the ~300 MB model on the user's device.

## 🐚 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
```

> **Auto-Install:** `./cli.sh` automatically installs Rust via `rustup` when these cargo-dependent MCP servers are selected, so you don't need to install Rust manually beforehand (manual `claude mcp add` still requires a pre-installed Rust toolchain).

> **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

claude plugin marketplace add JuliusBrussee/caveman
claude plugin install caveman@caveman

# 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, code-quality-review, commit-atomic, draft-pull-request, docs-update, llm-wiki, plannotator-setup-goal, portless-local, security-audit, tmux, blindspot-pass, implementation-logger, quiz-me, spec-interview, capability-experiments, code-review, context-discovery, doc-search, git-context, orchestrating-fusion
# 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 |
| `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         |
| `caveman`                | Concise, high-signal response mode      | 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\"'"
	}
}
```

> **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
- `code-review` - Two-axis diff review (Conventions + Intent) with parallel sub-agents — checks bash idioms, Tidy First practices, and whether the change does what it claims
- `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
- `security-audit` - Structured security audit workflow using OWASP Top 10, ASVS, and DevSecOps controls
- `slop` - AI slop detection and removal
- `tdd` - Test-Driven Development workflows
- `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.                                                                                                                                               |
| **Hunk Review**            | [modem-dev/hunk](https://github.com/modem-dev/hunk/blob/main/skills/hunk-review/SKILL.md)                     | Interactive terminal diff viewer for agent-authored changesets with live review sessions and inline comments.                                                                                                                  |
| **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 Code Architect** | [shadcn/improve](https://github.com/shadcn/improve)                                                           | Frontier model plans, cheap model executes — audit any codebase and produce implementation plans for cheaper models to run.                                                                                                    |
| **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 modem-dev/hunk --skill hunk-review --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
- [`CLAUDE.md`](configs/claude/CLAUDE.md) - Token-efficient global instructions with conditional, on-demand guidance
- [`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
- **Efficient Model Routing**: The managed defaults use Sonnet at medium effort for daily work and an Opus advisor for difficult decisions. Run `/advisor` or `/effort` to override them when a task needs a different trade-off.
- **Token-Efficient Context**: The global [`CLAUDE.md`](configs/claude/CLAUDE.md) keeps supplemental guidance conditional instead of using eager `@` imports. Keep prompts narrowly scoped, inspect loaded context with `/context`, limit shell output, and use `/clear` between unrelated tasks.
- **Session Management**: Monitor context usage with `claude-hud`. Create a plan with `/handoffs` and resume with `/pickup` when approaching the 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)

OpenCode 2 is available as a beta alongside OpenCode 1. It installs as the separate `opencode2` command and reads the same global configuration directory, `~/.config/opencode/`. Existing V1 configuration is translated in memory, but V1 plugins do not work with V2; keep OpenCode 1 available until any plugins you rely on have been ported. See the [OpenCode 2 migration guide](https://opencode.ai/v2/docs/migrate-v1).

<details>
<summary>Installation & Configuration</summary>

### Installation

OpenCode 1:

```bash
curl -fsSL https://opencode.ai/install | bash
```

OpenCode 2 beta (side-by-side with V1):

```bash
npm install -g @opencode-ai/cli@next
# Or with Bun (the beta package needs its native postinstall trusted):
bun install -g --trust @opencode-ai/cli@next
# Or with pnpm (allow the native postinstall explicitly):
pnpm add -g --allow-build=@opencode-ai/cli @opencode-ai/cli@next
# Or with Yarn:
yarn global add @opencode-ai/cli@next

opencode2
```

### 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/skills/qmd-knowledge/scripts/record.sh": "allow",
					"$HOME/.claude/skills/qmd-knowledge/scripts/record.sh": "allow"
				}
			}
		}
	},
	"plugin": ["@plannotator/opencode@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

Plugins are automatically installed on next OpenCode launch. Note: `@plannotator/opencode` is a V1 plugin and does not work in OpenCode 2 until ported (see the migration note above).

### Custom Agents

Located in [`configs/opencode/agent/`](configs/opencode/agent/):

- `ai-slop-remover` - Remove AI-generated boilerplate
- `docs-writer` - Generate documentation
- `fusion-executor` - Bounded implementation executor for the Fusion workflow
- `fusion-lead` - Read-only planning lead for the Fusion workflow
- `review` - Code review
- `security-audit` - Security auditing
- `test-generator` - Generate comprehensive tests for code changes

### Custom Providers

OpenCode supports custom model providers via OpenAI-compatible endpoints. They live under the singular `provider` key in `opencode.json` (V1-shaped, intentional), with custom model limits:

| Provider    | Role / models                                                                                          | Endpoint                   |
| ----------- | ------------------------------------------------------------------------------------------------------ | -------------------------- |
| `cursor-acp` | Cursor ACP bridge; models include `auto`, `cursor-grok-4.5-medium`, `composer-2.5`, `claude-*`, `gpt-*`, `gemini-*`, etc. | `http://127.0.0.1:32124/v1` |
| `omniroute`  | OmniRoute; `free` / `paid` / `premium` (plus named routes like `sf/step-3.7-flash`, `cu/grok-4.5-high`) | `http://localhost:20128/v1` |

The top-level default model is `"model": "omnirouter/free"`.

### Custom Commands

Located in [`configs/opencode/command/`](configs/opencode/command/):

- `batch` - Run multiple tasks in parallel as worker tasks
- `happyhorse` - Generate a video with QwenCloud HappyHorse (async, may take minutes)
- `plannotator-annotate` - Annotate the current plan with @plannotator/opencode
- `plannotator-last` - Show the last plannotator plan
- `plannotator-review` - Review the current plan with @plannotator/opencode
- `simplify` - Simplify over-engineered code for clarity and maintainability
- `wan` - Generate an image with QwenCloud Wan (wan2.7)

</details>

---

## 🚀 Command Code (Optional)

AI coding assistant that continuously learns your taste of writing code. [Homepage](https://commandcode.ai)

<details>
<summary>Installation & Configuration</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>Installation & Configuration</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"
}
```

### Agent Modes (plugins)

Custom Amp agent modes live in [`configs/amp/plugins/`](configs/amp/plugins/) and are installed with the rest of the Amp config:

| Plugin                   | Mode key          | Model                              | Notes                                |
| ------------------------ | ----------------- | ---------------------------------- | ------------------------------------ |
| `glm-52-mode.ts`         | `glm-5.2`         | `amp/glm-5.2`                      | Experimental GLM 5.2 agent mode      |
| `grok-45-mode.ts`        | `grok45`          | `xai/grok-4.5`                     | Grok 4.5 with deep-mode tools        |
| `inkling-mode.ts`        | `inkling`         | `baseten/thinkingmachines/inkling` | Thinking Machines Inkling agent mode |
| `kimi-k3-mode.ts`        | `kimi-k3`         | —                                  | Senior engineering judgment mode     |
| `cursor-composer-2.5.ts` | `cursor-comp-2.5` | `openai/gpt-5.2-codex`             | Cursor Composer-style editing mode   |
| `opus-5-mode.ts`         | `opus-5`          | `anthropic/claude-opus-5`          | Opus 5 with configurable reasoning   |
| `plannotator.ts`         | —                 | —                                  | Interactive plan annotation          |
| `orca-agent-status.ts`   | —                 | —                                  | Orca agent status integration        |

The [`my-ai-tools-skills`](configs/amp/plugins/my-ai-tools-skills/) directory plugin also bundles every repository
skill for personal Amp installation. Amp exposes them with qualified names such as
`my-ai-tools-skills:code-review`.

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>Installation & Configuration</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>Installation & Configuration</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"
```

### Custom Agents

Located in [`configs/codex/agents/`](configs/codex/agents/):

- `code-reviewer` - Comprehensive code quality and security review
- `test-generator` - Generate meaningful tests with edge case coverage
- `documentation-writer` - Create clear, helpful documentation
- `ai-slop-remover` - Remove AI-generated boilerplate and improve code quality
- `security-audit` - Security vulnerability assessment

### 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>Installation & Configuration</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>Installation, Migration & Configuration</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

Key defaults from [`configs/antigravity-cli/settings.json`](configs/antigravity-cli/settings.json):

- **Default model**: `Gemini 3.6 Flash (High)`
- **Tool permission**: `proceed-in-sandbox`
- **Allowlist additions**: codebase-memory MCP tools (`search_graph`, `list_projects`, `get_code_snippet`, `trace_path`, `search_code`), GitHub PR lookup, `bun test`, `qmd`, `git worktree`
- **Deny list**: `git reset --hard`, `git push --force`, `rm -rf`
- **Trusted workspaces**: empty by default (add local paths as needed)

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>Installation & Configuration</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.

### 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>Installation & Configuration</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>Installation & Configuration</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)

The 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 `cursor` as the default provider with `auto` as the default model (OmniRoute `paid`/`free`/`premium` remain available in `enabledModels`). You can inspect or edit them at `~/.pi/agent/settings.json` after installation.

**Key Settings:**

- **Default Model**: `auto`
- **Default Provider**: `cursor`
- **Default Thinking Level**: `high`
- **Theme**: `kanagawa`
- **Permission Level**: `high`
- **Quiet Startup**: Enabled (skips changelog on launch)
- **Hide Thinking Block**: Enabled (hides thinking process)

### Custom Agents

Located in [`configs/pi/agents/`](configs/pi/agents/):

### 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-btw",
		"npm:pi-code-previews",
		"npm:pi-codex-goal",
		"npm:pi-commandcode-provider",
		"npm:pi-footer",
		"npm:pi-tps-meter",
		"npm:@juicesharp/rpiv-advisor",
		"npm:pi-web-access",
		"npm:pi-clinepass-provider",
		"npm:@juicesharp/rpiv-ask-user-question",
		"npm:@yofriadi/pi-antigravity-oauth",
		"npm:@juicesharp/rpiv-todo",
		"npm:pi-qwencloud-provider",
		"npm:pi-cursor-sdk"
	]
}
```

**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-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-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      |
| `@juicesharp/rpiv-todo`              | Todo list management tool (replaces `pi-manage-todo-list`)         |
| `pi-qwencloud-provider`              | QwenCloud model provider integration for Pi                        |

> **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`, `grok-4.5`                                                                                                                 |
| openai-codex       | `gpt-5.4-mini`, `gpt-5.5`, `gpt-5.6-luna`, `gpt-5.6-sol`, `gpt-5.6-terra`                                                                          |
| clinepass          | `deepseek-v4-pro` (default), `deepseek-v4-flash`, `kimi-k2.7-code`, `glm-5.2`, `kimi-k2.6`, `kimi-k3`, `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`, `MiniMaxAI/MiniMax-M3`, `poolside/laguna-s-2.1-free`                                                                   |
| qw                 | `deepseek-v4-pro`, `glm-5.2`, `qwen3.8-max-preview`                                                                                                |

### 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>Installation & Configuration</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"]
		}
	}
}
```

### Custom Agents

Located in [`configs/copilot/agents/`](configs/copilot/agents/):

### 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>Installation & Configuration</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/):

- `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>Installation & Configuration</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 = "auto"
default_plan_mode = true
review = "opencode:clinepass/cline-pass/glm-5.2"
visible_provider_models = "{\"claude\":[],\"codex\":[],\"cursor\":[],\"opencode\":[\"opencode:openrouter/tencent/hy3:free\",\"opencode:opencode/deepseek-v4-flash-free\",\"opencode:opencode/hy3-free\",\"opencode:clinepass/cline-pass/deepseek-v4-flash\",\"opencode:clinepass/cline-pass/deepseek-v4-pro\",\"opencode:clinepass/cline-pass/glm-5.2\",\"opencode:alibaba-token-plan/qwen3.8-max-preview\"],\"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>Installation & Configuration</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>Installation & Configuration</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>Installation & Configuration</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"]

[mcp_servers.sem]
command = "sem-mcp"
args = []

[mcp_servers.ctx]
command = "ctx"
args = ["mcp", "serve"]

[mcp_servers.codebase-memory-mcp]
type = "stdio"
command = "codebase-memory-mcp"

[models]
default = "grok-4.5"
default_reasoning_effort = "high"

[ui]
theme = "auto"
auto_dark_theme = "rosepine-moon"
auto_light_theme = "grokday"
```

### 🎨 Theme

Grok Build ships built-in dark themes (`groknight`, `tokyonight`, `rosepine-moon`, `oscura-midnight`, plus `grokday` for light).

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/`.

Current defaults in `config.toml`:

- **Default model**: `grok-4.5` with `default_reasoning_effort = "high"`
- **UI theme**: `theme = "auto"` with `auto_dark_theme = "rosepine-moon"`

Switch themes in the TUI with `/theme` or edit `[ui]` 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>Installation & Configuration</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>Installation & Configuration</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>Installation &amp; Configuration</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>Installation &amp; Configuration</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>

## 🔍 Hunk (Optional)

Review-first terminal diff viewer for agent-authored changesets, with multi-file navigation, inline agent notes, watch mode, and Git, Jujutsu, and Sapling support. [Homepage](https://www.hunk.dev/) | [Docs](https://www.hunk.dev/docs/) | [GitHub](https://github.com/modem-dev/hunk)

<details>
<summary>Installation &amp; Configuration</summary>

### Installation

```bash
# Cross-platform (Node.js 18+)
npm install --global hunkdiff

# macOS (Homebrew core)
brew install hunk
```

Or run this repo's installer:

```bash
./cli.sh
```

### Configuration

The checked-in [`configs/hunk/config.toml`](configs/hunk/config.toml) is installed to `$XDG_CONFIG_HOME/hunk/config.toml`, or `~/.config/hunk/config.toml` when `XDG_CONFIG_HOME` is unset. It selects Hunk's built-in Kanagawa Wave theme and shows agent notes when a review opens.

Repository-specific settings can override the user config in `.hunk/config.toml`. CLI flags have the highest precedence. This integration does not change the global Git pager; opt in separately if desired:

```bash
git config --global core.pager "hunk pager"
```

### Usage

```bash
hunk diff          # Review the working tree, including untracked files
hunk diff --watch  # Reload as an agent changes the working tree
hunk show          # Review the latest commit
hunk session list  # List live review sessions for agent interaction
```

The recommended [Hunk Review skill](https://github.com/modem-dev/hunk/blob/main/skills/hunk-review/SKILL.md) teaches coding agents to inspect live sessions and add inline comments without launching the interactive TUI themselves.

See the official [install guide](https://www.hunk.dev/docs/start/install/) and [config reference](https://www.hunk.dev/docs/reference/config) for all platforms and preferences.

</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>Installation &amp; Configuration</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>Installation &amp; Configuration</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>Installation & Configuration</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>Installation & Configuration</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       |
| `ccs`      | `switch`  | Claude Code Switch    |

**Templates:**

| Template                        | Aliases                     | Description                            |
| ------------------------------- | --------------------------- | -------------------------------------- |
| `review`                        | `rev`, `code-review`        | Code review with OpenCode              |
| `commit-zen`                    | `zen`, `logical-commit`     | Generate commitizen commit messages    |
| `commit-staged`                 | `gd`, `git-diff`            | Atomic commit for staged changes       |
| `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`                       | `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`, `simplify` | Code simplification plugin             |
| `logical-grouping-pull-request` | `split-pr`                  | Create PR with logical commit grouping |
| `summary`                       | `sum`, `summarize`          | Summarize content via OpenCode (free)  |

</details>

---

## 🛠️ Companion Tools

<details>
<summary>Additional Tools & Integrations</summary>

### Plannotator

[**Plannotator**](https://plannotator.ai/) - Annotate plans outside the terminal for better collaboration. ([GitHub](https://github.com/backnotprop/plannotator))

### Waku

[**Waku**](https://github.com/egoist/waku) - A fast, native desktop app for working with local coding agents.

### 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
```

### Token-Efficient AI Assistants

The setup applies the approach from [How I Stopped Running out of Tokens](https://danielabaron.me/blog/how-i-stopped-running-out-of-tokens/) across the managed AI assistants without assuming that every tool supports Claude-specific hooks or commands:

| Technique               | This repository's implementation                                                                                                                                                                                                                                               |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Compress command output | Installs [RTK](https://github.com/rtk-ai/rtk) once for all assistants. Every managed global instruction profile uses its stable `~/.local/bin/rtk` path when available; Claude additionally gets a managed hook-only integration without an always-loaded `@RTK.md`.           |
| Keep responses concise  | Every managed `AGENTS.md`/`GEMINI.md` profile requests concise, high-signal output. Claude additionally enables the [Caveman](https://github.com/JuliusBrussee/caveman) plugin; use `normal mode` when full prose is preferable and `/caveman-stats` for its savings estimate. |
| Query a code graph      | Uses the existing cross-agent `codebase-memory-mcp` integration instead of installing a redundant CodeGraph server.                                                                                                                                                            |
| Use cheaper defaults    | Claude runs Sonnet at medium effort and configures Opus as the advisor model. Other tools retain their provider-specific defaults rather than receiving unsupported model settings.                                                                                            |
| Control loaded context  | Replaces eager guidance imports in Claude, OpenCode, Kilo, MiMo-Code, Gemini, Antigravity, and the cross-tool profiles with conditional reads. All profiles request scoped discovery, bounded command output, and fresh sessions between unrelated tasks.                      |
| Monitor context         | Claude uses Claude HUD in the status line. Other assistants can use their native context/session meters where available.                                                                                                                                                       |

For a separate Claude rolling usage and burn-rate view, install [Claude Code Usage Monitor](https://github.com/Maciek-roboblog/Claude-Code-Usage-Monitor) and run it in another terminal so it does not replace the existing status line:

```bash
uv tool install claude-monitor
claude-monitor --plan pro
```

RTK savings are available with `~/.local/bin/rtk gain --daily`. To temporarily bypass command rewriting, prefix a command with `RTK_DISABLED=1`.

RTK is installed automatically on macOS, Linux, and WSL. Native Windows users should install a release binary manually; WSL is recommended for full hook support.

### 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

### 9Router

[**9Router**](https://9router.com) - Smart AI router connecting CLI/IDE tools to 60+ AI providers with 3-tier auto-fallback (subscription → cheap → free). Built-in RTK token compression and Caveman mode. Open-source (MIT). ([GitHub](https://github.com/decolua/9router))

```bash
npm install -g 9router
```

### 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

**Implementation Notes** — [`configs/implementation-notes-guidelines.md`](configs/implementation-notes-guidelines.md) (→ `~/.ai-tools/implementation-notes.md`):

- Structured workflow for AI agents to capture implementation notes
- Templates and style rules for what to record after each task
- Decision rules for routing knowledge to the right store (qmd / agentmemory / handoffs)

Best practices and memory guidelines are automatically referenced by all 15+ AI tool AGENTS.md configurations installed by this repo; implementation notes are linked from the shared memory workflow.

---

## 📖 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
- [9Router](https://9router.com) - AI router with 60+ providers and 3-tier fallback

---

## 👤 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!

[![GitHub stars](https://img.shields.io/github/stars/jellydn/my-ai-tools?style=flat&logo=github&label=Stars)](https://github.com/jellydn/my-ai-tools/stargazers)
[![Ko-fi](https://img.shields.io/badge/Ko--fi-Support%20me-ff5e5b?logo=ko-fi&logoColor=white)](https://ko-fi.com/dunghd)
[![GitHub Sponsors](https://img.shields.io/badge/Sponsor-%E2%9D%A4-ff69b4?logo=githubsponsors&logoColor=white)](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)

my-ai-tools

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README