Enum Command 

pub enum Command {
    Run {
        issues: Vec<i64>,
        common: Common,
        loop_flags: LoopFlags,
        triage_flags: TriageFlags,
        plan_out: PathBuf,
        no_worktrees: bool,
    },
    Triage {
        issues: Vec<i64>,
        common: Common,
        plan_out: PathBuf,
    },
    Resume {
        prs: Vec<i64>,
        common: Common,
        loop_flags: LoopFlags,
        next_actor: Option<String>,
    },
    Review {
        items: Vec<i64>,
        common: Common,
        dry_run: bool,
        max_rounds: Option<u32>,
    },
    Post {
        prs: Vec<i64>,
        repo: PathBuf,
        config: Option<PathBuf>,
        file: Option<PathBuf>,
        dry_run: bool,
    },
    Init {
        out: PathBuf,
        force: bool,
        update: bool,
    },
    Clean {
        repo: PathBuf,
        config: Option<PathBuf>,
        all: bool,
        pr_state: bool,
    },
    Doctor {
        config: Option<PathBuf>,
    },
    ScrubFilter,
}

Variants

Run

Triage the issues, then work them in dependency order.

Fields

issues: Vec<i64>

Issue numbers. Omit to take every open issue, up to –limit.

common: Common

loop_flags: LoopFlags

triage_flags: TriageFlags

plan_out: PathBuf

Where to write the triage plan.

no_worktrees: bool

Work in the main checkout instead of an isolated worktree per issue.

Triage

Triage only. Writes the plan and touches nothing else.

Fields

issues: Vec<i64>

Issue numbers. Omit to take every open issue, up to –limit.

common: Common

plan_out: PathBuf

Resume

Continue the review loop on existing PRs, including ones spar did not create.

Fields

prs: Vec<i64>

Pull request numbers. Omit to take every open PR, up to –limit.

common: Common

loop_flags: LoopFlags

next_actor: Option<String>

Which agent reviews next, overriding the PR’s saved state.

Review

Review pull requests without changing them, including from a fork.

Both agents review independently, then rule on each other’s findings, then answer the objections. Nothing is committed, pushed, or merged.

Fields

items: Vec<i64>

Pull request numbers. An issue number resolves to its open PR. Omit to take every open PR, up to –limit.

common: Common

dry_run: bool

Print the review instead of posting it.

max_rounds: Option<u32>

Adjudication passes. 1 is two independent reviews with no cross-checking, 2 adds it, 3 adds a rebuttal on what they dispute.

Post

Post a review a dry run produced, without running the agents again.

spar review <pr> --dry-run saves what it produced. Read it, edit the file if you like, then post exactly that.

Fields

prs: Vec<i64>

Pull request numbers whose saved review should be posted.

repo: PathBuf

config: Option<PathBuf>

file: Option<PathBuf>

Post this file instead of the saved review.

dry_run: bool

Print what would be posted and stop.

Init

Detect installed agent CLIs and write a spar.toml.

On an existing config, --update appends any settings it does not mention, which is how to pick up options added by a newer release.

Fields

out: PathBuf

force: bool

Overwrite an existing config.

update: bool

Append settings the existing config does not mention, as comments. Nothing already in the file is changed.

Clean

Remove worktrees, branches, and state whose PR is merged or closed.

Fields

repo: PathBuf

config: Option<PathBuf>

all: bool

Remove every worktree and branch spar created, even for open PRs.

pr_state: bool

Also delete state comments left on finished PRs.

Doctor

Check prerequisites and resolve each configured agent.

Fields

config: Option<PathBuf>

ScrubFilter

Read a commit message on stdin and write the scrubbed version to stdout.

Used by git filter-branch, not by people.

Trait Implementations

impl Debug for Command

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

Formats the value using the given formatter.

impl FromArgMatches for Command

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 Command

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