ecd8981 cli/patch: migrate patch CLI parsing to clap — heartwood

Radicle Heartwood Protocol & Stack

cli/patch: migrate patch CLI parsing to clap

Matthias Beyer committed 6 months ago

commit ecd89817d103727b3a0d4d8cfaa1b2c6ab9113a7
parent 69971971b9a753d9e3ee99605496514a169b1c8a

6 files changed +938 -959

modified crates/radicle-cli/src/commands/help.rs

@@ -94,7 +94,10 @@ const COMMANDS: &[CommandItem] = &[

         name: "node",
         about: crate::commands::node::ABOUT,
     },
     CommandItem::Lexopt(crate::commands::patch::HELP),
     CommandItem::Clap {
         name: "patch",
         about: crate::commands::patch::ABOUT,
     },
     CommandItem::Clap {
         name: "path",
         about: crate::commands::path::ABOUT,

modified crates/radicle-cli/src/commands/patch.rs

@@ -1,4 +1,5 @@

 mod archive;
 mod args;
 mod assign;
 mod cache;
 mod checkout;

@@ -17,14 +18,11 @@ mod show;

 mod update;
 use std::collections::BTreeSet;
 use std::ffi::OsString;
 use std::str::FromStr as _;
 use anyhow::anyhow;
 use radicle::cob::patch::PatchId;
 use radicle::cob::{patch, Label, Reaction};
 use radicle::git::fmt::RefString;
 use radicle::cob::{patch, Label};
 use radicle::patch::cache::Patches as _;
 use radicle::storage::git::transport;
 use radicle::{prelude::*, Node};

@@ -32,811 +30,15 @@ use radicle::{prelude::*, Node};

 use crate::git::Rev;
 use crate::node;
 use crate::terminal as term;
 use crate::terminal::args::{string, Args, Error, Help};
 use crate::terminal::patch::Message;
 pub const HELP: Help = Help {
     name: "patch",
     description: "Manage patches",
     version: env!("RADICLE_VERSION"),
     usage: r#"
 Usage
 pub use args::Args;
 pub(crate) use args::ABOUT;
     rad patch [<option>...]
     rad patch list [--all|--merged|--open|--archived|--draft|--authored] [--author <did>]... [<option>...]
     rad patch show <patch-id> [<option>...]
     rad patch diff <patch-id> [<option>...]
     rad patch archive <patch-id> [--undo] [<option>...]
     rad patch update <patch-id> [<option>...]
     rad patch checkout <patch-id> [<option>...]
     rad patch review <patch-id> [--accept | --reject] [-m [<string>]] [-d | --delete] [<option>...]
     rad patch resolve <patch-id> [--review <review-id>] [--comment <comment-id>] [--unresolve] [<option>...]
     rad patch delete <patch-id> [<option>...]
     rad patch redact <revision-id> [<option>...]
     rad patch react <patch-id | revision-id> [--react <emoji>] [<option>...]
     rad patch assign <revision-id> [--add <did>] [--delete <did>] [<option>...]
     rad patch label <revision-id> [--add <label>] [--delete <label>] [<option>...]
     rad patch ready <patch-id> [--undo] [<option>...]
     rad patch edit <patch-id> [<option>...]
     rad patch set <patch-id> [<option>...]
     rad patch comment <patch-id | revision-id> [<option>...]
     rad patch cache [<patch-id>] [--storage] [<option>...]
 use args::{AssignArgs, Command, CommentAction, LabelArgs};
 Show options
     -p, --patch                Show the actual patch diff
     -v, --verbose              Show additional information about the patch
 Diff options
     -r, --revision <id>        The revision to diff (default: latest)
 Comment options
     -m, --message <string>     Provide a comment message via the command-line
         --reply-to <comment>   The comment to reply to
         --edit <comment>       The comment to edit (use --message to edit with the provided message)
         --react <comment>      The comment to react to
         --emoji <char>         The emoji to react with when --react is used
         --redact <comment>     The comment to redact
 Edit options
     -m, --message [<string>]   Provide a comment message to the patch or revision (default: prompt)
 Review options
     -r, --revision <id>        Review the given revision of the patch
     -p, --patch                Review by patch hunks
         --hunk <index>         Only review a specific hunk
         --accept               Accept a patch or set of hunks
         --reject               Reject a patch or set of hunks
     -U, --unified <n>          Generate diffs with <n> lines of context instead of the usual three
     -d, --delete               Delete a review draft
     -m, --message [<string>]   Provide a comment with the review (default: prompt)
 Resolve options
     --review <id>              The review id which the comment is under
     --comment <id>             The comment to (un)resolve
     --undo                     Unresolve the comment
 Assign options
     -a, --add    <did>         Add an assignee to the patch (may be specified multiple times).
                                Note: --add will take precedence over --delete
     -d, --delete <did>         Delete an assignee from the patch (may be specified multiple times).
                                Note: --add will take precedence over --delete
 Archive options
         --undo                 Unarchive a patch
 Label options
     -a, --add    <label>       Add a label to the patch (may be specified multiple times).
                                Note: --add will take precedence over --delete
     -d, --delete <label>       Delete a label from the patch (may be specified multiple times).
                                Note: --add will take precedence over --delete
 Update options
     -b, --base <revspec>       Provide a Git revision as the base commit
     -m, --message [<string>]   Provide a comment message to the patch or revision (default: prompt)
         --no-message           Leave the patch or revision comment message blank
 List options
         --all                  Show all patches, including merged and archived patches
         --archived             Show only archived patches
         --merged               Show only merged patches
         --open                 Show only open patches (default)
         --draft                Show only draft patches
         --authored             Show only patches that you have authored
         --author <did>         Show only patched where the given user is an author
                                (may be specified multiple times)
 Ready options
         --undo                 Convert a patch back to a draft
 Checkout options
         --revision <id>        Checkout the given revision of the patch
         --name <string>        Provide a name for the branch to checkout
         --remote <string>      Provide the git remote to use as the upstream
     -f, --force                Checkout the head of the revision, even if the branch already exists
 Set options
         --remote <string>      Provide the git remote to use as the upstream
 React options
         --emoji <char>         The emoji to react to the patch or revision with
 Other options
         --repo <rid>           Operate on the given repository (default: cwd)
         --[no-]announce        Announce changes made to the network
     -q, --quiet                Quiet output
         --help                 Print help
 "#,
 };
 #[derive(Debug, Default, PartialEq, Eq)]
 pub enum OperationName {
     Assign,
     Show,
     Diff,
     Update,
     Archive,
     Delete,
     Checkout,
     Comment,
     React,
     Ready,
     Review,
     Resolve,
     Label,
     #[default]
     List,
     Edit,
     Redact,
     Set,
     Cache,
 }
 #[derive(Debug, PartialEq, Eq)]
 pub enum CommentOperation {
     Edit,
     React,
     Redact,
 }
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct AssignOptions {
     pub add: BTreeSet<Did>,
     pub delete: BTreeSet<Did>,
 }
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct LabelOptions {
     pub add: BTreeSet<Label>,
     pub delete: BTreeSet<Label>,
 }
 #[derive(Debug)]
 pub enum Operation {
     Show {
         patch_id: Rev,
         diff: bool,
         verbose: bool,
     },
     Diff {
         patch_id: Rev,
         revision_id: Option<Rev>,
     },
     Update {
         patch_id: Rev,
         base_id: Option<Rev>,
         message: Message,
     },
     Archive {
         patch_id: Rev,
         undo: bool,
     },
     Ready {
         patch_id: Rev,
         undo: bool,
     },
     Delete {
         patch_id: Rev,
     },
     Checkout {
         patch_id: Rev,
         revision_id: Option<Rev>,
         opts: checkout::Options,
     },
     Comment {
         revision_id: Rev,
         message: Message,
         reply_to: Option<Rev>,
     },
     CommentEdit {
         revision_id: Rev,
         comment_id: Rev,
         message: Message,
     },
     CommentRedact {
         revision_id: Rev,
         comment_id: Rev,
     },
     CommentReact {
         revision_id: Rev,
         comment_id: Rev,
         reaction: Reaction,
         undo: bool,
     },
     React {
         revision_id: Rev,
         reaction: Reaction,
         undo: bool,
     },
     Review {
         patch_id: Rev,
         revision_id: Option<Rev>,
         opts: review::Options,
     },
     Resolve {
         patch_id: Rev,
         review_id: Rev,
         comment_id: Rev,
         undo: bool,
     },
     Assign {
         patch_id: Rev,
         opts: AssignOptions,
     },
     Label {
         patch_id: Rev,
         opts: LabelOptions,
     },
     List {
         filter: Option<patch::Status>,
     },
     Edit {
         patch_id: Rev,
         revision_id: Option<Rev>,
         message: Message,
     },
     Redact {
         revision_id: Rev,
     },
     Set {
         patch_id: Rev,
         remote: Option<RefString>,
     },
     Cache {
         patch_id: Option<Rev>,
         storage: bool,
     },
 }
 impl Operation {
     fn is_announce(&self) -> bool {
         match self {
             Operation::Update { .. }
             | Operation::Archive { .. }
             | Operation::Ready { .. }
             | Operation::Delete { .. }
             | Operation::Comment { .. }
             | Operation::CommentEdit { .. }
             | Operation::CommentRedact { .. }
             | Operation::CommentReact { .. }
             | Operation::Review { .. }
             | Operation::Resolve { .. }
             | Operation::Assign { .. }
             | Operation::Label { .. }
             | Operation::Edit { .. }
             | Operation::Redact { .. }
             | Operation::React { .. }
             | Operation::Set { .. } => true,
             Operation::Show { .. }
             | Operation::Diff { .. }
             | Operation::Checkout { .. }
             | Operation::List { .. }
             | Operation::Cache { .. } => false,
         }
     }
 }
 #[derive(Debug)]
 pub struct Options {
     pub op: Operation,
     pub repo: Option<RepoId>,
     pub announce: bool,
     pub quiet: bool,
     pub authored: bool,
     pub authors: Vec<Did>,
 }
 impl Args for Options {
     fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {
         use lexopt::prelude::*;
         let mut parser = lexopt::Parser::from_args(args);
         let mut op: Option<OperationName> = None;
         let mut verbose = false;
         let mut quiet = false;
         let mut authored = false;
         let mut authors = vec![];
         let mut announce = true;
         let mut patch_id = None;
         let mut revision_id = None;
         let mut review_id = None;
         let mut comment_id = None;
         let mut message = Message::default();
         let mut filter = Some(patch::Status::Open);
         let mut diff = false;
         let mut undo = false;
         let mut reaction: Option<Reaction> = None;
         let mut reply_to: Option<Rev> = None;
         let mut comment_op: Option<(CommentOperation, Rev)> = None;
         let mut checkout_opts = checkout::Options::default();
         let mut remote: Option<RefString> = None;
         let mut assign_opts = AssignOptions::default();
         let mut label_opts = LabelOptions::default();
         let mut review_op = review::Operation::default();
         let mut base_id = None;
         let mut repo = None;
         let mut cache_storage = false;
         while let Some(arg) = parser.next()? {
             match arg {
                 // Options.
                 Long("message") | Short('m') => {
                     if message != Message::Blank {
                         // We skip this code when `no-message` is specified.
                         let txt: String = term::args::string(&parser.value()?);
                         message.append(&txt);
                     }
                 }
                 Long("no-message") => {
                     message = Message::Blank;
                 }
                 Long("announce") => {
                     announce = true;
                 }
                 Long("no-announce") => {
                     announce = false;
                 }
                 // Show options.
                 Long("patch") | Short('p') if op == Some(OperationName::Show) => {
                     diff = true;
                 }
                 Long("verbose") | Short('v') if op == Some(OperationName::Show) => {
                     verbose = true;
                 }
                 // Ready options.
                 Long("undo") if op == Some(OperationName::Ready) => {
                     undo = true;
                 }
                 // Archive options.
                 Long("undo") if op == Some(OperationName::Archive) => {
                     undo = true;
                 }
                 // Update options.
                 Short('b') | Long("base") if op == Some(OperationName::Update) => {
                     let val = parser.value()?;
                     let rev = term::args::rev(&val)?;
                     base_id = Some(rev);
                 }
                 // React options.
                 Long("emoji") if op == Some(OperationName::React) => {
                     if let Some(emoji) = parser.value()?.to_str() {
                         reaction =
                             Some(Reaction::from_str(emoji).map_err(|_| anyhow!("invalid emoji"))?);
                     }
                 }
                 Long("undo") if op == Some(OperationName::React) => {
                     undo = true;
                 }
                 // Comment options.
                 Long("reply-to") if op == Some(OperationName::Comment) => {
                     let val = parser.value()?;
                     let rev = term::args::rev(&val)?;
                     reply_to = Some(rev);
                 }
                 Long("edit") if op == Some(OperationName::Comment) => {
                     let val = parser.value()?;
                     let rev = term::args::rev(&val)?;
                     comment_op = Some((CommentOperation::Edit, rev));
                 }
                 Long("react") if op == Some(OperationName::Comment) => {
                     let val = parser.value()?;
                     let rev = term::args::rev(&val)?;
                     comment_op = Some((CommentOperation::React, rev));
                 }
                 Long("emoji")
                     if op == Some(OperationName::Comment)
                         && matches!(comment_op, Some((CommentOperation::React, _))) =>
                 {
                     if let Some(emoji) = parser.value()?.to_str() {
                         reaction =
                             Some(Reaction::from_str(emoji).map_err(|_| anyhow!("invalid emoji"))?);
                     }
                 }
                 Long("undo")
                     if op == Some(OperationName::Comment)
                         && matches!(comment_op, Some((CommentOperation::React, _))) =>
                 {
                     undo = true;
                 }
                 Long("redact") if op == Some(OperationName::Comment) => {
                     let val = parser.value()?;
                     let rev = term::args::rev(&val)?;
                     comment_op = Some((CommentOperation::Redact, rev));
                 }
                 // Edit options.
                 Long("revision") | Short('r') if op == Some(OperationName::Edit) => {
                     let val = parser.value()?;
                     let rev = term::args::rev(&val)?;
                     revision_id = Some(rev);
                 }
                 // Review/diff options.
                 Long("revision") | Short('r')
                     if op == Some(OperationName::Review) || op == Some(OperationName::Diff) =>
                 {
                     let val = parser.value()?;
                     let rev = term::args::rev(&val)?;
                     revision_id = Some(rev);
                 }
                 Long("patch") | Short('p') if op == Some(OperationName::Review) => {
                     if let review::Operation::Review { by_hunk, .. } = &mut review_op {
                         *by_hunk = true;
                     } else {
                         return Err(arg.unexpected().into());
                     }
                 }
                 Long("unified") | Short('U') if op == Some(OperationName::Review) => {
                     if let review::Operation::Review { unified, .. } = &mut review_op {
                         let val = parser.value()?;
                         *unified = term::args::number(&val)?;
                     } else {
                         return Err(arg.unexpected().into());
                     }
                 }
                 Long("hunk") if op == Some(OperationName::Review) => {
                     if let review::Operation::Review { hunk, .. } = &mut review_op {
                         let val = parser.value()?;
                         let val = term::args::number(&val)
                             .map_err(|e| anyhow!("invalid hunk value: {e}"))?;
                         *hunk = Some(val);
                     } else {
                         return Err(arg.unexpected().into());
                     }
                 }
                 Long("delete") | Short('d') if op == Some(OperationName::Review) => {
                     review_op = review::Operation::Delete;
                 }
                 Long("accept") if op == Some(OperationName::Review) => {
                     if let review::Operation::Review {
                         verdict: verdict @ None,
                         ..
                     } = &mut review_op
                     {
                         *verdict = Some(patch::Verdict::Accept);
                     } else {
                         return Err(arg.unexpected().into());
                     }
                 }
                 Long("reject") if op == Some(OperationName::Review) => {
                     if let review::Operation::Review {
                         verdict: verdict @ None,
                         ..
                     } = &mut review_op
                     {
                         *verdict = Some(patch::Verdict::Reject);
                     } else {
                         return Err(arg.unexpected().into());
                     }
                 }
                 // Resolve options
                 Long("undo") if op == Some(OperationName::Resolve) => {
                     undo = true;
                 }
                 Long("review") if op == Some(OperationName::Resolve) => {
                     let val = parser.value()?;
                     let rev = term::args::rev(&val)?;
                     review_id = Some(rev);
                 }
                 Long("comment") if op == Some(OperationName::Resolve) => {
                     let val = parser.value()?;
                     let rev = term::args::rev(&val)?;
                     comment_id = Some(rev);
                 }
                 // Checkout options
                 Long("revision") if op == Some(OperationName::Checkout) => {
                     let val = parser.value()?;
                     let rev = term::args::rev(&val)?;
                     revision_id = Some(rev);
                 }
                 Long("force") | Short('f') if op == Some(OperationName::Checkout) => {
                     checkout_opts.force = true;
                 }
                 Long("name") if op == Some(OperationName::Checkout) => {
                     let val = parser.value()?;
                     checkout_opts.name = Some(term::args::refstring("name", val)?);
                 }
                 Long("remote") if op == Some(OperationName::Checkout) => {
                     let val = parser.value()?;
                     checkout_opts.remote = Some(term::args::refstring("remote", val)?);
                 }
                 // Assign options.
                 Short('a') | Long("add") if matches!(op, Some(OperationName::Assign)) => {
                     assign_opts.add.insert(term::args::did(&parser.value()?)?);
                 }
                 Short('d') | Long("delete") if matches!(op, Some(OperationName::Assign)) => {
                     assign_opts
                         .delete
                         .insert(term::args::did(&parser.value()?)?);
                 }
                 // Label options.
                 Short('a') | Long("add") if matches!(op, Some(OperationName::Label)) => {
                     let val = parser.value()?;
                     let name = term::args::string(&val);
                     let label = Label::new(name)?;
                     label_opts.add.insert(label);
                 }
                 Short('d') | Long("delete") if matches!(op, Some(OperationName::Label)) => {
                     let val = parser.value()?;
                     let name = term::args::string(&val);
                     let label = Label::new(name)?;
                     label_opts.delete.insert(label);
                 }
                 // Set options.
                 Long("remote") if op == Some(OperationName::Set) => {
                     let val = parser.value()?;
                     remote = Some(term::args::refstring("remote", val)?);
                 }
                 // List options.
                 Long("all") => {
                     filter = None;
                 }
                 Long("draft") => {
                     filter = Some(patch::Status::Draft);
                 }
                 Long("archived") => {
                     filter = Some(patch::Status::Archived);
                 }
                 Long("merged") => {
                     filter = Some(patch::Status::Merged);
                 }
                 Long("open") => {
                     filter = Some(patch::Status::Open);
                 }
                 Long("authored") => {
                     authored = true;
                 }
                 Long("author") if op == Some(OperationName::List) => {
                     authors.push(term::args::did(&parser.value()?)?);
                 }
                 // Cache options.
                 Long("storage") if op == Some(OperationName::Cache) => {
                     cache_storage = true;
                 }
                 // Common.
                 Long("quiet") | Short('q') => {
                     quiet = true;
                 }
                 Long("repo") => {
                     let val = parser.value()?;
                     let rid = term::args::rid(&val)?;
                     repo = Some(rid);
                 }
                 Long("help") => {
                     return Err(Error::HelpManual { name: "rad-patch" }.into());
                 }
                 Short('h') => {
                     return Err(Error::Help.into());
                 }
                 Value(val) if op.is_none() => match val.to_string_lossy().as_ref() {
                     "l" | "list" => op = Some(OperationName::List),
                     "s" | "show" => op = Some(OperationName::Show),
                     "u" | "update" => op = Some(OperationName::Update),
                     "d" | "delete" => op = Some(OperationName::Delete),
                     "c" | "checkout" => op = Some(OperationName::Checkout),
                     "a" | "archive" => op = Some(OperationName::Archive),
                     "y" | "ready" => op = Some(OperationName::Ready),
                     "e" | "edit" => op = Some(OperationName::Edit),
                     "r" | "redact" => op = Some(OperationName::Redact),
                     "diff" => op = Some(OperationName::Diff),
                     "assign" => op = Some(OperationName::Assign),
                     "label" => op = Some(OperationName::Label),
                     "comment" => op = Some(OperationName::Comment),
                     "review" => op = Some(OperationName::Review),
                     "resolve" => op = Some(OperationName::Resolve),
                     "set" => op = Some(OperationName::Set),
                     "cache" => op = Some(OperationName::Cache),
                     unknown => anyhow::bail!("unknown operation '{}'", unknown),
                 },
                 Value(val) if op == Some(OperationName::Redact) => {
                     let rev = term::args::rev(&val)?;
                     revision_id = Some(rev);
                 }
                 Value(val)
                     if patch_id.is_none()
                         && [
                             Some(OperationName::Show),
                             Some(OperationName::Diff),
                             Some(OperationName::Update),
                             Some(OperationName::Delete),
                             Some(OperationName::Archive),
                             Some(OperationName::Ready),
                             Some(OperationName::Checkout),
                             Some(OperationName::Comment),
                             Some(OperationName::Review),
                             Some(OperationName::Resolve),
                             Some(OperationName::Edit),
                             Some(OperationName::Set),
                             Some(OperationName::Assign),
                             Some(OperationName::Label),
                             Some(OperationName::Cache),
                         ]
                         .contains(&op) =>
                 {
                     let val = string(&val);
                     patch_id = Some(Rev::from(val));
                 }
                 _ => anyhow::bail!(arg.unexpected()),
             }
         }
         let op = match op.unwrap_or_default() {
             OperationName::List => Operation::List { filter },
             OperationName::Show => Operation::Show {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
                 diff,
                 verbose,
             },
             OperationName::Diff => Operation::Diff {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
                 revision_id,
             },
             OperationName::Delete => Operation::Delete {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
             },
             OperationName::Update => Operation::Update {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
                 base_id,
                 message,
             },
             OperationName::Archive => Operation::Archive {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch id must be provided"))?,
                 undo,
             },
             OperationName::Checkout => Operation::Checkout {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
                 revision_id,
                 opts: checkout_opts,
             },
             OperationName::Comment => match comment_op {
                 Some((CommentOperation::Edit, comment)) => Operation::CommentEdit {
                     revision_id: patch_id
                         .ok_or_else(|| anyhow!("a patch or revision must be provided"))?,
                     comment_id: comment,
                     message,
                 },
                 Some((CommentOperation::React, comment)) => Operation::CommentReact {
                     revision_id: patch_id
                         .ok_or_else(|| anyhow!("a patch or revision must be provided"))?,
                     comment_id: comment,
                     reaction: reaction
                         .ok_or_else(|| anyhow!("a reaction emoji must be provided"))?,
                     undo,
                 },
                 Some((CommentOperation::Redact, comment)) => Operation::CommentRedact {
                     revision_id: patch_id
                         .ok_or_else(|| anyhow!("a patch or revision must be provided"))?,
                     comment_id: comment,
                 },
                 None => Operation::Comment {
                     revision_id: patch_id
                         .ok_or_else(|| anyhow!("a patch or revision must be provided"))?,
                     message,
                     reply_to,
                 },
             },
             OperationName::React => Operation::React {
                 revision_id: patch_id
                     .ok_or_else(|| anyhow!("a patch or revision must be provided"))?,
                 reaction: reaction.ok_or_else(|| anyhow!("a reaction emoji must be provided"))?,
                 undo,
             },
             OperationName::Review => Operation::Review {
                 patch_id: patch_id
                     .ok_or_else(|| anyhow!("a patch or revision must be provided"))?,
                 revision_id,
                 opts: review::Options {
                     message,
                     op: review_op,
                 },
             },
             OperationName::Resolve => Operation::Resolve {
                 patch_id: patch_id
                     .ok_or_else(|| anyhow!("a patch or revision must be provided"))?,
                 review_id: review_id.ok_or_else(|| anyhow!("a review must be provided"))?,
                 comment_id: comment_id.ok_or_else(|| anyhow!("a comment must be provided"))?,
                 undo,
             },
             OperationName::Ready => Operation::Ready {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
                 undo,
             },
             OperationName::Edit => Operation::Edit {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
                 revision_id,
                 message,
             },
             OperationName::Redact => Operation::Redact {
                 revision_id: revision_id.ok_or_else(|| anyhow!("a revision must be provided"))?,
             },
             OperationName::Assign => Operation::Assign {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
                 opts: assign_opts,
             },
             OperationName::Label => Operation::Label {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
                 opts: label_opts,
             },
             OperationName::Set => Operation::Set {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
                 remote,
             },
             OperationName::Cache => Operation::Cache {
                 patch_id,
                 storage: cache_storage,
             },
         };
         Ok((
             Options {
                 op,
                 repo,
                 quiet,
                 announce,
                 authored,
                 authors,
             },
             vec![],
         ))
     }
 }
 pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
     let (workdir, rid) = if let Some(rid) = options.repo {
 pub fn run(args: Args, ctx: impl term::Context) -> anyhow::Result<()> {
     let (workdir, rid) = if let Some(rid) = args.repo {
         (None, rid)
     } else {
         radicle::rad::cwd()

@@ -846,51 +48,51 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

     let profile = ctx.profile()?;
     let repository = profile.storage.repository(rid)?;
     let announce = options.announce && options.op.is_announce();
     // Fallback to [`Command::List`] if no subcommand is provided.
     // Construct it using the [`EmptyArgs`] in `args.empty`.
     let mut announce = args.should_announce();
     let command = args
         .command
         .unwrap_or_else(|| Command::List(args.empty.into()));
     announce &= command.should_announce();
     transport::local::register(profile.storage.clone());
     match options.op {
         Operation::List { filter } => {
             let mut authors: BTreeSet<Did> = options.authors.iter().cloned().collect();
             if options.authored {
     match command {
         Command::List(args) => {
             let mut authors: BTreeSet<Did> = args.authors.iter().cloned().collect();
             if args.authored {
                 authors.insert(profile.did());
             }
             list::run(filter.as_ref(), authors, &repository, &profile)?;
             list::run((&args.state).into(), authors, &repository, &profile)?;
         }
         Operation::Show {
             patch_id,
             diff,
             verbose,
         } => {
             let patch_id = patch_id.resolve(&repository.backend)?;
         Command::Show { id, patch, verbose } => {
             let patch_id = id.resolve(&repository.backend)?;
             show::run(
                 &patch_id,
                 diff,
                 patch,
                 verbose,
                 &profile,
                 &repository,
                 workdir.as_ref(),
             )?;
         }
         Operation::Diff {
             patch_id,
             revision_id,
         } => {
             let patch_id = patch_id.resolve(&repository.backend)?;
             let revision_id = revision_id
         Command::Diff { id, revision } => {
             let patch_id = id.resolve(&repository.backend)?;
             let revision_id = revision
                 .map(|rev| rev.resolve::<radicle::git::Oid>(&repository.backend))
                 .transpose()?
                 .map(patch::RevisionId::from);
             diff::run(&patch_id, revision_id, &repository, &profile)?;
         }
         Operation::Update {
             ref patch_id,
             ref base_id,
             ref message,
         } => {
             let patch_id = patch_id.resolve(&repository.backend)?;
             let base_id = base_id
         Command::Update { id, base, message } => {
             let message = Message::from(message);
             let patch_id = id.resolve(&repository.backend)?;
             let base_id = base
                 .as_ref()
                 .map(|base| base.resolve(&repository.backend))
                 .transpose()?;

@@ -898,21 +100,16 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

                 "this command must be run from a repository checkout"
             ))?;
             update::run(
                 patch_id,
                 base_id,
                 message.clone(),
                 &profile,
                 &repository,
                 &workdir,
             )?;
             update::run(patch_id, base_id, message, &profile, &repository, &workdir)?;
         }
         Operation::Archive { ref patch_id, undo } => {
             let patch_id = patch_id.resolve::<PatchId>(&repository.backend)?;
         Command::Archive { id, undo } => {
             let patch_id = id.resolve::<PatchId>(&repository.backend)?;
             archive::run(&patch_id, undo, &profile, &repository)?;
         }
         Operation::Ready { ref patch_id, undo } => {
             let patch_id = patch_id.resolve::<PatchId>(&repository.backend)?;
         Command::Ready { id, undo } => {
             let patch_id = id.resolve::<PatchId>(&repository.backend)?;
             if !ready::run(&patch_id, undo, &profile, &repository)? {
                 if undo {

@@ -922,17 +119,15 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

                 }
             }
         }
         Operation::Delete { patch_id } => {
             let patch_id = patch_id.resolve::<PatchId>(&repository.backend)?;
         Command::Delete { id } => {
             let patch_id = id.resolve::<PatchId>(&repository.backend)?;
             delete::run(&patch_id, &profile, &repository)?;
         }
         Operation::Checkout {
             patch_id,
             revision_id,
             opts,
         } => {
             let patch_id = patch_id.resolve::<radicle::git::Oid>(&repository.backend)?;
             let revision_id = revision_id
         Command::Checkout { id, revision, opts } => {
             let patch_id = id.resolve::<radicle::git::Oid>(&repository.backend)?;
             let revision_id = revision
                 .map(|rev| rev.resolve::<radicle::git::Oid>(&repository.backend))
                 .transpose()?
                 .map(patch::RevisionId::from);

@@ -945,121 +140,136 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

                 &repository,
                 &workdir,
                 &profile,
                 opts,
                 opts.into(),
             )?;
         }
         Operation::Comment {
             revision_id,
             message,
             reply_to,
         } => {
             comment::run(
                 revision_id,
         Command::Comment(c) => match CommentAction::from(c) {
             CommentAction::Comment {
                 revision,
                 message,
                 reply_to,
                 options.quiet,
                 &repository,
                 &profile,
             )?;
         }
         Operation::CommentEdit {
             revision_id,
             comment_id,
             message,
         } => {
             let comment = comment_id.resolve(&repository.backend)?;
             comment::edit::run(
                 revision_id,
             } => {
                 comment::run(
                     revision,
                     message,
                     reply_to,
                     args.quiet,
                     &repository,
                     &profile,
                 )?;
             }
             CommentAction::Edit {
                 revision,
                 comment,
                 message,
                 options.quiet,
                 &repository,
                 &profile,
             )?;
         }
         Operation::CommentRedact {
             revision_id,
             comment_id,
         } => {
             let comment = comment_id.resolve(&repository.backend)?;
             comment::redact::run(revision_id, comment, &repository, &profile)?;
         }
         Operation::CommentReact {
             revision_id,
             comment_id,
             reaction,
             undo,
         } => {
             let comment = comment_id.resolve(&repository.backend)?;
             if undo {
                 comment::react::run(revision_id, comment, reaction, false, &repository, &profile)?;
             } else {
                 comment::react::run(revision_id, comment, reaction, true, &repository, &profile)?;
             } => {
                 let comment = comment.resolve(&repository.backend)?;
                 comment::edit::run(
                     revision,
                     comment,
                     message,
                     args.quiet,
                     &repository,
                     &profile,
                 )?;
             }
         }
         Operation::Review {
             patch_id,
             revision_id,
             opts,
             CommentAction::Redact { revision, comment } => {
                 let comment = comment.resolve(&repository.backend)?;
                 comment::redact::run(revision, comment, &repository, &profile)?;
             }
             CommentAction::React {
                 revision,
                 comment,
                 emoji,
                 undo,
             } => {
                 let comment = comment.resolve(&repository.backend)?;
                 if undo {
                     comment::react::run(revision, comment, emoji, false, &repository, &profile)?;
                 } else {
                     comment::react::run(revision, comment, emoji, true, &repository, &profile)?;
                 }
             }
         },
         Command::Review {
             id,
             revision,
             options,
         } => {
             let patch_id = patch_id.resolve(&repository.backend)?;
             let revision_id = revision_id
             let patch_id = id.resolve(&repository.backend)?;
             let revision_id = revision
                 .map(|rev| rev.resolve::<radicle::git::Oid>(&repository.backend))
                 .transpose()?
                 .map(patch::RevisionId::from);
             review::run(patch_id, revision_id, opts, &profile, &repository)?;
             review::run(patch_id, revision_id, options.into(), &profile, &repository)?;
         }
         Operation::Resolve {
             ref patch_id,
             ref review_id,
             ref comment_id,
             undo,
         Command::Resolve {
             id,
             review,
             comment,
             unresolve,
         } => {
             let patch = patch_id.resolve(&repository.backend)?;
             let patch = id.resolve(&repository.backend)?;
             let review = patch::ReviewId::from(
                 review_id.resolve::<radicle::cob::EntryId>(&repository.backend)?,
                 review.resolve::<radicle::cob::EntryId>(&repository.backend)?,
             );
             let comment = comment_id.resolve(&repository.backend)?;
             if undo {
             let comment = comment.resolve(&repository.backend)?;
             if unresolve {
                 resolve::unresolve(patch, review, comment, &repository, &profile)?;
                 term::success!("Unresolved comment {comment_id}");
                 term::success!("Unresolved comment {comment}");
             } else {
                 resolve::resolve(patch, review, comment, &repository, &profile)?;
                 term::success!("Resolved comment {comment_id}");
                 term::success!("Resolved comment {comment}");
             }
         }
         Operation::Edit {
             patch_id,
             revision_id,
         Command::Edit {
             id,
             revision,
             message,
         } => {
             let patch_id = patch_id.resolve(&repository.backend)?;
             let revision_id = revision_id
             let message = Message::from(message);
             let patch_id = id.resolve(&repository.backend)?;
             let revision_id = revision
                 .map(|id| id.resolve::<radicle::git::Oid>(&repository.backend))
                 .transpose()?
                 .map(patch::RevisionId::from);
             edit::run(&patch_id, revision_id, message, &profile, &repository)?;
         }
         Operation::Redact { revision_id } => {
             redact::run(&revision_id, &profile, &repository)?;
         Command::Redact { id } => {
             redact::run(&id, &profile, &repository)?;
         }
         Operation::Assign {
             patch_id,
             opts: AssignOptions { add, delete },
         Command::Assign {
             id,
             args: AssignArgs { add, delete },
         } => {
             let patch_id = patch_id.resolve(&repository.backend)?;
             assign::run(&patch_id, add, delete, &profile, &repository)?;
             let patch_id = id.resolve(&repository.backend)?;
             assign::run(
                 &patch_id,
                 add.into_iter().collect(),
                 delete.into_iter().collect(),
                 &profile,
                 &repository,
             )?;
         }
         Operation::Label {
             patch_id,
             opts: LabelOptions { add, delete },
         Command::Label {
             id,
             args: LabelArgs { add, delete },
         } => {
             let patch_id = patch_id.resolve(&repository.backend)?;
             label::run(&patch_id, add, delete, &profile, &repository)?;
             let patch_id = id.resolve(&repository.backend)?;
             label::run(
                 &patch_id,
                 add.into_iter().collect(),
                 delete.into_iter().collect(),
                 &profile,
                 &repository,
             )?;
         }
         Operation::Set { patch_id, remote } => {
         Command::Set { id, remote } => {
             let patches = term::cob::patches(&profile, &repository)?;
             let patch_id = patch_id.resolve(&repository.backend)?;
             let patch_id = id.resolve(&repository.backend)?;
             let patch = patches
                 .get(&patch_id)?
                 .ok_or_else(|| anyhow!("patch {patch_id} not found"))?;

@@ -1074,13 +284,11 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

                 true,
             )?;
         }
         Operation::Cache { patch_id, storage } => {
         Command::Cache { id, storage } => {
             let mode = if storage {
                 cache::CacheMode::Storage
             } else {
                 let patch_id = patch_id
                     .map(|id| id.resolve(&repository.backend))
                     .transpose()?;
                 let patch_id = id.map(|id| id.resolve(&repository.backend)).transpose()?;
                 patch_id.map_or(
                     cache::CacheMode::Repository {
                         repository: &repository,

@@ -1093,15 +301,15 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

             };
             cache::run(mode, &profile)?;
         }
         Operation::React {
             revision_id,
             reaction,
         Command::React {
             id,
             emoji: react,
             undo,
         } => {
             if undo {
                 react::run(&revision_id, reaction, false, &repository, &profile)?;
                 react::run(&id, react, false, &repository, &profile)?;
             } else {
                 react::run(&revision_id, reaction, true, &repository, &profile)?;
                 react::run(&id, react, true, &repository, &profile)?;
             }
         }
     }

added crates/radicle-cli/src/commands/patch/args.rs

@@ -0,0 +1,755 @@

 use clap::{Parser, Subcommand};
 use radicle::cob::Label;
 use radicle::git;
 use radicle::git::fmt::RefString;
 use radicle::patch::Status;
 use radicle::patch::Verdict;
 use radicle::prelude::Did;
 use radicle::prelude::RepoId;
 use crate::commands::patch::checkout;
 use crate::commands::patch::review;
 use crate::git::Rev;
 use crate::terminal::patch::Message;
 pub(crate) const ABOUT: &str = "Manage patches";
 #[derive(Debug, Parser)]
 #[command(about = ABOUT, disable_version_flag = true)]
 pub struct Args {
     #[command(subcommand)]
     pub(super) command: Option<Command>,
     /// Quiet output
     #[arg(short, long, global = true)]
     pub(super) quiet: bool,
     /// Announce changes made to the network
     #[arg(long, global = true, conflicts_with = "no_announce")]
     announce: bool,
     /// Do not announce changes made to the network
     #[arg(long, global = true, conflicts_with = "announce")]
     no_announce: bool,
     /// Operate on the given repository [default: cwd]
     #[arg(long, global = true, value_name = "RID")]
     pub(super) repo: Option<RepoId>,
     /// Verbose output
     #[arg(long, short, global = true)]
     pub(super) verbose: bool,
     /// Arguments for the empty subcommand.
     /// Will fall back to [`Command::List`].
     #[clap(flatten)]
     pub(super) empty: EmptyArgs,
 }
 impl Args {
     pub(super) fn should_announce(&self) -> bool {
         self.announce || !self.no_announce
     }
 }
 /// Commands to create, view, and edit Radicle patches
 #[derive(Subcommand, Debug)]
 pub(super) enum Command {
     /// List the patches of a repository
     #[command(alias = "l")]
     List(ListArgs),
     /// Show a specific patch
     #[command(alias = "s")]
     Show {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         /// Show the diff of the changes in the patch
         #[arg(long, short)]
         patch: bool,
         /// Verbose output
         #[arg(long, short)]
         verbose: bool,
     },
     /// Show the diff of a specific patch
     ///
     /// The `git diff` of the revision's base and head will be shown
     Diff {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         /// The revision to diff
         ///
         /// If not specified, the latest revision of the original author
         /// will be used
         #[arg(long, short)]
         revision: Option<Rev>,
     },
     /// Mark a patch as archived
     #[command(alias = "a")]
     Archive {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         /// Unarchive a patch
         ///
         /// The patch will be marked as open
         #[arg(long)]
         undo: bool,
     },
     /// Update the metadata of a patch
     #[command(alias = "u")]
     Update {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         /// Provide a Git revision as the base commit
         #[arg(long, short, value_name = "REVSPEC")]
         base: Option<Rev>,
         /// Change the message of the original revision of the patch
         #[clap(flatten)]
         message: MessageArgs,
     },
     /// Checkout a Git branch pointing to the head of a patch revision
     ///
     /// If no revision is specified, the latest revision of the original author
     /// is chosen
     #[command(alias = "c")]
     Checkout {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         /// Checkout the given revision of the patch
         #[arg(long)]
         revision: Option<Rev>,
         #[clap(flatten)]
         opts: CheckoutArgs,
     },
     /// Create a review of a patch revision
     Review {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         /// The particular revision to review
         ///
         /// If none is specified, the initial revision will be reviewed
         #[arg(long, short)]
         revision: Option<Rev>,
         #[clap(flatten)]
         options: ReviewArgs,
     },
     /// Mark a comment of a review as resolved or unresolved
     Resolve {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         /// The review id which the comment is under
         #[arg(long, value_name = "REVIEW_ID")]
         review: Rev,
         /// The comment to (un)resolve
         #[arg(long, value_name = "COMMENT_ID")]
         comment: Rev,
         /// Unresolve the comment
         #[arg(long)]
         unresolve: bool,
     },
     /// Delete a patch
     ///
     /// This will delete any patch data associated with this user. Note that
     /// other user's data will remain, meaning the patch will remain until all
     /// other data is also deleted.
     #[command(alias = "d")]
     Delete {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
     },
     /// Redact a patch revision
     #[command(alias = "r")]
     Redact {
         /// ID of the patch revision
         #[arg(value_name = "REVISION_ID")]
         id: Rev,
     },
     /// React to a patch or patch revision
     React {
         /// ID of the patch or patch revision
         #[arg(value_name = "PATCH_ID|REVISION_ID")]
         id: Rev,
         /// The reaction being used
         #[arg(long, value_name = "CHAR")]
         emoji: radicle::cob::Reaction,
         /// Remove the reaction
         #[arg(long)]
         undo: bool,
     },
     /// Add or remove assignees to/from a patch
     Assign {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         #[clap(flatten)]
         args: AssignArgs,
     },
     /// Add or remove labels to/from a patch
     Label {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         #[clap(flatten)]
         args: LabelArgs,
     },
     /// If the patch is marked as a draft, then mark it as open
     #[command(alias = "y")]
     Ready {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         /// Convert a patch back to a draft
         #[arg(long)]
         undo: bool,
     },
     #[command(alias = "e")]
     Edit {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         /// ID of the patch revision
         #[arg(long, value_name = "REVISION_ID")]
         revision: Option<Rev>,
         #[clap(flatten)]
         message: MessageArgs,
     },
     /// Set an upstream branch for a patch
     Set {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Rev,
         /// Provide the git remote to use as the upstream
         #[arg(long, value_name = "REF", value_parser = parse_refstr)]
         remote: Option<RefString>,
     },
     /// Comment on, reply to, edit, or react to a comment
     Comment(CommentArgs),
     /// Re-cache the patches
     Cache {
         /// ID of the patch
         #[arg(value_name = "PATCH_ID")]
         id: Option<Rev>,
         /// Re-cache all patches in storage, as opposed to the current repository
         #[arg(long)]
         storage: bool,
     },
 }
 impl Command {
     pub(super) fn should_announce(&self) -> bool {
         match self {
             Self::Update { .. }
             | Self::Archive { .. }
             | Self::Ready { .. }
             | Self::Delete { .. }
             | Self::Comment { .. }
             | Self::Review { .. }
             | Self::Resolve { .. }
             | Self::Assign { .. }
             | Self::Label { .. }
             | Self::Edit { .. }
             | Self::Redact { .. }
             | Self::React { .. }
             | Self::Set { .. } => true,
             Self::Show { .. }
             | Self::Diff { .. }
             | Self::Checkout { .. }
             | Self::List { .. }
             | Self::Cache { .. } => false,
         }
     }
 }
 #[derive(Parser, Debug)]
 pub(super) struct CommentArgs {
     /// ID of the revision to comment on
     #[arg(value_name = "REVISION_ID")]
     revision: Rev,
     #[clap(flatten)]
     message: MessageArgs,
     /// The comment to edit
     ///
     /// Use `--message` to edit with the provided message
     #[arg(
         long,
         value_name = "COMMENT_ID",
         conflicts_with = "react",
         conflicts_with = "redact"
     )]
     edit: Option<Rev>,
     /// The comment to react to
     ///
     /// Use `--emoji` for the character to react with
     ///
     /// Use `--undo` with `--emoji` to remove the reaction
     #[arg(
         long,
         value_name = "COMMENT_ID",
         conflicts_with = "edit",
         conflicts_with = "redact",
         requires = "emoji",
         group = "reaction"
     )]
     react: Option<Rev>,
     /// The comment to redact
     #[arg(
         long,
         value_name = "COMMENT_ID",
         conflicts_with = "react",
         conflicts_with = "edit"
     )]
     redact: Option<Rev>,
     /// The emoji to react with
     ///
     /// Requires using `--react <COMMENT_ID>`
     #[arg(long, requires = "reaction")]
     emoji: Option<radicle::cob::Reaction>,
     /// The comment to reply to
     #[arg(long, value_name = "COMMENT_ID")]
     reply_to: Option<Rev>,
     /// Remove the reaction
     ///
     /// Requires using `--react <COMMENT_ID> --emoji <EMOJI>`
     #[arg(long, requires = "reaction")]
     undo: bool,
 }
 #[derive(Debug)]
 pub(super) enum CommentAction {
     Comment {
         revision: Rev,
         message: Message,
         reply_to: Option<Rev>,
     },
     Edit {
         revision: Rev,
         comment: Rev,
         message: Message,
     },
     Redact {
         revision: Rev,
         comment: Rev,
     },
     React {
         revision: Rev,
         comment: Rev,
         emoji: radicle::cob::Reaction,
         undo: bool,
     },
 }
 impl From<CommentArgs> for CommentAction {
     fn from(
         CommentArgs {
             revision,
             message,
             edit,
             react,
             redact,
             reply_to,
             emoji,
             undo,
         }: CommentArgs,
     ) -> Self {
         match (edit, react, redact) {
             (Some(edit), None, None) => CommentAction::Edit {
                 revision,
                 comment: edit,
                 message: Message::from(message),
             },
             (None, Some(react), None) => CommentAction::React {
                 revision,
                 comment: react,
                 emoji: emoji.unwrap(),
                 undo,
             },
             (None, None, Some(redact)) => CommentAction::Redact {
                 revision,
                 comment: redact,
             },
             (None, None, None) => Self::Comment {
                 revision,
                 message: Message::from(message),
                 reply_to,
             },
             _ => unreachable!("`--edit`, `--react`, and `--redact` cannot be used together"),
         }
     }
 }
 #[derive(Parser, Debug, Default)]
 pub(super) struct EmptyArgs {
     #[arg(long, hide = true, value_name = "DID", num_args = 1.., action = clap::ArgAction::Append)]
     authors: Vec<Did>,
     #[arg(long, hide = true)]
     authored: bool,
     #[clap(flatten)]
     state: EmptyStateArgs,
 }
 #[derive(Parser, Debug, Default)]
 #[group(multiple = false)]
 pub(super) struct EmptyStateArgs {
     #[arg(long, hide = true)]
     all: bool,
     #[arg(long, hide = true)]
     draft: bool,
     #[arg(long, hide = true)]
     open: bool,
     #[arg(long, hide = true)]
     merged: bool,
     #[arg(long, hide = true)]
     archived: bool,
 }
 #[derive(Parser, Debug, Default)]
 pub(super) struct ListArgs {
     /// Show only patched where the given user is an author (may be specified
     /// multiple times)
     #[arg(
         long = "author",
         value_name = "DID",
         num_args = 1..,
         action = clap::ArgAction::Append,
     )]
     pub(super) authors: Vec<Did>,
     /// Show only patches that you have authored
     #[arg(long)]
     pub(super) authored: bool,
     #[clap(flatten)]
     pub(super) state: ListStateArgs,
 }
 impl From<EmptyArgs> for ListArgs {
     fn from(args: EmptyArgs) -> Self {
         Self {
             authors: args.authors,
             authored: args.authored,
             state: ListStateArgs::from(args.state),
         }
     }
 }
 #[derive(Parser, Debug, Default)]
 #[group(multiple = false)]
 pub(crate) struct ListStateArgs {
     /// Show all patches, including draft, merged, and archived patches
     #[arg(long)]
     pub(crate) all: bool,
     /// Show only draft patches
     #[arg(long)]
     pub(crate) draft: bool,
     /// Show only open patches (default)
     #[arg(long)]
     pub(crate) open: bool,
     /// Show only merged patches
     #[arg(long)]
     pub(crate) merged: bool,
     /// Show only archived patches
     #[arg(long)]
     pub(crate) archived: bool,
 }
 impl From<EmptyStateArgs> for ListStateArgs {
     fn from(args: EmptyStateArgs) -> Self {
         Self {
             all: args.all,
             draft: args.draft,
             open: args.open,
             merged: args.merged,
             archived: args.archived,
         }
     }
 }
 impl From<&ListStateArgs> for Option<&Status> {
     fn from(args: &ListStateArgs) -> Self {
         match (args.all, args.draft, args.open, args.merged, args.archived) {
             (true, false, false, false, false) => None,
             (false, true, false, false, false) => Some(&Status::Draft),
             (false, false, true, false, false) | (false, false, false, false, false) => {
                 Some(&Status::Open)
             }
             (false, false, false, true, false) => Some(&Status::Merged),
             (false, false, false, false, true) => Some(&Status::Archived),
             _ => unreachable!(),
         }
     }
 }
 #[derive(Debug, Parser)]
 pub(super) struct ReviewArgs {
     /// Review by patch hunks
     ///
     /// This operation is obsolete
     #[arg(long, short, group = "by-hunk", conflicts_with = "delete")]
     patch: bool,
     /// Generate diffs with <N> lines of context
     ///
     /// This operation is obsolete
     #[arg(
         long,
         short = 'U',
         value_name = "N",
         requires = "by-hunk",
         default_value_t = 3
     )]
     unified: usize,
     /// Only review a specific hunk
     ///
     /// This operation is obsolete
     #[arg(long, value_name = "INDEX", requires = "by-hunk")]
     hunk: Option<usize>,
     /// Accept a patch revision
     #[arg(long, conflicts_with = "reject", conflicts_with = "delete")]
     accept: bool,
     /// Reject a patch revision
     #[arg(long, conflicts_with = "delete")]
     reject: bool,
     /// Delete a review draft
     ///
     /// This operation is obsolete
     #[arg(long, short)]
     delete: bool,
     #[clap(flatten)]
     message_args: MessageArgs,
 }
 impl ReviewArgs {
     fn as_operation(&self) -> review::Operation {
         let Self {
             patch,
             accept,
             reject,
             delete,
             ..
         } = self;
         if *patch {
             let verdict = if *accept {
                 Some(Verdict::Accept)
             } else if *reject {
                 Some(Verdict::Reject)
             } else {
                 None
             };
             return review::Operation::Review(review::ReviewOptions {
                 by_hunk: true,
                 unified: self.unified,
                 hunk: self.hunk,
                 verdict,
             });
         }
         if *delete {
             return review::Operation::Delete;
         }
         if *accept {
             return review::Operation::Review(review::ReviewOptions {
                 by_hunk: false,
                 unified: 3,
                 hunk: None,
                 verdict: Some(Verdict::Accept),
             });
         }
         if *reject {
             return review::Operation::Review(review::ReviewOptions {
                 by_hunk: false,
                 unified: 3,
                 hunk: None,
                 verdict: Some(Verdict::Reject),
             });
         }
         panic!("expected one of `--patch`, `--delete`, `--accept`, or `--reject`");
     }
 }
 impl From<ReviewArgs> for review::Options {
     fn from(args: ReviewArgs) -> Self {
         let op = args.as_operation();
         Self {
             message: Message::from(args.message_args),
             op,
         }
     }
 }
 #[derive(Debug, clap::Args)]
 #[group(required = false, multiple = false)]
 pub(super) struct MessageArgs {
     /// Provide a message (default: prompt)
     ///
     /// This can be specified multiple times. This will result in newlines
     /// between the specified messages.
     #[clap(
         long,
         short,
         value_name = "MESSAGE",
         num_args = 1..,
         action = clap::ArgAction::Append
     )]
     pub(super) message: Option<Vec<String>>,
     /// Do not provide a message
     #[arg(long, conflicts_with = "message")]
     pub(super) no_message: bool,
 }
 impl From<MessageArgs> for Message {
     fn from(
         MessageArgs {
             message,
             no_message,
         }: MessageArgs,
     ) -> Self {
         if no_message {
             assert!(message.is_none());
             return Self::Blank;
         }
         match message {
             Some(messages) => messages.into_iter().fold(Self::Blank, |mut result, m| {
                 result.append(&m);
                 result
             }),
             None => Self::Edit,
         }
     }
 }
 #[derive(Debug, clap::Args)]
 pub(super) struct CheckoutArgs {
     /// Provide a name for the branch to checkout
     #[arg(long, value_name = "BRANCH", value_parser = parse_refstr)]
     pub(super) name: Option<RefString>,
     /// Provide the git remote to use as the upstream
     #[arg(long, value_parser = parse_refstr)]
     pub(super) remote: Option<RefString>,
     /// Checkout the head of the revision, even if the branch already exists
     #[arg(long, short)]
     pub(super) force: bool,
 }
 impl From<CheckoutArgs> for checkout::Options {
     fn from(value: CheckoutArgs) -> Self {
         Self {
             name: value.name,
             remote: value.remote,
             force: value.force,
         }
     }
 }
 #[derive(Parser, Debug)]
 #[group(required = true)]
 pub(super) struct AssignArgs {
     /// Add an assignee to the patch (may be specified multiple times).
     ///
     /// Note: `--add` takes precedence over `--delete`
     #[arg(long, short, value_name = "DID", num_args = 1.., action = clap::ArgAction::Append)]
     pub(super) add: Vec<Did>,
     /// Remove an assignee from the patch (may be specified multiple times).
     ///
     /// Note: `--add` takes precedence over `--delete`
     #[clap(long, short, value_name = "DID", num_args = 1.., action = clap::ArgAction::Append)]
     pub(super) delete: Vec<Did>,
 }
 #[derive(Parser, Debug)]
 #[group(required = true)]
 pub(super) struct LabelArgs {
     /// Add a label to the patch (may be specified multiple times).
     ///
     /// Note: `--add` takes precedence over `--delete`
     #[arg(long, short, value_name = "LABEL", num_args = 1.., action = clap::ArgAction::Append)]
     pub(super) add: Vec<Label>,
     /// Remove a label from the patch (may be specified multiple times).
     ///
     /// Note: `--add` takes precedence over `--delete`
     #[clap(long, short, value_name = "LABEL", num_args = 1.., action = clap::ArgAction::Append)]
     pub(super) delete: Vec<Label>,
 }
 fn parse_refstr(refstr: &str) -> Result<RefString, git::fmt::Error> {
     RefString::try_from(refstr)
 }

modified crates/radicle-cli/src/commands/patch/review.rs

@@ -21,19 +21,16 @@ Markdown supported.

 "#;
 #[derive(Debug, PartialEq, Eq)]
 pub enum Operation {
     Delete,
     Review {
         by_hunk: bool,
         unified: usize,
         hunk: Option<usize>,
         verdict: Option<Verdict>,
     },
 pub(super) struct ReviewOptions {
     pub(super) by_hunk: bool,
     pub(super) unified: usize,
     pub(super) hunk: Option<usize>,
     pub(super) verdict: Option<Verdict>,
 }
 impl Default for Operation {
 impl Default for ReviewOptions {
     fn default() -> Self {
         Self::Review {
         Self {
             by_hunk: false,
             unified: 3,
             hunk: None,

@@ -42,6 +39,18 @@ impl Default for Operation {

     }
 }
 #[derive(Debug, PartialEq, Eq)]
 pub(super) enum Operation {
     Delete,
     Review(ReviewOptions),
 }
 impl Default for Operation {
     fn default() -> Self {
         Operation::Review(ReviewOptions::default())
     }
 }
 #[derive(Debug, Default)]
 pub struct Options {
     pub message: Message,

@@ -77,12 +86,12 @@ pub fn run(

     let patch_id_pretty = term::format::tertiary(term::format::cob(&patch_id));
     match options.op {
         Operation::Review {
             verdict,
         Operation::Review(ReviewOptions {
             by_hunk,
             unified,
             hunk,
         } if by_hunk => {
             verdict,
         }) if by_hunk => {
             crate::warning::obsolete("rad patch review --patch");
             let mut opts = git::raw::DiffOptions::new();
             opts.patience(true)

@@ -94,7 +103,7 @@ pub fn run(

                 .verdict(verdict)
                 .run(revision, &mut opts, &signer)?;
         }
         Operation::Review { verdict, .. } => {
         Operation::Review(ReviewOptions { verdict, .. }) => {
             let message = options.message.get(REVIEW_HELP_MSG)?;
             let message = message.replace(REVIEW_HELP_MSG.trim(), "");
             let message = if message.is_empty() {

modified crates/radicle-cli/src/commands/patch/show.rs

@@ -5,6 +5,7 @@ use radicle::git;

 use radicle::storage::git::Repository;
 use crate::terminal as term;
 use crate::terminal::Error;
 use super::*;

modified crates/radicle-cli/src/main.rs

@@ -75,6 +75,7 @@ enum Commands {

     Issue(issue::Args),
     Ls(ls::Args),
     Node(node::Args),
     Patch(patch::Args),
     Path(path::Args),
     Publish(publish::Args),
     Remote(remote::Args),

@@ -311,7 +312,9 @@ pub(crate) fn run_other(exe: &str, args: &[OsString]) -> Result<(), Option<anyho

             }
         }
         "patch" => {
             term::run_command_args::<patch::Options, _>(patch::HELP, patch::run, args.to_vec());
             if let Some(Commands::Patch(args)) = CliArgs::parse().command {
                 term::run_command_fn(patch::run, args);
             }
         }
         "path" => {
             if let Some(Commands::Path(args)) = CliArgs::parse().command {