Struct CommandDef 

pub struct CommandDef {

    pub name: String,
    pub about: Option<String>,
    pub long_about: Option<String>,
    pub usage: Option<String>,
    pub before_help: Option<String>,
    pub after_help: Option<String>,
    pub aliases: Vec<String>,
    pub hidden: bool,
    pub sort_key: Option<String>,
    pub policy: CommandPolicyDef,
    pub args: Vec<ArgDef>,
    pub flags: Vec<FlagDef>,
    pub subcommands: Vec<CommandDef>,
}

Declarative command description used for help, completion, and plugin metadata.

Fields

name: String

Canonical command name shown in the command path.

about: Option<String>

Short summary used in compact help output.

long_about: Option<String>

Expanded description used in detailed help output.

usage: Option<String>

Explicit usage line when generated usage should be overridden.

before_help: Option<String>

Text inserted before generated help content.

after_help: Option<String>

Text appended after generated help content.

aliases: Vec<String>

Alternate visible names accepted for the command.

hidden: bool

Whether the command should be hidden from generated discovery output.

sort_key: Option<String>

Optional presentation key used to order sibling commands.

policy: CommandPolicyDef

Policy metadata that controls command visibility and availability.

args: Vec<ArgDef>

Positional arguments accepted by the command.

flags: Vec<FlagDef>

Flags and options accepted by the command.

subcommands: Vec<CommandDef>

Nested subcommands exposed below this command.

Implementations

impl CommandDef

pub fn new(name: impl Into<String>) -> Self

Creates a command definition with the provided command name.

Examples

use osp_cli::core::command_def::{
    ArgDef, CommandDef, CommandPolicyDef, FlagDef, ValueChoice, ValueKind,
};
use osp_cli::core::command_policy::VisibilityMode;

let policy = CommandPolicyDef {
    visibility: VisibilityMode::Authenticated,
    required_capabilities: vec!["plugins.write".to_string()],
    feature_flags: vec!["beta".to_string()],
};

let command = CommandDef::new("theme")
    .about("Inspect themes")
    .long_about("Long theme help")
    .usage("osp theme [OPTIONS] [name]")
    .before_help("before text")
    .after_help("after text")
    .alias("skin")
    .aliases(["palette"])
    .sort("10")
    .policy(policy.clone())
    .arg(
        ArgDef::new("name")
            .help("Theme name")
            .value_kind(ValueKind::Enum)
            .choices([
                ValueChoice::new("dracula"),
                ValueChoice::new("tokyonight"),
            ]),
    )
    .flag(FlagDef::new("raw").long("raw").help("Show raw values"))
    .subcommand(CommandDef::new("list").about("List available themes"));

assert_eq!(command.name, "theme");
assert_eq!(command.long_about.as_deref(), Some("Long theme help"));
assert_eq!(command.usage.as_deref(), Some("osp theme [OPTIONS] [name]"));
assert_eq!(command.before_help.as_deref(), Some("before text"));
assert_eq!(command.after_help.as_deref(), Some("after text"));
assert_eq!(command.aliases, vec!["skin".to_string(), "palette".to_string()]);
assert_eq!(command.sort_key.as_deref(), Some("10"));
assert_eq!(command.policy, policy);
assert_eq!(command.args[0].choices.len(), 2);
assert_eq!(command.flags[0].long.as_deref(), Some("raw"));
assert_eq!(command.subcommands[0].name, "list");

pub fn about(self, about: impl Into<String>) -> Self

Sets the short help text and returns the updated definition.

pub fn long_about(self, long_about: impl Into<String>) -> Self

Sets the long help text and returns the updated definition.

pub fn usage(self, usage: impl Into<String>) -> Self

Sets the explicit usage line and returns the updated definition.

pub fn before_help(self, text: impl Into<String>) -> Self

Sets text shown before generated help output.

pub fn after_help(self, text: impl Into<String>) -> Self

Sets text shown after generated help output.

pub fn alias(self, alias: impl Into<String>) -> Self

Appends a visible alias and returns the updated definition.

pub fn aliases( self, aliases: impl IntoIterator<Item = impl Into<String>>, ) -> Self

Appends multiple visible aliases and returns the updated definition.

pub fn hidden(self) -> Self

Marks the command as hidden from generated help and discovery output.

pub fn sort(self, sort_key: impl Into<String>) -> Self

Sets a sort key used when presenting the command alongside peers.

pub fn policy(self, policy: CommandPolicyDef) -> Self

Replaces the command policy metadata.

pub fn arg(self, arg: ArgDef) -> Self

Appends a positional argument definition.

pub fn args(self, args: impl IntoIterator<Item = ArgDef>) -> Self

Appends multiple positional argument definitions.

pub fn flag(self, flag: FlagDef) -> Self

Appends a flag definition.

pub fn flags(self, flags: impl IntoIterator<Item = FlagDef>) -> Self

Appends multiple flag definitions.

pub fn subcommand(self, subcommand: CommandDef) -> Self

Appends a nested subcommand definition.

pub fn subcommands( self, subcommands: impl IntoIterator<Item = CommandDef>, ) -> Self

Appends multiple nested subcommand definitions.

impl CommandDef

pub fn from_clap(command: Command) -> Self

Converts a clap command tree into a CommandDef tree.

Only available with the clap cargo feature, which is enabled by default.

Examples

use clap::Command;
use osp_cli::core::command_def::CommandDef;

let command = CommandDef::from_clap(
    Command::new("ldap").about("Directory lookups"),
);

assert_eq!(command.name, "ldap");
assert_eq!(command.about.as_deref(), Some("Directory lookups"));

Trait Implementations

impl Clone for CommandDef

fn clone(&self) -> CommandDef

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CommandDef

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CommandDef

fn default() -> CommandDef

Returns the “default value” for a type.

impl Eq for CommandDef

impl From<&CommandDef> for DescribeCommandV1

fn from(command: &CommandDef) -> Self

Converts to this type from the input type.

impl From<&DescribeCommandV1> for CommandDef

fn from(command: &DescribeCommandV1) -> Self

Converts to this type from the input type.

impl PartialEq for CommandDef

fn eq(&self, other: &CommandDef) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CommandDef