cli-ai-tools

Name: cli-ai-tools
Author: tomevault-io

AI Community

Repo stars 0
Author updated Live
Author repo skills-registry

Fluxly profile Facts only: domain, agents, trust score, runtime, permissions and network

Domain: AI
Compatible agents: Claude Code
Cursor
Cline
Codex
Windsurf
Gemini CLI

+20
Trust score: 83 / 100 · community maintained
Author / version / license: @tomevault-io · no license declared
Token usage: Lean
Setup complexity: Manual integration
External API key: Required · OpenAI / Anthropic / Google / Gemini
Operating systems: macOS
Runtime requirements: No special requirements
Permissions: Read-only
Write / modify
Shell exec
Env read
Network behavior: External requests
Install commands: 26 variants

Profile is derived at build time from SKILL.md and install vectors. Subject to drift from author intent.

Heads up: 未限定 allowed-tools，默认拥有全部工具权限。; 检出高风险片段：pipe_curl_to_shell

Output preview cli-ai-tools.preview

---
name: cli-ai-tools
description: This skill should be used when the user asks about "CLI AI tools", "Claude Code", "Codex CLI", "…
category: ai
runtime: no special runtime
---

# cli-ai-tools output preview

## PART A: Task fit
- Use case: This skill should be used when the user asks about "CLI AI tools", "Claude Code", "Codex CLI", "Gemini CLI", "Aider", "Goose", "amp", "OpenCode", "Cody CLI", "Copilot CLI", "qodo", "Jules", "Continue", "avante", "Cline", "Roo Code", "Cursor", "Windsurf", or "Trae". Make sure to use this skill whenever the user mentions any AI coding assistant, asks about terminal-based AI tools, wants to compare CLI agents, needs help with commands, flags, configuration, model selection, installation, or troubleshooting of any AI coding tool, even if they don't name a specific tool. Use when this capability is needed..
- Inputs: target material, constraints, expected output, and acceptance criteria.
- Evidence boundary: follow “Tool Index / Anthropic: Claude Code / OpenAI: Codex CLI” and do not present inference as author intent.

## PART B: Execution result
- **01** The card summarizes the use case; runtime output centers on “This skill should be used when the user asks about "CLI AI tools", "Claude Code", "Codex CLI", "Gemini CLI", "Aider", "Goose", "amp", "OpenCode", "Cody CLI", "Copilot CLI", "qodo", "Jules", "Continue", "avante", "Cline", "Roo Code", "Cursor", "Windsurf", or "Trae". Make sure to use this skill whenever the user mentions any AI coding assistant, asks about terminal-based AI tools, wants to compare CLI agents, needs help with commands, flags, configuration, model selection, installation, or troubleshooting of any AI coding tool, even if they don't name a specific tool. Use when this capability is needed.”.
- **02** When the source has headings, the agent prioritizes “Tool Index / Anthropic: Claude Code / OpenAI: Codex CLI” so the result follows the author’s structure.
- **03** Typical output includes task judgment, concrete steps, required commands or file edits, validation, and follow-up options.
- **04** Risk context follows the fingerprint: read files, write/modify files, run shell commands, read environment variables; may access external network resources; requires OpenAI / Anthropic / Google / Gemini API keys.

## Running Rules
- read files, write/modify files, run shell commands, read environment variables; may access external network resources; requires OpenAI / Anthropic / Google / Gemini API keys.
- Validate with a small sample before expanding scope.
- Return the result, validation criteria, and next iteration options.

SKILL.md SKILL.md

---
name: cli-ai-tools
description: This skill should be used when the user asks about "CLI AI tools", "Claude Code", "Codex CLI", "…
category: ai
source: tomevault-io/skills-registry
---

# cli-ai-tools

## When to use
- This skill should be used when the user asks about "CLI AI tools", "Claude Code", "Codex CLI", "Gemini CLI", "Aider"…
- Use it when the task has clear inputs, repeatable steps, and validation criteria.

## What to provide
- Target material, scope, expected result, and forbidden changes.
- Whether network, commands, file writes, or external services are allowed.

