Enum Command 

pub enum Command {
    Run {
        issues: Vec<i64>,
        common: Common,
        loop_flags: LoopFlags,
        triage_flags: TriageFlags,
        plan_out: PathBuf,
        no_worktrees: bool,
    },
    Followup {
        common: Common,
        loop_flags: LoopFlags,
        triage_flags: TriageFlags,
        file: Option<PathBuf>,
        screen_only: bool,
        file_only: bool,
        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>,
    },
    Checkin {
        items: Vec<i64>,
        common: Common,
        dry_run: bool,
        reply_only: bool,
        any_author: bool,
        again: bool,
        keep_worktrees: bool,
    },
    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.

Followup

Work the follow-ups recorded in .spar/followups.md.

One agent reads every entry against the current checkout and rules on it: still there, already fixed, not worth it, or a duplicate. What survives is filed as an issue and worked like any other, which means both agents still triage it before anything is implemented. An entry that was filed or dropped leaves the queue and is kept in .spar/followups.done.md.

Takes no numbers: an entry has no number a person could type. –limit caps how many are taken, and –min-number does nothing here.

Fields

common: Common

loop_flags: LoopFlags

triage_flags: TriageFlags

file: Option<PathBuf>

Read this instead of .spar/followups.md.

screen_only: bool

Print the verdicts and stop. Nothing is filed and no file is touched.

file_only: bool

File the issues and stop, leaving them for a later spar run.

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.

Checkin

Answer the comments on a pull request, and act on the ones worth acting on.

Reads every comment somebody else left that has not been answered. Both agents judge each one. A change they both agree is right and belongs here is made, pushed, answered in its own thread, and the thread marked resolved. One they both judge wrong gets the reason and the thread is left open for you. One they disagree about is parked.

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 every reply and every change instead of posting or pushing.

reply_only: bool

Answer in words only. Nothing is committed, pushed, or resolved.

any_author: bool

Act on a comment from anyone, not only from somebody who can write to this repository.

again: bool

Answer comments spar already answered, ignoring what it recorded.

keep_worktrees: bool

Leave worktrees in place afterwards, for inspection.

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