mcpField
C
CLI Command Explainer

CLI Command Explainer

Local
github.com/zmwaiworldDeveloper Tools0Updated 30w ago

About CLI Command Explainer

CLI Command Explainer is an MCP server for coding agents that explains shell commands and rates their risk before execution. It checks a built-in dictionary and system man pages first, with optional AI explanations for commands those sources miss.

Key features

  1. 01Explanations of commands and flags
  2. 02Low, medium, high, and unknown risk ratings
  3. 03Detection of common shell syntax
  4. 04Built-in dictionary and system man-page lookup
  5. 05Optional local or cloud AI explanations

Use cases

  1. 01Review shell commands proposed by coding agents
  2. 02Check commands involving elevated privileges or deletion
  3. 03Understand pipes, redirects, and error-handling syntax
  4. 04Explain commands missing from reference sources

MCP support

The server exposes the `explain_command` tool, called by a pre-command hook to return a command explanation and risk rating. Explanations can come from its built-in dictionary, system man pages, or optional AI.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
"mcpServers": {
"cmd-explain": {
"command": "npx",
"args": [
"-y",
"cmd-explain"
]
}
}
}
Run commandnpx -y cmd-explain

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
npmcmd-explain

Tools

1

Saved tool list · updated 2w ago

ParameterTypeRequiredDescription
commandstringYesThe full CLI command to explain

Details

From the project README

cmd-explain

cmd-explain

Know what every shell command does — before you approve it.
MCP server for AI coding agents · Works with Kiro, Cursor, VS Code, Windsurf, Claude Code

English | 中文

Quick Start · How It Works · Supported IDEs · Local AI


The Problem

AI coding agents run shell commands on your machine. They show an approval dialog, but you're left guessing:

Agent wants to run:  curl -sL https://raw.githubusercontent.com/some-tool/install.sh | sudo bash

  [ Approve ]   [ Deny ]

Is that safe? What does -sL mean? Why sudo? Most people either blindly approve (dangerous) or Google it (slow, breaks flow).

The Fix

cmd-explain intercepts every shell command before it runs and shows you a plain-English explanation with a risk rating:

🔴 Transfer data from or to a URL (silent, follow redirects),
   then GNU Bourne-Again SHell
   Risk: high · Source: built-in

Agent wants to run:  curl -sL https://raw.githubusercontent.com/some-tool/install.sh | sudo bash

  [ Approve ]   [ Deny ]

Now you know: it silently downloads a script and pipes it to bash with root privileges. That's a one-line rootkit vector. Easy deny — or at least worth inspecting first.

More Examples

Commands that agents actually suggest — and that you'd probably approve without thinking:

🔴 chmod -R 777 .
   Change file permissions (recursive)
   Risk: high · Source: built-in
   → Makes every file in your project world-writable

🟡 curl -sL https://install.example.com | bash
   Transfer data from or to a URL (silent, follow redirects),
   then GNU Bourne-Again SHell
   Risk: medium · Source: built-in
   → Downloads and executes a remote script. Classic supply chain risk.

🔴 git push origin main --force
   Upload local commits to a remote (force push, set upstream)
   Risk: high · Source: built-in
   → Overwrites remote history. Other people's commits may be lost.

🔴 rm -rf node_modules dist .next .cache && npm ci
   Remove files or directories (recursive, force without confirmation),
   then clean install from lockfile
   Risk: high · Source: built-in

🟡 npx prisma db push --accept-data-loss
   Run a command from a local or remote npm package without installing
   Risk: medium · Source: built-in
   → That --accept-data-loss flag means exactly what it says.

🔴 kubectl exec -it prod-db-0 -- psql -c "DROP TABLE users"
   Execute a command in a container
   Risk: high · Source: built-in
   → Running SQL directly on a production pod.

Every explanation includes:

  • What it does in plain English, including flags and shell patterns (2>&1, || true, >/dev/null)
  • Risk level — low (read-only), medium (state-changing), high (destructive), or unknown
  • Source — built-in (241-command dictionary), system (man pages), or ai-generated (LLM)