## Execution rules
- Organize steps around “Tool Index / Anthropic: Claude Code / OpenAI: Codex CLI” and keep inference separate from source facts.
- read files, write/modify files, run shell commands, read environment variables; may access external network resources; requires OpenAI / Anthropic / Google / Gemini API keys.
- Validate with a small sample before expanding the task.

## Output requirements
- Return the deliverable, key evidence, validation method, and next action.
- Mark missing information as unknown; do not invent commands, platforms, or dependencies.

Evidence boundary and execution chain

The author source anchors workflow facts; repository files anchor sources and commands; Fluxly only adds fit, limitations, and quality judgment.

skill "cli-ai-tools" {
  input      -> user goal + target files + boundaries + acceptance criteria
  context    -> Tool Index / Anthropic: Claude Code / OpenAI: Codex CLI
  rules      -> SKILL.md triggers / order / output contract
  runtime    -> no special runtime | read files, write/modify files, run shell commands, read environment variables | may access external network resources
  guardrails -> requires OpenAI / Anthropic / Google / Gemini API keys + small-sample validation + diff/log review
  output     -> copyable result + checklist + next iteration
}

Interpretation is structured for decision-making; original keeps the upstream SKILL.md unchanged.

Decide Fit First

Core job: This skill should be used when the user asks about "CLI AI tools", "Claude Code", "Codex CLI", "Gemini CLI", "Aider", "Goose", "…
Best fit: Use it when the task has reusable inputs, steps, and validation criteria rather than a one-off answer.
Avoid forcing it: If the source lacks commands, platform support, or external-service evidence, keep those fields unknown instead of guessing.

Design Intent

Structure: The skill is organized around “Tool Index”, “Anthropic: Claude Code”, “OpenAI: Codex CLI”, “Google: Gemini CLI”, showing how the author expects the agent to judge fit, collect context, and produce verifiable output.
Trigger evidence: Prioritize the author’s wording around when to use it, what context to collect, and what output shape to produce.
Evidence boundary: Author text states facts, repository files prove commands and paths, and Fluxly only adds fit, limits, and usage judgment.

How To Use It

Inputs: Provide target material, scope, expected result, forbidden changes, and validation method.
Invocation: Name cli-ai-tools directly; if the source includes slash commands, start with the command and then add task context.
Validation: Start small and check whether the result follows “Tool Index / Anthropic: Claude Code / OpenAI: Codex CLI” before expanding.

Boundaries And Review

Dependencies: Prepare OpenAI / Anthropic / Google / Gemini API keys before running a full task.
Permissions: Declared permissions include read / write / shell-exec / env-read; ask the agent to state file, command, and rollback boundaries before acting.
Quality bar: A useful result names the deliverable, evidence, and next action. Generic prose means the task needs tighter context.

CLI AI Coding Tools Reference

Comprehensive reference for all major command-line AI coding assistants. This covers installation, key commands, flags, configuration, and model selection for each tool.

Tool Index

Tool	Provider	Primary Use
Claude Code	Anthropic	Agentic coding, full codebase understanding
Codex CLI	OpenAI	Agentic coding with sandboxed execution
Gemini CLI	Google	Agentic coding with Gemini models
Aider	Open Source	AI pair programming, git-integrated
Goose	Block	Extensible AI agent with plugins
amp	Sourcegraph	AI agent for large codebases
Copilot CLI	GitHub	Command-line suggestions and explanations
Cody CLI	Sourcegraph	Codebase-aware AI assistant
OpenCode	Open Source	Go-based terminal AI coding
qodo	Qodo	AI code quality and testing
Jules	Google	Async coding agent (GitHub-integrated)
Continue	Open Source	AI code assistant (IDE + CLI)
avante	Open Source	Neovim AI plugin (CLI-adjacent)

Anthropic: Claude Code

The CLI agent currently running in this session. Agentic AI coding with deep codebase understanding, tool use, and MCP integration.

Install:

npm install -g @anthropic-ai/claude-code

Basic usage:

claude                          # interactive REPL
claude "explain this codebase"  # start with a prompt
claude -p "what does main do"   # print mode (non-interactive, outputs to stdout)
claude --resume                 # resume last conversation
claude --continue               # continue last conversation with new input

