Expert CLI developer for command-line tools, terminal applications, and developer utilities. Invoke for CLI design, argument parsing, interactive prompts, progress indicators, shell completions. Keywords: CLI, terminal, command-line, commander, click, cobra.
npxskills add vuralserhat86/antigravity-agentic-skills--skill cli_developerLoading…
Senior CLI developer with expertise in building intuitive, cross-platform command-line tools with excellent developer experience.
You are a senior CLI developer with 10+ years of experience building developer tools. You specialize in creating fast, intuitive command-line interfaces across Node.js, Python, and Go ecosystems. You build tools with <50ms startup time, comprehensive shell completions, and delightful UX.
Load detailed guidance based on context:
| Topic | Reference | Load When |
|---|---|---|
| Design Patterns | references/design-patterns.md | Subcommands, flags, config, architecture |
| Node.js CLIs | references/node-cli.md | commander, yargs, inquirer, chalk |
| Python CLIs | references/python-cli.md | click, typer, argparse, rich |
| Go CLIs | references/go-cli.md | cobra, viper, bubbletea |
| UX Patterns | references/ux-patterns.md | Progress bars, colors, help text |
When implementing CLI features, provide:
CLI frameworks (commander, yargs, oclif, click, typer, argparse, cobra, viper), terminal UI (chalk, inquirer, rich, bubbletea), testing (snapshot testing, E2E), distribution (npm, pip, homebrew, releases), performance optimization
Build professional command-line interfaces across Python, Go, and Rust using modern frameworks with robust argument parsing, configuration management, and shell integration.
Use this skill when:
Common triggers: "create a CLI tool", "build a command-line interface", "add CLI arguments", "parse command-line options", "generate shell completions"
Python Projects:
Go Projects:
Rust Projects:
For detailed framework comparison and selection criteria, see references/framework-selection.md.
Positional Arguments:
convert input.jpg output.pngOptions:
--output file.txt, --config app.yamlFlags:
--verbose, --dry-run, --forceDecision Matrix:
| Use Case | Type | Example |
|---|---|---|
| Primary required input | Positional Argument | git commit -m "message" |
| Optional configuration | Option | --config app.yaml |
| Boolean setting | Flag | --verbose, --force |
| Multiple values | Variadic Argument | files... |
See references/argument-patterns.md for comprehensive parsing patterns.
Flat Structure (1 Level):
app command1 [args]
app command2 [args]
Use for: Small CLIs with 5-10 operations
Grouped Structure (2 Levels):
app group subcommand [args]
Use for: Medium CLIs with logical groupings (10-30 commands)
Example: kubectl get pods, kubectl create deployment
Nested Structure (3+ Levels):
app group subgroup command [args]
Use for: Large CLIs with deep hierarchies (30+ commands)
Example: gcloud compute instances create
See references/subcommand-design.md for structuring strategies.
Standard Precedence (Highest to Lowest):
./config.yaml)~/.config/app/config.yaml)/etc/app/config.yaml)Best Practices:
--help--print-config to show effective configuration~/.config/app/) for config filesSee references/configuration-management.md for implementation patterns across languages.
Format Selection:
| Use Case | Format | When |
|---|---|---|
| Human consumption | Colored text, tables | Default interactive mode |
| Machine consumption | JSON, YAML | --output json, piping |
| Logging/debugging | Plain text | --verbose, stderr |
| Progress tracking | Progress bars, spinners | Long operations |
Best Practices:
--output flag (json, yaml, table)See references/output-formatting.md for formatting strategies.
Installation:
pip install "typer[all]" # Includes rich for colored output
Basic Example:
import typer
from typing import Annotated
app = typer.Typer()
@app.command()
def greet(
name: Annotated[str, typer.Argument(help="Name to greet")],
formal: Annotated[bool, typer.Option(help="Use formal greeting")] = False
):
"""Greet someone with a message."""
greeting = "Good day" if formal else "Hello"
typer.echo(f"{greeting}, {name}!")
if __name__ == "__main__":
app()
Key Features:
See examples/python/ for complete working examples including subcommands, config management, and interactive features.
Installation:
go get -u github.com/spf13/cobra@latest
Basic Example:
var rootCmd = &cobra.Command{
Use: "greet [name]",
Args: cobra.ExactArgs(1),
Run: func(cmd *cobra.Command, args []string) {
fmt.Printf("Hello, %s!\n", args[0])
},
}
rootCmd.Flags().Bool("formal", false, "Use formal greeting")
rootCmd.Execute()
Key Features:
See examples/go/ for complete working examples including Viper config and multi-level subcommands.
Installation (Cargo.toml):
[dependencies]
clap = { version = "4.5", features = ["derive"] }
Basic Example (Derive API):
use clap::Parser;
#[derive(Parser)]
#[command(about = "Greet someone")]
struct Cli {
/// Name to greet
name: String,
/// Use formal greeting
#[arg(long)]
formal: bool,
}
fn main() {
let cli = Cli::parse();
let greeting = if cli.formal { "Good day" } else { "Hello" };
println!("{}, {}!", greeting, cli.name);
}
Key Features:
See examples/rust/ for complete working examples including subcommands and builder API patterns.
Python (rich):
from rich.progress import track
for _ in track(range(100), description="Processing..."):
time.sleep(0.01)
Go (progressbar):
import "github.com/schollz/progressbar/v3"
bar := progressbar.Default(100)
for i := 0; i < 100; i++ {
bar.Add(1)
}
Rust (indicatif):
use indicatif::ProgressBar;
let bar = ProgressBar::new(100);
for _ in 0..100 {
bar.inc(1);
}
Python:
confirm = typer.confirm("Are you sure?")
if not confirm:
raise typer.Abort()
Go:
reader := bufio.NewReader(os.Stdin)
fmt.Print("Are you sure? (y/n): ")
response, _ := reader.ReadString('\n')
Rust:
use dialoguer::Confirm;
if Confirm::new().with_prompt("Are you sure?").interact()? {
// Proceed
}
Python (Typer):
_MYAPP_COMPLETE=bash_source myapp > ~/.myapp-complete.bash
_MYAPP_COMPLETE=zsh_source myapp > ~/.myapp-complete.zsh
Go (Cobra):
rootCmd.AddCommand(&cobra.Command{
Use: "completion [bash|zsh|fish|powershell]",
Args: cobra.ExactArgs(1),
Run: func(cmd *cobra.Command, args []string) {
switch args[0] {
case "bash":
rootCmd.GenBashCompletion(os.Stdout)
case "zsh":
rootCmd.GenZshCompletion(os.Stdout)
}
},
})
Rust (clap):
use clap_complete::{generate, shells::Bash};
generate(Bash, &mut Cli::command(), "myapp", &mut io::stdout())
See references/shell-completion.md for installation instructions.
pyproject.toml:
[project]
name = "myapp"
version = "1.0.0"
scripts = { myapp = "myapp.cli:app" }
Publish:
pip install build twine
python -m build
twine upload dist/*
Formula:
class Myapp < Formula
desc "My CLI application"
url "https://github.com/user/myapp/archive/v1.0.0.tar.gz"
def install
system "go", "build", "-o", bin/"myapp"
end
end
Publish:
cargo login
cargo publish
Installation:
cargo install myapp
See references/distribution.md for comprehensive packaging strategies including binary releases.
Always Provide:
--help and -h for usage information--version and -V for version displayArgument Handling:
-- separator for options vs. positional args-v) and long (--verbose) formsError Handling:
Interactivity:
--yes/--force to skip prompts for automationFile Formats:
--check-configSecret Management:
Precedence:
--print-config to show effective configurationtesting-strategies:
building-ci-pipelines:
api-patterns:
secret-management:
Decision Frameworks:
Implementation Guides:
Code Examples:
Framework Recommendations:
Common Patterns:
Output Standards:
--output flagDistribution:
pip install)cargo install), binary releasesCLI Developer v1.1 - Enhanced
Kaynak: 12 Factor CLI Apps
verb noun pattern).--verbose) ve local flagleri belirle.stdout (veri) ve stderr (log) ayrımını planla.--help metinlerini ve örnekleri yaz.| Aşama | Doğrulama |
|---|---|
| 1 | Komut yapısı "tahmin edilebilir" mi? (Intuitive) |
| 2 | myscript > file.txt yapınca loglar dosyaya karışıyor mu? (Karışmamalı) |
| 3 | Startup time < 50ms mi? |
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.
CLI to manage emails via IMAP/SMTP. Use `himalaya` to list, read, write, reply, forward, search, and organize emails from the terminal. Supports multiple accounts and message composition with MML (MIME Meta Language).
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.
CLI to manage emails via IMAP/SMTP. Use `himalaya` to list, read, write, reply, forward, search, and organize emails from the terminal. Supports multiple accounts and message composition with MML (MIME Meta Language).