Enum Commands 

pub(crate) enum Commands {
    Init {
        name: String,
    },
    Run {
        script: String,
        args: Vec<String>,
    },
    Watch,
    Doctor,
    Gpu(GpuCommands),
    Bench(BenchCommands),
    Debug(DebugCommands),
    Exp(ExpCommands),
    Log {
        id: Option<String>,
        follow: bool,
        grep: Option<String>,
    },
    Data(DataCommands),
    Model(ModelCommands),
    Serve(ServeCommands),
    Hub(HubCommands),
    Job(JobCommands),
    Cluster(ClusterCommands),
    Env(EnvCommands),
    Power(PowerCommands),
    Optimize(OptimizeCommands),
    Autopilot(AutopilotCommands),
    Cloud(CloudCommands),
    Marketplace(MarketplaceCommands),
    Tune(TuneCommands),
    Migrate(MigrateCommands),
    Profile(ProfileCommands),
    Secure(SecureCommands),
    Fleet(FleetCommands),
    Audit(AuditCommands),
    Onboard(OnboardCommands),
    Pqc(PqcCommands),
    Cost(CostCommands),
    Notebook(NotebookCommands),
    Query {
        query: String,
    },
    Install {
        tool: String,
    },
}

Variants

Init

Initialize a new ML project

Fields

name: String

Run

Run a training script with automatic telemetry and experiment tracking

Fields

script: String

args: Vec<String>

Watch

Live dashboard — GPU utilization, training metrics, eBPF telemetry

Doctor

Diagnose environment issues

Gpu(GpuCommands)

GPU management — top, mem, kill, lock, health

Bench(BenchCommands)

ML benchmark suite — gpu, nccl, dataloader, memory, e2e

Debug(DebugCommands)

ML training debugger — why-slow, oom, nan, hang

Exp(ExpCommands)

Experiment tracking

Log

Show training logs

Fields

id: Option<String>

follow: bool

grep: Option<String>

Data(DataCommands)

Dataset management — profile, split, cache, shard

Model(ModelCommands)

Model registry

Serve(ServeCommands)

Unified inference server — start, stop, benchmark

Hub(HubCommands)

Private model & dataset hub

Job(JobCommands)

Distributed job management

Cluster(ClusterCommands)

GPU cluster management — add, status, sync, run, drain

Env(EnvCommands)

Environment management — snapshot, diff, reproduce, export

Power(PowerCommands)

Smart GPU power management & energy tracking

Optimize(OptimizeCommands)

Training optimizations — precision, memory, checkpoints, NUMA

Autopilot(AutopilotCommands)

Autonomous training optimizer — monitors and fixes problems automatically

Cloud(CloudCommands)

GPU cloud management — launch, manage, destroy clusters

Marketplace(MarketplaceCommands)

Model marketplace — publish, browse, download, deploy

Tune(TuneCommands)

Adaptive kernel parameter tuning based on hardware

Migrate(MigrateCommands)

Live job migration between GPUs

Profile(ProfileCommands)

Full training pipeline profiler with waterfall

Secure(SecureCommands)

System hardening for production ML

Fleet(FleetCommands)

GPU fleet management — cost attribution, idle detection, capacity planning

Audit(AuditCommands)

Compliance audit trail — lineage, provenance, HIPAA/SOC2 exports

Onboard(OnboardCommands)

Developer onboarding — one-command setup, env sync, sharing

Pqc(PqcCommands)

Post-Quantum Cryptography — sign, verify, encrypt, decrypt

Cost(CostCommands)

GPU cost tracking — summary, budget, report

Notebook(NotebookCommands)

Jupyter notebook management

Query

Query experiments, jobs, models with ZQL

Fields

query: String

Install

Install ML tools (pytorch, ollama, jupyter, etc.)

Fields

tool: String

Trait Implementations

impl FromArgMatches for Commands

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 Commands

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