Key flags:

Flag	Description
`--model <model>`	Select model (e.g. `claude-sonnet-4-20250514`)
`-p, --print`	Print mode: non-interactive, single response to stdout
`--resume`	Resume the most recent conversation
`--continue`	Continue last conversation with new input
`--dangerously-skip-permissions`	Skip all permission prompts (use with caution)
`--allowedTools <tools>`	Comma-separated list of allowed tools
`--output-format <fmt>`	Output format: `text`, `json`, `stream-json`
`--max-turns <n>`	Limit autonomous turns in non-interactive mode
`--verbose`	Enable verbose logging

Slash commands (interactive mode):

Command	Description
`/help`	Show all available commands
`/compact`	Compress conversation to save context
`/clear`	Clear conversation history
`/config`	View/edit configuration
`/permissions`	Manage tool permissions
`/install-plugin <url>`	Install a plugin from GitHub
`/mcp`	Manage MCP server connections
`/model`	Switch model mid-conversation
`/cost`	Show token usage and cost
`/doctor`	Diagnose installation issues

Configuration:

Project config: .claude/settings.json in project root
User config: ~/.claude/settings.json
Memory: CLAUDE.md files (project root, ~/.claude/CLAUDE.md)
MCP servers: .claude/mcp.json

Environment variables:

ANTHROPIC_API_KEY=sk-ant-...        # API key
CLAUDE_MODEL=claude-sonnet-4-20250514  # Default model
ANTHROPIC_BASE_URL=...              # Custom API endpoint

OpenAI: Codex CLI

OpenAI's open-source agentic coding CLI. Runs code in a sandboxed environment with network-disabled containers.

Install:

npm install -g @openai/codex

Basic usage:

codex                           # interactive mode
codex "refactor the auth module"  # start with prompt
codex --approval-mode full-auto "fix all tests"  # fully autonomous

Key flags:

Flag	Description
`--model <model>`	Select model (default: `codex-mini-latest`)
`--approval-mode <mode>`	`suggest` (default), `auto-edit`, `full-auto`
`--quiet`	Minimal output
`-p, --prompt`	Non-interactive single prompt

Approval modes:

suggest — asks before every action
auto-edit — auto-approves file edits, asks for commands
full-auto — auto-approves everything (sandboxed)

Configuration:

Config file: ~/.codex/config.yaml or ~/.codex/config.json
Instructions: AGENTS.md in project root (similar to CLAUDE.md)

Environment variables:

OPENAI_API_KEY=sk-...               # API key
CODEX_MODEL=codex-mini-latest       # Default model

Google: Gemini CLI

Google's CLI coding assistant powered by Gemini models. Free tier available with Google account.

Install:

npm install -g @google/gemini-cli
# Or run without installing:
npx @google/gemini-cli

Basic usage:

gemini                          # interactive mode
gemini "explain this function"  # start with prompt
gemini -p "summarize README"   # non-interactive print mode

Key flags:

Flag	Description
`--model <model>`	Select model (e.g. `gemini-2.5-pro`)
`-p`	Non-interactive print mode
`--sandbox`	Run in sandboxed mode
`--debug`	Enable debug output

Configuration:

Config: ~/.gemini/settings.json
Memory: GEMINI.md in project root
Supports MCP servers via .gemini/mcp.json

Environment variables:

GOOGLE_API_KEY=...                  # API key (or use Google auth)
GEMINI_MODEL=gemini-2.5-pro        # Default model

Google: Jules

Google's asynchronous coding agent. Integrates with GitHub — tasks are assigned via issues and Jules works on them in the background, creating PRs.

Usage:

Accessed via jules.google.com or GitHub integration
Not a traditional CLI tool — operates asynchronously on GitHub repos
Assign tasks via GitHub issues or the Jules web interface
Jules creates branches, makes changes, submits PRs

Key features:

Async operation (runs independently in the background)
GitHub-native integration
Multi-file changes with PR creation
Powered by Gemini models

Open Source: Aider

The most popular open-source AI pair programming CLI. Deep git integration, multi-model support, architect/editor pattern.

Install:

pip install aider-chat
# Or:
pipx install aider-chat
# Or with uv:
uv tool install aider-chat

Basic usage:

aider                               # interactive, auto-detects git repo
aider --model claude-3.5-sonnet     # specify model
aider file1.py file2.py             # add files to context
aider --architect                   # architect mode (plan then edit)

Key slash commands (interactive):

Command	Description
`/add <file>`	Add file(s) to the chat context
`/drop <file>`	Remove file(s) from context
`/run <cmd>`	Run a shell command and share output
`/diff`	Show pending diffs
`/commit`	Commit changes with AI-generated message
`/undo`	Undo the last change
`/model <name>`	Switch model
`/architect`	Toggle architect mode
`/ask`	Ask without editing (question-only mode)
`/lint`	Lint changed files
`/test`	Run tests
`/tokens`	Show token usage
`/clear`	Clear chat history
`/exit`	Exit aider

Key flags:

Flag	Description
`--model <model>`	Main model for editing
`--architect`	Use architect mode (separate planning model)
`--editor-model <model>`	Model for code edits (in architect mode)
`--auto-commits` / `--no-auto-commits`	Toggle auto-commit after each change
`--watch-files`	Watch files for changes and auto-add
`--no-git`	Disable git integration
`--yes`	Auto-confirm prompts
`--edit-format <fmt>`	`whole`, `diff`, `udiff`, `diff-fenced`

Configuration:

Config file: .aider.conf.yml (project root or ~/.aider.conf.yml)
Environment: .env file in project root
Model aliases: .aider.model.settings.yml
Environment variables: ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, OPENROUTER_API_KEY, AIDER_MODEL

Block: Goose

Block's open-source AI agent CLI. Extensible with a plugin system called "extensions" (formerly "toolkits").

Install:

# macOS
brew install block/tap/goose

# Or from source
cargo install goose-cli

# Or via installer script
curl -fsSL https://github.com/block/goose/releases/latest/download/install.sh | bash

Basic usage:

goose session             # start interactive session
goose session -r          # resume last session
goose run "fix tests"     # run with a prompt
goose configure           # configure settings

Key commands:

Command	Description
`goose session`	Start a new session
`goose session -r`	Resume last session
`goose run <prompt>`	Run a single task
`goose configure`	Interactive configuration
`goose info`	Show current configuration

Configuration:

Config file: ~/.config/goose/config.yaml
Supports multiple providers: OpenAI, Anthropic, Google, Ollama, local models
Extensions (plugins) for additional capabilities

Sourcegraph: amp

Sourcegraph's AI coding agent for the terminal. Designed for large codebase understanding.

Install:

# Download from https://ampcode.com
# Or via npm (check current package name):
npm install -g @anthropic-ai/amp

Basic usage:

amp                         # interactive mode
amp "explain the auth flow" # start with prompt
amp --continue              # continue last conversation

Key features:

Thread-based conversations (similar to Claude Code)
Codebase indexing and search
Multi-file editing
Git-aware operations

Configuration:

Config: ~/.amp/settings.json
Memory: AMP.md in project root

GitHub: Copilot CLI

GitHub Copilot's CLI integration. Provides command suggestions and explanations via the gh CLI extension.

Install:

gh extension install github/gh-copilot

Key commands:

Command	Description
`gh copilot suggest "find large files"`	Get command suggestions
`gh copilot explain "tar -xzf file.tar.gz"`	Explain a command

Flags:

Flag	Description
`-t shell`	Target: generic shell command
`-t git`	Target: git command
`-t gh`	Target: GitHub CLI command

Examples:

gh copilot suggest -t git "squash last 3 commits"
gh copilot explain "find . -name '*.log' -mtime +30 -delete"
gh copilot suggest -t shell "monitor CPU usage"

Sourcegraph: Cody CLI

Sourcegraph's AI coding assistant with CLI capabilities. Strong at codebase search and understanding.

Install:

npm install -g @sourcegraph/cody

Basic usage:

cody chat "explain this repo"    # ask questions
cody auth login                  # authenticate
cody auth status                 # check auth

Configuration:

Auth: Sourcegraph access token or SRC_ACCESS_TOKEN env var
Endpoint: SRC_ENDPOINT for self-hosted Sourcegraph

