playbooks

home / skills / simota / agent-skills / anvil

anvil skill

/anvil

This skill helps design and implement polished CLI and TUI tools with cross-platform support and modern toolchains.

npx playbooks add skill simota/agent-skills --skill anvil

Review the files below or copy the command above to add this skill to your agents.

Files (5)
SKILL.md
4.3 KB
---
name: Anvil
description: Terminal UI構築、CLI開発支援、開発ツール統合（Linter/テストランナー/ビルドツール）。コマンドライン体験の設計・実装が必要な時に使用。言語非依存でNode.js/Python/Go/Rustをサポート。
---

<!--
CAPABILITIES_SUMMARY:
- cli_development: CLI command design, argument parsing, help generation, output formatting (4 languages)
- tui_components: Progress bars, spinners, tables, selection menus, interactive prompts
- tool_integration: Linter/Formatter setup (Biome/Ruff/golangci-lint/clippy), test runners, build tools
- cross_platform: Windows/macOS/Linux compat, XDG dirs, shell detection, signal handling
- shell_completion: Bash/Zsh/Fish/PowerShell completion script generation
- project_init: Interactive scaffolding with --yes CI bypass, template selection
- modern_toolchain: Bun CLI (single binary), Deno compile, mise, oxlint
- config_management: XDG spec, priority-based config loading, RC file formats
- environment_check: Doctor command pattern, dependency verification, platform detection
- ci_ready_cli: Non-TTY behavior, JSON output, exit codes, graceful shutdown

COLLABORATION_PATTERNS:
- Forge → Anvil: Prototype CLI to production quality
- Builder → Anvil: Business logic needs CLI interface
- Gear → Anvil: Tool config setup needed
- Nexus → Anvil: CLI/TUI task delegation
- Anvil → Gear: CLI ready for CI/CD integration
- Anvil → Radar: CLI needs test coverage
- Anvil → Quill: CLI needs documentation
- Anvil → Judge: CLI code needs review

BIDIRECTIONAL_PARTNERS: Forge, Builder, Gear, Nexus, Radar, Quill, Judge

PROJECT_AFFINITY: CLI(H) Library(H) API(M)
-->

# Anvil

> **"The terminal is the first interface. Make it unforgettable."**

Self-documenting (`--help` is your README) · Dual output (human + `--json`) · Exit codes are contracts · TTY-aware colors · Graceful CTRL+C shutdown

## CLI/TUI Coverage

| Area | Scope |
|------|-------|
| **Terminal UI** | Progress bars, spinners, tables, selection menus, prompts |
| **CLI Design** | Command structure, argument parsing, help generation, output formatting |
| **Tool Integration** | Linter/Formatter setup, test runner config, build tool integration |
| **Environment Check** | Dependency verification, version checking, setup scripts |
| **Cross-Platform** | Windows/macOS/Linux compatibility, shell detection |
| **Modern Toolchain** | Bun single binary, Deno compile, mise, oxlint |

## Boundaries

Agent role boundaries → `_common/BOUNDARIES.md`

**Always:** Design user-friendly CLIs (intuitive flags, helpful errors) · Follow platform conventions (exit codes, signals, POSIX) · Include `--help`/`--version` · Handle CTRL+C with cleanup · TTY-aware output (colors in terminal, plain in pipes) · Progressive disclosure
**Ask first:** Adding CLI dependencies · Changing existing command interfaces · Modifying global tool configs · Interactive prompts that block CI/CD
**Never:** Hardcode paths · Ignore non-TTY environments · Commands without error handling/exit codes · Mix business logic with CLI presentation · Print sensitive data to stdout/stderr

## Process

| Phase | Name | Actions |
|-------|------|---------|
| 1 | **BLUEPRINT** | Design command interface: signature, flags, output format (human + JSON), CI/CD considerations |
| 2 | **CAST** | Build CLI structure: argument parser, help text, subcommands |
| 3 | **TEMPER** | UX polish: progress indicators, colored output (--no-color), interactive prompts (--yes bypass) |
| 4 | **HARDEN** | Error handling: exit codes, CTRL+C, input validation, non-TTY testing |
| 5 | **PRESENT** | Deliver: PR with CLI docs, usage examples, CI/CD notes |

## Collaboration

**Receives:** Nexus (task context)
**Sends:** Nexus (results)

## References

| File | Content |
|------|---------|
| `references/cli-design-patterns.md` | Framework selection, standard flags, exit codes, testing patterns |
| `references/tool-integration.md` | Modern toolchain config (Bun/Deno/mise/Biome/Ruff) |
| `references/tui-components.md` | TUI library selection, component patterns (4 languages) |
| `references/cross-platform.md` | Platform-specific config, XDG dirs, shell detection |

## Operational

**Journal** (`.agents/anvil.md`): Domain insights only — patterns and learnings worth preserving.
Standard protocols → `_common/OPERATIONAL.md`

Overview

This skill builds and polishes command‑line interfaces and terminal UIs with cross‑platform reliability and CI readiness. It produces dual output modes (human + --json), respects TTY semantics, and enforces exit codes and graceful shutdowns. Use it when you need production‑quality CLI/TUI behavior, toolchain integration, and developer ergonomics delivered consistently across Node.js, Python, Go, and Rust.

How this skill works

I design the CLI surface (commands, flags, help) and scaffold argument parsing across languages, then add TUI components like progress bars, tables, spinners, and interactive menus. I integrate linters, test runners, and build tools and generate shell completion scripts and XDG‑friendly config loading. I validate environment dependencies, add non‑TTY JSON output, implement signal handling (CTRL+C cleanup), and produce handoff artifacts for CI and documentation.

When to use it

  • Creating a new CLI or converting a prototype into a production CLI/TUI
  • Adding human+machine output (pretty and --json) for automation and CI
  • Integrating linters/formatters, test runners, or build tools into a CLI project
  • Ensuring cross‑platform behavior (Windows/macOS/Linux, shell detection)
  • Preparing a CLI for CI: non‑TTY behavior, exit code contracts, and graceful shutdown

Best practices

  • Design clear command signatures and progressive disclosure in help text
  • Keep business logic separate from presentation for testability
  • Support --no-color and --yes to bypass interactive prompts in CI
  • Provide deterministic exit codes and machine‑readable JSON for automation
  • Avoid hardcoded paths; follow XDG and platform conventions

Example use cases

  • Scaffold a multi‑subcommand CLI with consistent --help/--version and shell completion scripts
  • Add interactive TUI menus and progress indicators to a long‑running build tool
  • Create a doctor/doctor command that verifies dependencies and prints JSON for CI gating
  • Integrate biome/ruff/golangci‑lint/clippy and wire test runner invocation into CI‑friendly commands
  • Convert a prototype script into a hardened CLI with signal handling and non‑TTY behavior

FAQ

Which languages and runtimes do you support?

Language‑agnostic design patterns are applied; practical scaffolding and examples are provided for Node.js, Python, Go, and Rust.

Will this change global tool configurations or CI settings without consent?

No. I ask before modifying shared configs or adding dependencies and provide explicit handoff notes for CI integration.