Enum ToolCommands 

pub enum ToolCommands {
    Showcase {
        auto_verify: bool,
        step: Option<String>,
        tier: String,
        model_dir: PathBuf,
        baseline: String,
        zram: bool,
        runs: usize,
        gpu: bool,
        json: bool,
        verbose: bool,
        quiet: bool,
    },
    Rosetta {
        action: RosettaCommands,
    },
    Publish {
        directory: PathBuf,
        repo_id: String,
        model_name: Option<String>,
        license: String,
        pipeline_tag: String,
        library_name: Option<String>,
        tags: Option<Vec<String>>,
        message: Option<String>,
        dry_run: bool,
    },
    Oracle {
        source: Option<String>,
        family: Option<String>,
        size: Option<String>,
        compliance: bool,
        tensors: bool,
        stats: bool,
        explain: bool,
        kernels: bool,
        validate: bool,
        full: bool,
    },
}

Variants

Showcase

Qwen2.5-Coder showcase demo

Fields

auto_verify: bool

Run all steps with auto-verification

step: Option<String>

Run specific step

tier: String

Model tier: tiny (0.5B), small (1.5B), medium (7B), large (32B)

model_dir: PathBuf

Model directory

baseline: String

Baselines to compare: llama-cpp,ollama

zram: bool

Enable ZRAM compression

runs: usize

Number of benchmark runs (spec: minimum 30)

gpu: bool

Force GPU acceleration

json: bool

Output results as JSON

verbose: bool

Verbose output

quiet: bool

Quiet mode (errors only)

Rosetta

Rosetta Stone - Universal model format converter (PMAT-ROSETTA-001)

Fields

action: RosettaCommands

Publish

Publish model to HuggingFace Hub (APR-PUB-001)

Fields

directory: PathBuf

Directory containing model files to publish

repo_id: String

HuggingFace repository ID (e.g., paiml/whisper-apr-tiny)

model_name: Option<String>

Model display name

license: String

License (SPDX identifier, default: mit)

pipeline_tag: String

Pipeline tag (e.g., automatic-speech-recognition, text-generation)

library_name: Option<String>

Library name (e.g., whisper-apr, aprender)

tags: Option<Vec<String>>

Additional tags (comma-separated)

message: Option<String>

Commit message

dry_run: bool

Dry run (preview without uploading)

Oracle

Model Oracle: identify family, size, constraints, and contract compliance

Three modes: apr oracle - Analyze local model file apr oracle hf://org/repo - Query HuggingFace API apr oracle –family qwen2 - Describe contract from YAML

Fields

source: Option<String>

Model file path or hf:// URI

family: Option<String>

Show contract for a model family (e.g., qwen2, llama, whisper, bert)

size: Option<String>

Filter to a specific size variant (e.g., 0.5b, 7b)

compliance: bool

Run full contract compliance check

tensors: bool

List all tensor shapes

stats: bool

Show statistical analysis (GQA, memory, FFN, FLOPS)

explain: bool

Show architecture explanations with literature references

kernels: bool

Show kernel compatibility report (quantization, TPS estimates)

validate: bool

Cross-validate contract against HuggingFace config.json

full: bool

Enable all analysis sections (stats + explain + kernels + validate)

Trait Implementations

impl Debug for ToolCommands

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

Formats the value using the given formatter.

impl FromArgMatches for ToolCommands

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 ToolCommands

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