Quick Start

npx cmd-explain setup

That's it. Auto-detects your IDE, installs the MCP server, creates the pre-command hook. Restart your IDE and you're protected.

Requirements: Node.js 18+. No API keys, no Ollama, no config files to edit.

How It Works

cmd-explain is an MCP server with one tool: explain_command. When your agent is about to run a shell command, a pre-command hook calls this tool automatically.

Explanations come from three tiers, checked in order:

TierSourceSpeedCoverageNeeds Setup?
1Built-in dictionary — 240+ programs with 440+ command explanations (git, docker, npm, kubectl, terraform, aws, brew, cargo, and more)<1ms~90% of agent commandsNo
2System man pages — parses whatis output for any installed CLI tool~50msMost installed toolsNo
3Local AI — Ollama, OpenAI, or Anthropic for anything tiers 1–2 miss~1sEverythingOptional

Tiers 1 and 2 are fully offline with zero dependencies. Tier 3 is opt-in.

Shell Pattern Detection

cmd-explain understands shell syntax that agents commonly use:

PatternAnnotation
2>&1redirect stderr to stdout
>/dev/null 2>&1suppress all output
2>/dev/nullsuppress error output
|| trueignore exit code
set -eexit on error
set -xprint commands before execution
set -o pipefailfail on any pipe segment error
$(...)command substitution

These are appended to the explanation so you always know what the full command is doing.

Risk Classification
LevelMeaningExamples
🟢 lowRead-only, no side effectsls, cat, grep, git status, curl GET
🟡 mediumState-changing but reversiblegit commit, npm install, mkdir, docker build
🔴 highDestructive or irreversiblerm -rf, docker rm -f, terraform destroy, find -delete
⚪ unknownNot recognizedCustom/proprietary CLIs

Supported IDEs

One setup command handles everything. Each IDE gets the right hook format automatically.

IDEHook EventShell Coverage
KiropreToolUse✅ All shell commands
VS Code CopilotPreToolUse✅ All shell commands
CursorbeforeShellExecution✅ Dedicated shell hook
Windsurfpre_run_command✅ Dedicated shell hook
Claude CodePreToolUse✅ Via matcher
npx cmd-explain setup              # Auto-detect all IDEs
npx cmd-explain setup --ide kiro   # Target one IDE
npx cmd-explain setup --no-hooks   # MCP server only

Optional: Local AI

For commands not in the dictionary or man pages, enable local AI explanations powered by Ollama (~1GB one-time download):

brew install ollama
brew services start ollama
ollama pull qwen2.5-coder:1.5b
npx cmd-explain setup --ollama qwen2.5-coder:1.5b

The setup command validates each step — if Ollama isn't installed or the model isn't pulled, it tells you exactly what to run.

Cloud APIs also work:

npx cmd-explain setup --openai-key sk-...

Supported providers: Ollama, OpenAI (OPENAI_API_KEY), Anthropic (ANTHROPIC_API_KEY).

Manual Install

Add to your IDE's MCP config:

{
  "mcpServers": {
    "cmd-explain": {
      "command": "npx",
      "args": ["-y", "cmd-explain"]
    }
  }
}

Config locations:

  • Kiro: .kiro/settings/mcp.json
  • VS Code: .vscode/mcp.json
  • Cursor: .cursor/mcp.json
  • Windsurf: ~/.codeium/windsurf/mcp_config.json
  • Claude Code: ~/.claude/settings.json

Uninstall

npx cmd-explain uninstall

Removes the MCP config and hook files from all detected IDEs. Clean removal, nothing left behind.

Platform Support

macOSLinuxWindows
Dictionary (Tier 1)✅✅✅
Man pages (Tier 2)✅✅⚠️ --help only
Local AI (Tier 3)✅✅✅
Setup CLI✅✅✅

License

MIT

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.