Enum IntentCommand 

pub enum IntentCommand {
    List,
    Show {
        id: String,
    },
    Validate,
    Coverage,
    Preflight {
        issue: Option<String>,
        paths: Vec<String>,
    },
    Binding {
        issue: Option<String>,
        intent: Option<String>,
        paths: Vec<String>,
        exempt: Option<String>,
        because: Option<String>,
    },
    Realization {
        intent: Option<String>,
    },
    Explain {
        id: String,
    },
    Propose {
        statement: String,
        title: Option<String>,
        id: Option<String>,
    },
}

The subcommands of majordomus intent: the command line of intents.list, intents.record, intents.validate and intents.preflight.

use majordomus_cli::cli::{Cli, Command, IntentCommand};
use clap::Parser;
let cli = Cli::parse_from(["majordomus", "intent", "show", "intent-lifecycle"]);
let Command::Intent(args) = cli.command else { panic!("intent") };
let IntentCommand::Show { id } = args.command else { panic!("show") };
assert_eq!(id, "intent-lifecycle");

Variants

List

Every intent, with the stage derived from its milestones and its evidence

Show

One intent in full: each milestone’s derived status and each criterion’s evidence state

Fields

id: String

The intent’s id, which is also its file name

Validate

Every finding over the intents; exit 10 when any is a failure

Coverage

Which work carries which criterion, and the reason every issue exists

Preflight

Which intent the work on an issue, or on some paths, serves, whether it is maintenance, or why it may not proceed; exit 10 when refused

Fields

issue: Option<String>

The issue the work executes

paths: Vec<String>

A path the work will touch; repeat for each

Binding

What a piece of work is bound to before it starts: the issue, the intent or the paths it names resolved to the criteria it serves, or an exemption the policy declares, with the two pins a resumed worker compares; exit 10 when refused

Fields

issue: Option<String>

The issue the work executes

intent: Option<String>

The intent the work serves, named directly

paths: Vec<String>

A path the work will touch; repeat for each

exempt: Option<String>

An exemption class the policy declares under intent.exemptions

because: Option<String>

Why the exemption applies

Realization

Which work realises which intent — tasks, episodes, providers, handovers, peer claims — each link with its provenance, and each intent’s unmet criteria and drift; exit 10 when an intent whose milestones are all DONE is contradicted by its evidence

Fields

intent: Option<String>

Only this intent and the work linked to it

Explain

Why an intent stands where it stands: its stage, each criterion, the work realising it

Fields

id: String

The intent’s id

Propose

Write a new, unplanned intent: what must become true (ADR 0144)

Fields

statement: String

What must become true, kept verbatim

title: Option<String>

One line naming it; the statement’s first line when absent

id: Option<String>

The identity and file name; the title’s slug when absent

Trait Implementations

impl Debug for IntentCommand

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

Formats the value using the given formatter.

impl FromArgMatches for IntentCommand

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 IntentCommand

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