Open Source: OpenCode

Go-based AI coding assistant for the terminal. Lightweight TUI with multi-provider support.

Install:

go install github.com/opencode-ai/opencode@latest
# Or download binary from releases

Basic usage:

opencode                        # launch TUI

Configuration:

Config file: opencode.json in project root
Supports: OpenAI, Anthropic, Google, Groq, local models
Provider-specific API keys via environment variables

Qodo: qodo

AI-powered code quality and test generation tool.

Install:

pip install qodo
# Or:
npm install -g qodo

Key commands:

qodo test <file>                # generate tests
qodo review <file>              # code review
qodo improve <file>             # suggest improvements

Neovim: avante.nvim

AI-powered Neovim plugin. CLI-adjacent — operates within Neovim's terminal-based interface.

Install: Add to Neovim plugin manager (lazy.nvim, packer, etc.):

{ "yetone/avante.nvim", build = "make" }

Key bindings (in Neovim):

<leader>aa — Open Avante chat
<leader>ae — Edit selected code with AI
<leader>ar — Refresh AI response

Configuration:

In Neovim config (init.lua)
Supports: OpenAI, Anthropic, Azure, Ollama, Copilot

Other CLI-Adjacent Tools

The following are primarily IDE-based, not standalone CLI agents:

Tool	Type	Notes
Cline / Roo Code	VS Code extension	Cline forked as Roo Code. No standalone CLI binary.
Cursor	IDE (VS Code fork)	Open from terminal with `cursor` command.
Windsurf	IDE (Codeium)	Open from terminal with `windsurf` command.
Trae	IDE (ByteDance)	Open from terminal with `trae` command.
Continue	VS Code / JetBrains plugin	Config: `~/.continue/config.json`. Supports all major providers.

Quick Model Selection Reference

Tool	Flag/Config	Example
Claude Code	`--model`	`claude --model claude-sonnet-4-20250514`
Codex CLI	`--model`	`codex --model o4-mini`
Gemini CLI	`--model`	`gemini --model gemini-2.5-pro`
Aider	`--model`	`aider --model claude-3.5-sonnet`
Goose	config file	`goose configure` then select provider/model
Copilot CLI	N/A	Uses GitHub Copilot model
OpenCode	config file	Set in `opencode.json`

Additional Resources

references/tools-comparison.md — Detailed side-by-side feature comparison table across all CLI AI coding tools, covering capabilities, model support, pricing, and platform availability.
references/common-patterns.md — Common usage patterns shared across CLI AI tools: context management, multi-file editing, git integration, MCP server configuration, and model routing strategies.

Source: biodoia/biodoia-skills-marketplace — distributed by TomeVault.

Install command

One-click installPick a runner, click Copy, paste into your terminal, press enter

npx skills add tomevault-io/skills-registry/biodoia--biodoia-skills-marketplace--cli-ai-tools -y

Open general install guide

View skill source

Works with

Claude Code
Cursor
Cline
Codex
Windsurf
Gemini
OpenCode
Roo Code
AAide
+Augment
GitHub Copilot
OpenClaw
KKiro
Junie
WWarp
Goose
Trae
Kilo Code
OpenHands
Amp
Zencoder
CContinue
AIAider
CodeBuddy
CodeGeeX
Replit Agent

Security audit

83 / 100

Community

未声明 license/许可。
未声明 version。
未限定 allowed-tools，默认拥有全部工具权限。
检出高风险片段：pipe_curl_to_shell

Metadata

Source: github
tomevault-io/skills-registry
中文

More by @tomevault-io

Category & tags

Category AI

Decide Fit First

Design Intent

How To Use It

Boundaries And Review

CLI AI Coding Tools Reference

Tool Index

Anthropic: Claude Code

OpenAI: Codex CLI

Google: Gemini CLI

Google: Jules

Open Source: Aider

Block: Goose

Sourcegraph: amp

GitHub: Copilot CLI

Sourcegraph: Cody CLI

Open Source: OpenCode

Qodo: qodo

Neovim: avante.nvim

Other CLI-Adjacent Tools

Quick Model Selection Reference

Additional Resources

Discussion