Enum ContinuityCommand 

pub enum ContinuityCommand {
    Status,
    Records,
    Device {
        label: Option<String>,
    },
    Plan {
        record: Option<String>,
    },
    Publish {
        handover: Option<String>,
        issue: Option<String>,
        milestone: Option<String>,
    },
    Sync {
        remote: Option<String>,
    },
    Resume {
        record: Option<String>,
    },
}

The subcommands of majordomus continuity: the command line of continuity.status, continuity.records, continuity.device, continuity.plan, continuity.publish, continuity.sync and continuity.resume.

use majordomus_cli::cli::{Cli, Command, ContinuityCommand};
use clap::Parser;
let cli = Cli::parse_from(["majordomus", "continuity", "publish", "--issue", "#184"]);
let Command::Continuity(args) = cli.command else { panic!("continuity") };
let ContinuityCommand::Publish { issue, handover, .. } = args.command else { panic!("publish") };
assert_eq!(issue.as_deref(), Some("#184"));
assert!(handover.is_none(), "the newest handover by default");

Variants

Status

This device, the record this checkout continues, the store against its remote (no network), every line of work, and what other devices published that could be resumed here

Records

Every published handover the local store admits, by line, and every file it refused

Device

This device’s identity — the mesh node key, created when absent — and its label; with –label, rename it

Fields

label: Option<String>

A label for this device (macbook-pro, mac-mini)

Plan

Decide, writing nothing, whether and how a published handover can be resumed here: trust, lineage, source compatibility, uncommitted work at the origin

Fields

record: Option<String>

A record id or a unique prefix; the one resumable handover when absent

Publish

Publish this checkout’s newest handover as a signed record for another machine; refused when it carries a secret or a machine path

Fields

handover: Option<String>

A handover record’s file name under .ai/local/state/handovers/; the newest when absent

issue: Option<String>

The issue the work belongs to

milestone: Option<String>

The milestone it belongs to

Sync

Exchange published handovers with a git remote: fetch, merge as a union, push; an unreachable remote leaves what is pending pending

Fields

remote: Option<String>

The git remote; the current branch’s, else origin, when absent

Resume

Resume a published handover when its plan is ready: write it into this checkout’s handovers, carry its decisions, and continue its line

Fields

record: Option<String>

A record id or a unique prefix; the one resumable handover when absent

Trait Implementations

impl Debug for ContinuityCommand

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

Formats the value using the given formatter.

impl FromArgMatches for ContinuityCommand

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 ContinuityCommand

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