Installation

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

Configuration

Copy configs/opencode/opencode.json to ~/.config/opencode/:

{
	"$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
		}
	},
	"agent": {
		"build": {
			"permission": {
				"bash": {
					"git push": "ask",
					"qmd": "allow",
					"qmd query": "allow",
					"qmd get": "allow",
					"qmd search": "allow",
					"$HOME/.config/opencode/skill/qmd-knowledge/scripts/record.sh": "allow",
					"$HOME/.claude/skills/qmd-knowledge/scripts/record.sh": "allow"
				}
			}
		}
	},
	"plugin": [
		"@plannotator/opencode@latest",
		"@mohak34/opencode-notifier@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 - Interactive code planning and annotation
• @mohak34/opencode-notifier - Sound and system notifications for events (permission requests, completion, errors, questions)

Plugins are automatically installed on next OpenCode launch. Configure notification behavior via ~/.config/opencode/opencode-notifier.json if desired.

Custom Agents

Located in configs/opencode/agent/:

• ai-slop-remover - Remove AI-generated boilerplate
• docs-writer - Generate documentation
• review - Code review
• security-audit - Security auditing

Custom Commands

Located in configs/opencode/command/:

• simplify - Simplify over-engineered code for clarity and maintainability
• batch - Run multiple tasks in parallel as worker tasks

📋 Installation

npm install -g command-code

🔧 Configuration

Run the setup script to install configurations to ~/.commandcode/:

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

{
	"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"]
		}
	}
}

🤖 Custom Agents

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

Installation

curl -fsSL https://ampcode.com/install.sh | bash

Configuration

Copy configs/amp/settings.json to ~/.config/amp/:

{
	"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"]
		}
	},
	"amp.terminal.theme": "kanagawa"
}

See configs/amp/AGENTS.md for agent guidelines.

Installation

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, GitHub Copilot (zero API keys needed)
3. API Profiles - GLM, Kimi, OpenRouter, or any Anthropic-compatible API

Quick Start

1. Open Dashboard:

   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:

   ccs           # Default Claude session
   ccs gemini    # Gemini (OAuth)
   ccs codex     # OpenAI Codex (OAuth)
   ccs glm       # GLM (API key)
   ccs ollama    # Local Ollama
   

Configuration

CCS auto-creates config on install. Dashboard is the recommended way to manage settings.

Config location: ~/.ccs/config.yaml

See configs/ccs/config.yaml for example configuration.

Installation

npm install -g @openai/codex

Configuration

Located in configs/codex/:

• config.toml - Main TOML configuration with MCP servers
• AGENTS.md - Agent guidelines

MCP Servers

[mcp_servers.context7]
command = "npx"
args = [ "-y", "@upstash/context7-mcp" ]

[mcp_servers.notion]
url = "https://mcp.notion.com/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"]

Plugins

[plugins."github@openai-curated"]
enabled = true

[plugins."computer-use@openai-bundled"]
enabled = true

[plugins."plannotator@plannotator"]
enabled = true

Usage

# Start Codex CLI
codex

# Use with Ollama (local models)
codex --oss

# Use with a specific task
codex "Explain this code"

Installation

npm install -g @google/gemini-cli

Or using Homebrew (macOS/Linux):

brew install gemini-cli

Authentication

Gemini CLI supports multiple authentication methods:

Option 1: Login with Google (OAuth)

gemini
# Follow the browser authentication flow

Option 2: Gemini API Key

export GEMINI_API_KEY="YOUR_API_KEY"
gemini

Get your API key from Google AI Studio.

Configuration

Located in configs/gemini/:

• settings.json - Main configuration with MCP servers and experimental features
• GEMINI.md - Agent guidelines
• AGENTS.md - Additional agent guidelines
• 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/ - 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

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

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

{
	"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"]
		}
	},
	"experimental": {
		"enableAgents": true
	}
}

Note: Custom agents in ~/.gemini/agents/ are automatically discovered when experimental.enableAgents is set to true.

Installation

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

{
	"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
		},
		"logpilot": {
			"type": "local",
			"command": ["logpilot", "mcp-server"],
			"enabled": true
		}
	}
}

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

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

Installation

curl -fsSL https://pi.dev/install.sh | sh

Configuration

Pi uses ~/.pi/settings.json for global user settings and .pi/settings.json in project roots for project-level configuration.

Located in configs/pi/:

• settings.json - Global settings with package registrations

Key Settings:

• Default Model: kimi-k2.6 (via crofai)
• Default Provider: crofai
• Default Thinking Level: high
• Theme: kanagawa
• Permission Level: high
• Quiet Startup: Enabled (skips changelog on launch)
• Hide Thinking Block: Disabled (shows thinking process)

Pi Packages

Pi uses a package-based extension system (not MCP). Install packages with:

