Migration of `rad` to `clap` — heartwood

This patch migrates the top-level rad command to use all the clap machinery for parsing.

This also results in removing a lot of no longer needed code around argument parsing, and maintaining a help command.

  "dunce",
  "human-panic",
  "itertools",
  "lexopt",
  "localtime",
  "log",
  "nonempty",

 dunce = { workspace = true }
 human-panic.workspace = true
 itertools.workspace = true
 lexopt = { workspace = true }
 localtime = { workspace = true }
 log = { workspace = true, features = ["std"] }
 nonempty = { workspace = true }

 ```
 $ rad --help
 rad [..]
 Radicle command line interface
 Usage: rad <command> [--help]
 Common `rad` commands used in various situations:
 	auth         Manage identities and profiles
 	block        Block repositories or nodes from being seeded or followed
 	checkout     Checkout a repository into the local directory
 	clone        Clone a Radicle repository
 	config       Manage your local Radicle configuration
 	debug        Write out information to help debug your Radicle node remotely
 	fork         Create a fork of a repository
 	help         CLI help
 	id           Manage repository identities
 	init         Initialize a Radicle repository
 	inbox        Manage your Radicle notifications
 	inspect      Inspect a Radicle repository
 	issue        Manage issues
 	ls           List repositories
 	node         Control and query the Radicle Node
 	patch        Manage patches
 	path         Display the Radicle home path
 	publish      Publish a repository to the network
 	clean        Remove all remotes from a repository
 	self         Show information about your identity and device
 	seed         Manage repository seeding policies
 	follow       Manage node follow policies
 	unblock      Unblock repositories or nodes to allow them to be seeded or followed
 	unfollow     Unfollow a peer
 	unseed       Remove repository seeding policies
 	remote       Manage a repository's remotes
 	stats        Displays aggregated repository and node metrics
 	sync         Sync repositories to the network
 	watch        Wait for some state to be updated
 See `rad <command> --help` to learn about a specific command.
 Radicle is a sovereign code forge built on Git.
 See `rad <COMMAND> --help` to learn about a specific command.
 Do you have feedback?
  - Chat[..]
  - Mail[..]
  - Chat </x1b]8;;https://radicle.zulipchat.com/x1b//radicle.zulipchat.com/x1b]8;;/x1b//>
  - Mail </x1b]8;;mailto:feedback@radicle.xyz/x1b//feedback@radicle.xyz/x1b]8;;/x1b//>
    (Messages are automatically posted to the public #feedback channel on Zulip.)
 Usage: rad <COMMAND>
 Commands:
   auth      Manage identities and profiles
   block     Block repositories or nodes from being seeded or followed
   checkout  Checkout a repository into the local directory
   clean     Remove all remotes from a repository
   clone     Clone a Radicle repository
   config    Manage your local Radicle configuration
   debug     Write out information to help debug your Radicle node remotely
   follow    Manage node follow policies
   fork      Create a fork of a repository
   id        Manage repository identities
   inbox     Manage your Radicle notifications
   init      Initialize a Radicle repository
   inspect   Inspect a Radicle repository
   issue     Manage issues
   ls        List repositories
   node      Control and query the Radicle Node
   patch     Manage patches
   path      Display the Radicle home path
   publish   Publish a repository to the network
   remote    Manage a repository's remotes
   seed      Manage repository seeding policies
   self      Show information about your identity and device
   stats     Displays aggregated repository and node metrics
   sync      Sync repositories to the network
   unblock   Unblock repositories or nodes to allow them to be seeded or followed
   unfollow  Unfollow a peer
   unseed    Remove repository seeding policies
   watch     Wait for some state to be updated
   version   Print the version information of the CLI
   help      Print this message or the help of the given subcommand(s)
 Options:
   -h, --help
           Print help (see a summary with '-h')
   -V, --version
           Print version
 ```

 pub mod diff;
 pub mod follow;
 pub mod fork;
 pub mod help;
 pub mod id;
 pub mod inbox;
 pub mod init;

 use crate::terminal as term;
 pub use args::Args;
 pub(crate) use args::ABOUT;
 pub fn run(args: Args, ctx: impl term::Context) -> anyhow::Result<()> {
     match ctx.profile() {

 use clap::Parser;
 use radicle::node::Alias;
 pub(crate) const ABOUT: &str = "Manage identities and profiles";
 const ABOUT: &str = "Manage identities and profiles";
 const LONG_ABOUT: &str = r#"
 A passphrase may be given via the environment variable `RAD_PASSPHRASE` or
 via the standard input stream if `--stdin` is used. Using either of these

 use crate::terminal::args::BlockTarget;
 pub(crate) const ABOUT: &str = "Block repositories or nodes from being seeded or followed";
 const ABOUT: &str = "Block repositories or nodes from being seeded or followed";
 #[derive(Parser, Debug)]
 #[command(about = ABOUT, disable_version_flag = true)]

 use clap::Parser;
 use radicle::prelude::{Did, RepoId};
 pub(crate) const ABOUT: &str = "Checkout a repository into the local directory";
 const ABOUT: &str = "Checkout a repository into the local directory";
 const LONG_ABOUT: &str = r#"
 Creates a working copy from a repository in local storage.
 "#;

 use radicle::prelude::RepoId;
 pub const ABOUT: &str = "Remove all remotes from a repository";
 const ABOUT: &str = "Remove all remotes from a repository";
 const LONG_ABOUT: &str = r#"
 Removes all remotes from a repository, as long as they are not the

 use crate::terminal;
 pub(crate) const ABOUT: &str = "Clone a Radicle repository";
 const ABOUT: &str = "Clone a Radicle repository";
 const LONG_ABOUT: &str = r#"
 The `clone` command will use your local node's routing table to find seeds from

 use clap::{Parser, Subcommand};
 use radicle::node::Alias;
 pub(crate) const ABOUT: &str = "Manage your local Radicle configuration";
 const ABOUT: &str = "Manage your local Radicle configuration";
 const LONG_ABOUT: &str = r#"
 If no argument is specified, prints the current radicle configuration as JSON.

 use clap::Parser;
 pub const ABOUT: &str = "Write out information to help debug your Radicle node remotely";
 const ABOUT: &str = "Write out information to help debug your Radicle node remotely";
 const LONG_ABOUT: &str = r#"
 Run this if you are reporting a problem in Radicle. The output is

 use crate::terminal as term;
 pub(crate) const ABOUT: &str = "Manage node follow policies";
 const ABOUT: &str = "Manage node follow policies";
 const LONG_ABOUT: &str = r#"
 The `follow` command will print all nodes being followed, optionally filtered by alias, if no

 use radicle::identity::RepoId;
 pub(crate) const ABOUT: &str = "Create a fork of a repository";
 const ABOUT: &str = "Create a fork of a repository";
 #[derive(Debug, clap::Parser)]
 #[command(about = ABOUT, disable_version_flag = true)]

 use std::ffi::OsString;
 use crate::terminal as term;
 use crate::terminal::args::{Args, Error, Help};
 pub const HELP: Help = Help {
     name: "help",
     description: "CLI help",
     version: env!("RADICLE_VERSION"),
     usage: "Usage: rad help [--help]",
 };
 enum CommandItem {
     Lexopt(Help),
     Clap {
         name: &'static str,
         about: &'static str,
     },
 }
 impl CommandItem {
     fn name(&self) -> &str {
         match self {
             CommandItem::Lexopt(help) => help.name,
             CommandItem::Clap { name, .. } => name,
         }
     }
     fn description(&self) -> &str {
         match self {
             CommandItem::Lexopt(help) => help.description,
             CommandItem::Clap {
                 about: description, ..
             } => description,
         }
     }
 }
 const COMMANDS: &[CommandItem] = &[
     CommandItem::Clap {
         name: "auth",
         about: crate::commands::auth::ABOUT,
     },
     CommandItem::Clap {
         name: "block",
         about: crate::commands::block::ABOUT,
     },
     CommandItem::Clap {
         name: "checkout",
         about: crate::commands::checkout::ABOUT,
     },
     CommandItem::Clap {
         name: "clone",
         about: crate::commands::clone::ABOUT,
     },
     CommandItem::Clap {
         name: "config",
         about: crate::commands::config::ABOUT,
     },
     CommandItem::Clap {
         name: "debug",
         about: crate::commands::debug::ABOUT,
     },
     CommandItem::Clap {
         name: "fork",
         about: crate::commands::fork::ABOUT,
     },
     CommandItem::Lexopt(crate::commands::help::HELP),
     CommandItem::Clap {
         name: "id",
         about: crate::commands::id::ABOUT,
     },
     CommandItem::Clap {
         name: "init",
         about: crate::commands::init::ABOUT,
     },
     CommandItem::Clap {
         name: "inbox",
         about: crate::commands::inbox::ABOUT,
     },
     CommandItem::Clap {
         name: "inspect",
         about: crate::commands::inspect::ABOUT,
     },
     CommandItem::Clap {
         name: "issue",
         about: crate::commands::issue::ABOUT,
     },
     CommandItem::Clap {
         name: "ls",
         about: crate::commands::ls::ABOUT,
     },
     CommandItem::Clap {
         name: "node",
         about: crate::commands::node::ABOUT,
     },
     CommandItem::Lexopt(crate::commands::patch::HELP),
     CommandItem::Clap {
         name: "path",
         about: crate::commands::path::ABOUT,
     },
     CommandItem::Clap {
         name: "publish",
         about: crate::commands::publish::ABOUT,
     },
     CommandItem::Clap {
         name: "clean",
         about: crate::commands::clean::ABOUT,
     },
     CommandItem::Clap {
         name: "self",
         about: crate::commands::rad_self::ABOUT,
     },
     CommandItem::Clap {
         name: "seed",
         about: crate::commands::seed::ABOUT,
     },
     CommandItem::Clap {
         name: "follow",
         about: crate::commands::follow::ABOUT,
     },
     CommandItem::Clap {
         name: "unblock",
         about: crate::commands::unblock::ABOUT,
     },
     CommandItem::Clap {
         name: "unfollow",
         about: crate::commands::unfollow::ABOUT,
     },
     CommandItem::Clap {
         name: "unseed",
         about: crate::commands::unseed::ABOUT,
     },
     CommandItem::Clap {
         name: "remote",
         about: crate::commands::remote::ABOUT,
     },
     CommandItem::Clap {
         name: "stats",
         about: crate::commands::stats::ABOUT,
     },
     CommandItem::Lexopt(crate::commands::sync::HELP),
     CommandItem::Clap {
         name: "watch",
         about: crate::commands::watch::ABOUT,
     },
 ];
 #[derive(Default)]
 pub struct Options {}
 impl Args for Options {
     fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {
         let mut parser = lexopt::Parser::from_args(args);
         if let Some(arg) = parser.next()? {
             anyhow::bail!(arg.unexpected());
         }
         Err(Error::HelpManual { name: "rad" }.into())
     }
 }
 pub fn run(_options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
     term::print("Usage: rad <command> [--help]");
     if let Err(e) = ctx.profile() {
         term::blank();
         match e.downcast_ref() {
             Some(term::args::Error::WithHint { err, hint }) => {
                 term::print(term::format::yellow(err));
                 term::print(term::format::yellow(hint));
             }
             Some(e) => {
                 term::error(e);
             }
             None => {
                 term::error(e);
             }
         }
         term::blank();
     }
     term::print("Common `rad` commands used in various situations:");
     term::blank();
     for help in COMMANDS {
         term::info!(
             "\t{} {}",
             term::format::bold(format!("{:-12}", help.name())),
             term::format::dim(help.description())
         );
     }
     term::blank();
     term::print("See `rad <command> --help` to learn about a specific command.");
     term::blank();
     term::print("Do you have feedback?");
     term::print(
         " - Chat <\x1b]8;;https://radicle.zulipchat.com\x1b\\radicle.zulipchat.com\x1b]8;;\x1b\\>",
     );
     term::print(
         " - Mail <\x1b]8;;mailto:feedback@radicle.xyz\x1b\\feedback@radicle.xyz\x1b]8;;\x1b\\>",
     );
     term::print("   (Messages are automatically posted to the public #feedback channel on Zulip.)");
     Ok(())
 }

 use crate::terminal::Interactive;
 pub(crate) const ABOUT: &str = "Manage repository identities";
 const ABOUT: &str = "Manage repository identities";
 const LONG_ABOUT: &str = r#"
 The `id` command is used to manage and propose changes to the
 identity of a Radicle repository.

 mod args;
 pub use args::Args;
 pub(crate) use args::ABOUT;
 use std::path::Path;
 use std::process;

 use clap::{Parser, Subcommand, ValueEnum};
 use radicle::{node::notifications::NotificationId, prelude::RepoId};
 pub(crate) const ABOUT: &str = "Manage your Radicle notifications";
 const ABOUT: &str = "Manage your Radicle notifications";
 const LONG_ABOUT: &str = r#"
 By default, this command lists all items in your inbox.

 };
 use radicle_term::Interactive;
 pub(crate) const ABOUT: &str = "Initialize a Radicle repository";
 const ABOUT: &str = "Initialize a Radicle repository";
 #[derive(Debug, Parser)]
 #[command(about = ABOUT, disable_version_flag = true)]

 use clap::Parser;
 pub(crate) const ABOUT: &str = "Inspect a Radicle repository";
 const ABOUT: &str = "Inspect a Radicle repository";
 const LONG_ABOUT: &str = r#"Inspects the given path or RID. If neither is specified,
 the current repository is inspected.
 "#;

 use crate::terminal::issue::Format;
 use crate::terminal::Element;
 pub(crate) const ABOUT: &str = "Manage issues";
 const ABOUT: &str = "Manage issues";
 pub fn run(args: Args, ctx: impl term::Context) -> anyhow::Result<()> {
     let profile = ctx.profile()?;

 use clap::Parser;
 pub(crate) const ABOUT: &str = "List repositories";
 const ABOUT: &str = "List repositories";
 const LONG_ABOUT: &str = r#"
 By default, this command shows you all repositories that you have forked or initialized.
 If you wish to see all seeded repositories, use the `--seeded` option.

 use radicle::node::{Address, NodeId, PeerAddr, PeerAddrParseError};
 use radicle::prelude::RepoId;
 pub(crate) const ABOUT: &str = "Control and query the Radicle Node";
 const ABOUT: &str = "Control and query the Radicle Node";
 #[derive(Parser, Debug)]
 #[command(about = ABOUT, long_about, disable_version_flag = true)]

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

 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};

 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;
     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()

     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()?;

                 "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 {

                 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,

             };
             cache::run(mode, &profile)?;
         }
         Operation::CommentEdit {
             revision_id,
             comment_id,
             message,
         } => {
             let comment = comment_id.resolve(&repository.backend)?;
             comment::edit::run(
                 revision_id,
                 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)?;
             }
         }
         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)?;
             }
         }
     }

 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;
 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)
 }

 "#;
 #[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,

     }
 }
 #[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,

     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)

                 .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() {