Enum ProbeAction 

pub enum ProbeAction {
    Flake {
        iterations: usize,
        jobs: usize,
        probe: Option<String>,
        threshold: u8,
        dry_run: bool,
    },
    Impact {
        base: String,
        head: String,
        cache: Option<PathBuf>,
        verbose: bool,
    },
    Coverage {
        open: bool,
        output: Option<PathBuf>,
        compare: Option<PathBuf>,
        threshold: Option<f32>,
    },
    Profile {
        top: usize,
        probe: Option<String>,
        flamegraph: Option<PathBuf>,
        dry_run: bool,
    },
    Tag {
        tags: Vec<String>,
        exclude: Vec<String>,
        list: bool,
        dry_run: bool,
    },
    CiGen {
        platform: CiPlatform,
        coverage: bool,
        flake_detect: bool,
        profile: bool,
        output: Option<PathBuf>,
    },
    Env {
        action: EnvAction,
    },
    Replay {
        run_id: String,
        output: Option<PathBuf>,
        no_cleanup: bool,
    },
    Order {
        random: bool,
        seed: Option<String>,
        dry_run: bool,
        repeat: Option<usize>,
    },
    Doc {
        output: PathBuf,
        include_private: bool,
        skip_ignored: bool,
    },
}

Probe command actions

Variants

Flake

Flaky-probe detector - runs probes multiple times to detect instability

Fields

iterations: usize

Number of iterations to run (default: 20)

jobs: usize

Number of parallel workers (default: 4)

probe: Option<String>

Run only probes matching this pattern

threshold: u8

Fail if pass-rate falls below this percentage (default: 90)

dry_run: bool

Show plan without executing

Impact

Run only probes affected by recent changes

Fields

base: String

Base reference (default: origin/main)

head: String

Head reference (default: HEAD)

cache: Option<PathBuf>

Directory for source-to-probe index cache (default: ~/.cache/cmt-impact)

verbose: bool

Show selected probe list

Coverage

Coverage collection and visualization

Fields

open: bool

Open generated HTML in browser

output: Option<PathBuf>

Write JSON summary to file

compare: Option<PathBuf>

Compare against previous JSON file

threshold: Option<f32>

Fail if coverage drops below percentage

Profile

Per-probe timing and flamegraphs

Fields

top: usize

Show N slowest probes (default: 10)

probe: Option<String>

Focus on single probe

flamegraph: Option<PathBuf>

Generate flamegraph for selected probe

dry_run: bool

Print order without running

Tag

Custom probe tags and filtered execution

Fields

tags: Vec<String>

Run only probes with this tag (multiple tags ANDed)

exclude: Vec<String>

Run everything except probes with this tag

list: bool

Print all available tags

dry_run: bool

Show matching probes without running

CiGen

One-click CI snippet generator

Fields

platform: CiPlatform

Target CI platform

coverage: bool

Include coverage step

flake_detect: bool

Include flaky-probe detection

profile: bool

Include profiling step

output: Option<PathBuf>

Write to file instead of stdout

Env

Docker-backed probe environment manager

Fields

action: EnvAction

Replay

Deterministic failure reproducer

Fields

run_id: String

Run ID to replay

output: Option<PathBuf>

Extract snapshot to directory

no_cleanup: bool

Keep temporary directory after replay

Order

Randomised/seeded probe ordering

Fields

random: bool

Use random ordering (default)

seed: Option<String>

Use specific seed for deterministic ordering

dry_run: bool

Show order without running

repeat: Option<usize>

Run shuffled suite N times

Doc

Generate Markdown inventory of all probes

Fields

output: PathBuf

Output file (default: probeS.md)

include_private: bool

Include probes in #[cfg(probe)] modules

skip_ignored: bool

Omit #[ignore] probes

Trait Implementations

impl Clone for ProbeAction

fn clone(&self) -> ProbeAction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProbeAction

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

Formats the value using the given formatter.

impl FromArgMatches for ProbeAction

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 ProbeAction

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