Enum TopCommand 

pub enum TopCommand {
    Capabilities,
    Describe {
        capability: String,
    },
    Guide,
    Completions {
        shell: Shell,
    },
    Man,
    Services {
        action: ServicesAction,
    },
    Packages {
        action: PackagesAction,
    },
    Network {
        action: NetworkAction,
    },
    Firewall {
        action: FirewallAction,
    },
    Mcp {
        expanded_tools: bool,
    },
}

The top-level subcommands fez accepts.

Variants

Capabilities

List capability ids for on-demand discovery.

Describe

Describe one capability (inputs, output kind, flags, examples).

Fields

capability: String

Dotted capability id to describe (e.g. services.start).

Guide

Print the agent contract: discovery loop, envelope, exit codes, env vars.

Completions

Generate a shell completion script on stdout.

Fields

shell: Shell

Shell to generate completions for.

Man

Emit the roff man page on stdout (used by packaging).

Services

Manage systemd services.

Fields

action: ServicesAction

The services action to perform.

Packages

Manage RPM packages (via dnf5daemon).

Fields

action: PackagesAction

The packages action to perform.

Network

Inspect NetworkManager devices and connections.

Fields

action: NetworkAction

The network action to perform.

Firewall

Manage the firewall (via firewalld).

Fields

action: FirewallAction

The firewall action to perform.

Mcp

Run as an MCP server (JSON-RPC 2.0 over stdio): a frugal gateway exposing list_capabilities, describe_capability, and invoke meta-tools.

Fields

expanded_tools: bool

Also expose one strict JSON-schema tool per fez capability.

Trait Implementations

impl Debug for TopCommand

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

Formats the value using the given formatter.

impl FromArgMatches for TopCommand

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for TopCommand

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand