domain-cli

Build Rust CLI tools with clap argument parsing and layered configuration.

1|2|Updated Oct 10, 2025
One-click install
npx skills add https://github.com/dojoengine/torii-core --skill domain-cli-dojoengine
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: domain-cli
Source: https://github.com/dojoengine/torii-core/tree/main/.agents/skills/domain-cli
Command: npx skills add https://github.com/dojoengine/torii-core --skill domain-cli-dojoengine

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Build robust CLI design and tooling support for Rust applications, enabling consistent argument parsing, configuration layering, and maintainable command structures.

Core Features & Use Cases

  • Arg parsing via clap derive for type-safe command-line interfaces.
  • Layered configuration (CLI > env > file) for flexible, predictable startup behavior.
  • Subcommands, progress indicators, and basic interactive prompts for ergonomic UX.
  • Reusable design patterns and templates to accelerate CLI development across projects.

Quick Start

Create a new Rust CLI project, wire clap-based args, and run the app to see the help output.

Frequently Asked Questions about domain-cli

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I build a robust Rust CLI with type-safe argument parsing?

Build a Rust CLI by using clap derive macros to define typed arguments, enabling type-safe command-line parsing and automatic help generation for your application. This approach ensures compile-time validation and consistent argument handling across your project.

What is layered configuration in command-line tools and how does it work?

Layered configuration in command-line tools merges settings from multiple sources with a defined priority, typically CLI arguments overriding environment variables, which override file defaults. This provides predictable and flexible startup behavior for Rust applications.

How do I structure subcommands in a Rust command-line application?

Structure subcommands in a Rust command-line application by using clap derive enums to define distinct command variants, each with its own typed arguments and logic. This maintains an ergonomic UX and a maintainable command structure as the CLI grows.

Does clap support progress indicators and interactive prompts for Rust CLIs?

Clap focuses on argument parsing but supports the foundation for ergonomic UX; progress indicators and interactive prompts are implemented alongside clap to provide user feedback during long-running tasks and basic input collection.

What's the best way to create reusable design patterns for Rust CLI tooling?

The best way to create reusable Rust CLI tooling is to apply consistent templates for clap-based argument parsing and layered configuration across projects. This accelerates development by standardizing command structures and startup configurations.