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.