pi install pi-flow-enforcer
pi install pi-agent-pack

Then register them in .pi/settings.json:

{
	"packages": [
		"npm:@plannotator/pi-extension",
		"npm:pi-subagents",
		"https://github.com/davebcn87/pi-autoresearch",
		"npm:pi-hooks",
		"npm:@ff-labs/pi-fff",
		"npm:pi-mcp-adapter",
		"npm:pi-simplify",
		"npm:pi-manage-todo-list",
		"npm:pi-btw",
		"npm:pi-crofai"
	]
}

Package Overview:

Usage

# Start Pi
pi

# Run a task non-interactively
pi "Refactor this function to be more readable"

Prerequisites

Requires an active GitHub Copilot subscription and Node.js/npm.

Installation

npm install -g @github/copilot

Configuration

Copilot CLI configs are stored in configs/copilot/ and installed to the official global paths under ~/.copilot/.

• AGENTS.md - Agent guidelines and best practices, installed to ~/.copilot/copilot-instructions.md
• mcp-config.json - MCP server configuration, installed to ~/.copilot/mcp-config.json

MCP Servers

{
	"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"]
		}
	}
}

Usage

# 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

Prerequisites

Requires the Cursor 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/ and installed to ~/.cursor/rules/.

• AGENTS.md - Agent guidelines and best practices, installed to ~/.cursor/rules/general.mdc

Usage

# Open a project in Cursor
cursor .

# Open a specific file
cursor /path/to/file

# Check the CLI version
cursor --version

Installation

npm install -g @factory/cli

After installation, navigate to your project and start the droid CLI:

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 for supported providers and configuration.

Set your API key via environment variable:

export FACTORY_API_KEY=your_api_key_here

Or use the interactive login:

droid /login

Configuration

Factory Droid configs are stored in configs/factory/ and installed to ~/.factory/:

• AGENTS.md - Global agent guidelines
• mcp.json - MCP server configurations
• settings.json - Factory Droid settings
• droids/ - Optional user-created directory for custom droid definitions

MCP Servers

{
	"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"]
		}
	}
}

Usage

# 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

Installation

npm install -g cline

Authentication

Cline supports multiple authentication methods:

Option 1: OAuth (Cline Account)

cline
# Follow the browser authentication flow

Option 2: API Keys

Configure API keys via the Cline dashboard or set environment variables:

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/:

• mcp-settings.json - MCP server configurations, installed to ~/.cline/data/settings/cline_mcp_settings.json
• models.json - Model configurations
• providers.json - Provider credentials (copy from example and fill in your keys)
• kanban-config.json - Kanban board settings

MCP Servers

{
	"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"]
		}
	}
}

Usage

# 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/ folder.

Installation

curl -fsSL https://raw.githubusercontent.com/jellydn/ai-launcher/main/install.sh | sh

Configuration

Copy configs/ai-launcher/config.json to ~/.config/ai-launcher/:

Tools:

• claude / c - Claude CLI
• opencode / o, oc - OpenCode
• amp / a - Amp

Templates:

• review - Code review
• commit / commit-zen - Commit messages
• ac / commit-atomic - Atomic commits
• pr / draft-pr - Pull requests
• types - Type safety
• test - Tests
• docs - Documentation
• simplify - Code simplification

Plannotator

Plannotator - Annotate plans outside the terminal for better collaboration. (GitHub)

Claude-Mem

⚠️ DEPRECATED - Use qmd Knowledge Management 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 for details.

Claude HUD

Claude HUD - Status line monitoring for context usage, tools, agents, and todos.

# Inside Claude Code
/claude-hud:setup

Try

Try - Fresh directories for every vibe. (Interactive Demo)

Claude Squad

Claude Squad - Manage multiple AI agents in separate workspaces with isolated git worktrees.

cmux

cmux - Ghostty-based macOS terminal with vertical tabs and notifications for AI coding agents.

Conductor

Conductor - Orchestrate parallel AI coding agents to work on multiple tasks simultaneously.

Helmor

Helmor - Powerful workspace manager for AI coding agents with worktree isolation and automated setup.

Spec Kit

Spec Kit - Toolkit for Spec-Driven Development. (GitHub)

Backlog.md

Backlog.md - Markdown-native task manager and Kanban visualizer. (npm)

Agent Browser

agent-browser - Headless browser automation CLI for AI agents.

npx skills add vercel-labs/agent-browser

Dev Browser

Dev Browser - Browser automation plugin with persistent page state for Claude Code.

/plugin marketplace add sawyerhood/dev-browser
/plugin install dev-browser@sawyerhood/dev-browser

React Tools

For React developers:

• React Grab - MCP server for extracting and analyzing React components (@react-grab/mcp)
• React Scan - Detect performance issues in your React app automatically