term, cli, remote-helper: Status Symbols and improved sync output — heartwood

A new table style that is more narrow, and follows the recent change to rad node status. Deduplicate and clean up symbols we use to indicate status along the way.

 ╭─────────────────────────────────────────────────────────────────────────────╮
 │ ●  ID       Title          Author         Reviews  Head     +   -   Updated │
 ├─────────────────────────────────────────────────────────────────────────────┤
 │ ✔  [ ... ]  Second change  alice   (you)  -        daf349f  +0  -0  now     │
 │ ✔  [ ... ]  First change   alice   (you)  -        20aa5dd  +0  -0  now     │
 │ ✓  [ ... ]  Second change  alice   (you)  -        daf349f  +0  -0  now     │
 │ ✓  [ ... ]  First change   alice   (you)  -        20aa5dd  +0  -0  now     │
 ╰─────────────────────────────────────────────────────────────────────────────╯
 $ rad patch show 696ec5508494692899337afe6713fe1796d0315c
 ╭────────────────────────────────────────────────────────────────╮

 │ ●  ID       Title          Author         Reviews  Head     +   -   Updated │
 ├─────────────────────────────────────────────────────────────────────────────┤
 │ ●  356f738  Second change  alice   (you)  -        daf349f  +0  -0  now     │
 │ ✔  696ec55  First change   alice   (you)  -        20aa5dd  +0  -0  now     │
 │ ✓  696ec55  First change   alice   (you)  -        20aa5dd  +0  -0  now     │
 ╰─────────────────────────────────────────────────────────────────────────────╯
 ```

 ╭─────────────────────────────────────────────────────────────────────────────────────────╮
 │ ●  ID       Title                      Author         Reviews  Head     +   -   Updated │
 ├─────────────────────────────────────────────────────────────────────────────────────────┤
 │ ●  aa45913  Define power requirements  alice   (you)  ✔        27857ec  +0  -0  now     │
 │ ●  aa45913  Define power requirements  alice   (you)  ✓        27857ec  +0  -0  now     │
 ╰─────────────────────────────────────────────────────────────────────────────────────────╯
 ```

 ```
 $ rad sync status --sort-by alias
 ╭──────────────────────────────────────────────────────────────────────────────────────────────╮
 │ ●   Node                      Address                      Status        Tip       Timestamp │
 ├──────────────────────────────────────────────────────────────────────────────────────────────┤
 │ ●   alice   (you)             alice.radicle.example:8776   unannounced   056b1db   [  ...  ] │
 │ ●   bob     z6Mkt67…v4N1tRk   bob.radicle.example:8776     out-of-sync   99c5497   [  ...  ] │
 │ ●   eve     z6Mkux1…nVhib7Z   eve.radicle.example:8776     out-of-sync   99c5497   [  ...  ] │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────╯
 ╭───────────────────────────────────────────────────╮
 │ Node ID           Alias   ?   SigRefs   Timestamp │
 ├───────────────────────────────────────────────────┤
 │ (you)             alice   !   056b1db   [..]      │
 │ z6Mkt67…v4N1tRk   bob     ✗   99c5497   [..]      │
 │ z6Mkux1…nVhib7Z   eve     ✗   99c5497   [..]      │
 ╰───────────────────────────────────────────────────╯
 ```
 Now let's run `rad sync`. This will announce the issue refs to the network and

 ```
 $ rad sync status --sort-by alias
 ╭─────────────────────────────────────────────────────────────────────────────────────────╮
 │ ●   Node                      Address                      Status   Tip       Timestamp │
 ├─────────────────────────────────────────────────────────────────────────────────────────┤
 │ ●   alice   (you)             alice.radicle.example:8776            056b1db   [  ...  ] │
 │ ●   bob     z6Mkt67…v4N1tRk   bob.radicle.example:8776     synced   056b1db   [  ...  ] │
 │ ●   eve     z6Mkux1…nVhib7Z   eve.radicle.example:8776     synced   056b1db   [  ...  ] │
 ╰─────────────────────────────────────────────────────────────────────────────────────────╯
 ╭───────────────────────────────────────────────────╮
 │ Node ID           Alias   ?   SigRefs   Timestamp │
 ├───────────────────────────────────────────────────┤
 │ (you)             alice   ✓   056b1db   [..]      │
 │ z6Mkt67…v4N1tRk   bob     ✓   056b1db   [..]      │
 │ z6Mkux1…nVhib7Z   eve     ✓   056b1db   [..]      │
 ╰───────────────────────────────────────────────────╯
 ```
 If we try to sync again after the nodes have synced, we will already

     for id in accepted {
         let author = term::format::Author::new(&id, profile);
         signatures.push([
             term::format::positive("✓").into(),
             term::PREFIX_SUCCESS.into(),
             id.to_string().into(),
             author.alias().unwrap_or_default(),
             author.you().unwrap_or_default(),

 }
 fn state_attempted() -> term::Paint<String> {
     term::format::yellow("!".to_string())
     term::PREFIX_WARNING.into()
 }
 fn state_connected() -> term::Paint<String> {
     term::format::positive("✓".to_string())
     term::PREFIX_SUCCESS.into()
 }
 fn state_disconnected() -> term::Paint<String> {
     term::format::negative("✗".to_string())
     term::PREFIX_ERROR.into()
 }
 fn link_direction_label() -> term::Paint<String> {

             patch::State::Open { .. } => term::format::positive("●").into(),
             patch::State::Archived => term::format::yellow("●").into(),
             patch::State::Draft => term::format::dim("●").into(),
             patch::State::Merged { .. } => term::format::primary("✔").into(),
             patch::State::Merged { .. } => term::PREFIX_SUCCESS.into(),
         },
         term::format::tertiary(term::format::cob(id)).into(),
         term::format::default(patch.title().to_owned()).into(),

 use radicle::node::address::Store;
 use radicle::node::sync;
 use radicle::node::sync::fetch::SuccessfulOutcome;
 use radicle::node::SyncedAt;
 use radicle::node::{AliasStore, Handle as _, Node, Seed, SyncStatus};
 use radicle::prelude::{NodeId, Profile, RepoId};
 use radicle::storage::ReadRepository;

     profile: &Profile,
     options: &Options,
 ) -> anyhow::Result<()> {
     let mut table = Table::<7, term::Label>::new(TableOptions::bordered());
     const SYMBOL_STATE: &str = "?";
     const SYMBOL_STATE_UNKNOWN: &str = "•";
     let mut table = Table::<5, term::Label>::new(TableOptions::bordered());
     let mut seeds: Vec<_> = node.seeds(rid)?.into();
     let local_nid = node.nid()?;
     let aliases = profile.aliases();
     table.header([
         term::format::dim(String::from("●")).into(),
         term::format::bold(String::from("Node")).into(),
         term::Label::blank(),
         term::format::bold(String::from("Address")).into(),
         term::format::bold(String::from("Status")).into(),
         term::format::bold(String::from("Tip")).into(),
         term::format::bold(String::from("Timestamp")).into(),
         term::format::bold("Node ID").into(),
         term::format::bold("Alias").into(),
         term::format::bold(SYMBOL_STATE).into(),
         term::format::bold("SigRefs").into(),
         term::format::bold("Timestamp").into(),
     ]);
     table.divider();
     sort_seeds_by(local_nid, &mut seeds, &aliases, &options.sort_by);
     for seed in seeds {
         let (icon, status, head, time) = match seed.sync {
             Some(SyncStatus::Synced { at }) => (
                 term::format::positive("●"),
                 term::format::positive(if seed.nid != local_nid { "synced" } else { "" }),
                 term::format::oid(at.oid),
                 term::format::timestamp(at.timestamp),
         let (status, head, time) = match seed.sync {
             Some(SyncStatus::Synced {
                 at: SyncedAt { oid, timestamp },
             }) => (
                 term::PREFIX_SUCCESS,
                 term::format::oid(oid),
                 term::format::timestamp(timestamp),
             ),
             Some(SyncStatus::OutOfSync { remote, local, .. }) => (
                 if seed.nid != local_nid {
                     term::format::negative("●")
                 } else {
                     term::format::yellow("●")
                 },
                 if seed.nid != local_nid {
                     term::format::negative("out-of-sync")
                 } else {
                     term::format::yellow("unannounced")
                 },
                 term::format::oid(if seed.nid != local_nid {
                     remote.oid
                 } else {
                     local.oid
                 }),
                 term::format::timestamp(remote.timestamp),
             Some(SyncStatus::OutOfSync {
                 remote: SyncedAt { timestamp, .. },
                 local,
                 ..
             }) if seed.nid == local_nid => (
                 term::PREFIX_WARNING,
                 term::format::oid(local.oid),
                 term::format::timestamp(timestamp),
             ),
             Some(SyncStatus::OutOfSync {
                 remote: SyncedAt { oid, timestamp },
                 ..
             }) => (
                 term::PREFIX_ERROR,
                 term::format::oid(oid),
                 term::format::timestamp(timestamp),
             ),
             None if options.verbose => (
                 term::format::dim("●"),
                 term::format::dim("unknown"),
                 term::format::dim(SYMBOL_STATE_UNKNOWN),
                 term::paint(String::new()),
                 term::paint(String::new()),
             ),
             None => continue,
         };
         let addr = seed
             .addrs
             .first()
             .map(|a| a.addr.to_string())
             .unwrap_or_default()
             .into();
         let (alias, nid) = Author::new(&seed.nid, profile).labels();
         table.push([
             icon.into(),
             alias,
             nid,
             addr,
             alias,
             status.into(),
             term::format::secondary(head).into(),
             time.dim().italic().into(),

     }
     table.print();
     if profile.hints() {
         const COLUMN_WIDTH: usize = 16;
         let status = format!(
             "\n{:>4} … {}\n       {}   {}\n       {}   {}",
             term::Paint::from(SYMBOL_STATE.to_string()).fg(radicle_term::Color::White),
             term::format::dim("Status:"),
             format_args!(
                 "{} {:width$}",
                 term::PREFIX_SUCCESS,
                 term::format::dim("… in sync"),
                 width = COLUMN_WIDTH,
             ),
             format_args!(
                 "{} {}",
                 term::PREFIX_ERROR,
                 term::format::dim("… out of sync")
             ),
             format_args!(
                 "{} {:width$}",
                 term::PREFIX_WARNING,
                 term::format::dim("… not announced"),
                 width = COLUMN_WIDTH,
             ),
             format_args!(
                 "{} {}",
                 term::format::dim(SYMBOL_STATE_UNKNOWN),
                 term::format::dim("… unknown")
             ),
         );
         term::hint(status);
     }
     Ok(())
 }

     pub fn verdict(v: Option<Verdict>) -> term::Paint<String> {
         match v {
             Some(Verdict::Accept) => term::format::positive("✔".to_string()),
             Some(Verdict::Reject) => term::format::negative("✗".to_string()),
             Some(Verdict::Accept) => term::PREFIX_SUCCESS.into(),
             Some(Verdict::Reject) => term::PREFIX_ERROR.into(),
             None => term::format::dim("-".to_string()),
         }
     }

             Update::Reviewed { review } => {
                 let verdict = review.verdict();
                 let verdict_symbol = match verdict {
                     Some(Verdict::Accept) => term::format::positive("✓"),
                     Some(Verdict::Reject) => term::format::negative("✗"),
                     Some(Verdict::Accept) => term::PREFIX_SUCCESS,
                     Some(Verdict::Reject) => term::PREFIX_ERROR,
                     None => term::format::dim("⋄"),
                 };
                 let verdict_verb = match verdict {

             Update::Merged { author, merge } => {
                 let (alias, nid) = author.labels();
                 term::Line::spaced([
                     term::format::primary("✓").bold().into(),
                     term::PREFIX_SUCCESS.bold().into(),
                     term::format::default("merged by").into(),
                     alias,
                     nid,

             let print_update = || {
                 eprintln!(
                     "{} Canonical reference {} updated to target {kind} {}",
                     term::format::positive("✓"),
                     term::PREFIX_SUCCESS,
                     term::format::secondary(refname),
                     term::format::secondary(oid),
                 )

                     Ok(()) => {
                         eprintln!(
                             "{} Patch {} reverted at revision {}",
                             term::format::yellow("!"),
                             term::PREFIX_WARNING,
                             term::format::tertiary(&id),
                             term::format::dim(term::format::oid(*revision_id)),
                         );
                     }
                     Err(e) => {
                         eprintln!("{} Error reverting patch {id}: {e}", term::ERROR_PREFIX);
                         eprintln!("{} Error reverting patch {id}: {e}", term::PREFIX_ERROR);
                     }
                 }
                 break;

 pub use inquire;
 pub use inquire::Select;
 pub const ERROR_PREFIX: Paint<&str> = Paint::red("✗");
 pub const ERROR_HINT_PREFIX: Paint<&str> = Paint::yellow("✗ Hint:");
 pub const WARNING_PREFIX: Paint<&str> = Paint::yellow("!");
 pub(crate) const SYMBOL_ERROR: &str = "✗";
 pub(crate) const SYMBOL_SUCCESS: &str = "✓";
 pub(crate) const SYMBOL_WARNING: &str = "!";
 pub const PREFIX_ERROR: Paint<&str> = Paint::red(SYMBOL_ERROR);
 pub const PREFIX_SUCCESS: Paint<&str> = Paint::green(SYMBOL_SUCCESS);
 pub const PREFIX_WARNING: Paint<&str> = Paint::yellow(SYMBOL_WARNING);
 pub const TAB: &str = "    ";
 /// Passphrase input.

 pub static CONFIG: LazyLock<RenderConfig> = LazyLock::new(|| RenderConfig {
     prompt: StyleSheet::new().with_fg(Color::LightCyan),
     prompt_prefix: Styled::new("?").with_fg(Color::LightBlue),
     answered_prompt_prefix: Styled::new("✓").with_fg(Color::LightGreen),
     answered_prompt_prefix: Styled::new(SYMBOL_SUCCESS).with_fg(Color::LightGreen),
     answer: StyleSheet::new(),
     highlighted_option_prefix: Styled::new("✓").with_fg(Color::LightYellow),
     highlighted_option_prefix: Styled::new(SYMBOL_SUCCESS).with_fg(Color::LightYellow),
     selected_option: Some(StyleSheet::new().with_fg(Color::LightYellow)),
     option: StyleSheet::new(),
     help_message: StyleSheet::new().with_fg(Color::DarkGrey),
     default_value: StyleSheet::new().with_fg(Color::LightBlue),
     error_message: ErrorMessageRenderConfig::default_colored()
         .with_prefix(Styled::new("✗").with_fg(Color::LightRed)),
         .with_prefix(Styled::new(SYMBOL_ERROR).with_fg(Color::LightRed)),
     ..RenderConfig::default_colored()
 });

 pub use tip;
 pub fn success_args<W: io::Write>(w: &mut W, args: fmt::Arguments) {
     writeln!(w, "{} {args}", Paint::green("✓")).ok();
     writeln!(w, "{PREFIX_SUCCESS} {args}").ok();
 }
 pub fn tip_args(args: fmt::Arguments) {

 }
 pub fn notice_args<W: io::Write>(w: &mut W, args: fmt::Arguments) {
     writeln!(w, "{} {args}", Paint::new("!").dim()).ok();
     writeln!(w, "{} {args}", Paint::new(SYMBOL_WARNING).dim()).ok();
 }
 pub fn columns() -> Option<usize> {

 pub fn usage(name: &str, usage: &str) {
     println!(
         "{} {}\n{}",
         ERROR_PREFIX,
         PREFIX_ERROR,
         Paint::red(format!("Error: rad-{name}: invalid usage")),
         Paint::red(prefixed(TAB, usage)).dim()
     );

 pub fn warning(warning: impl fmt::Display) {
     println!(
         "{} {} {warning}",
         WARNING_PREFIX,
         PREFIX_WARNING,
         Paint::yellow("Warning:").bold(),
     );
 }
 pub fn error(error: impl fmt::Display) {
     println!("{ERROR_PREFIX} {} {error}", Paint::red("Error:"));
     println!("{PREFIX_ERROR} {} {error}", Paint::red("Error:"));
 }
 pub fn hint(hint: impl fmt::Display) {
     println!("{ERROR_HINT_PREFIX} {}", format::hint(hint));
     println!("{}", format::hint(format!("{SYMBOL_ERROR} Hint: {hint}")));
 }
 pub fn ask<D: fmt::Display>(prompt: D, default: bool) -> bool {

 use std::sync::{Arc, Mutex};
 use std::{fmt, io, thread, time};
 use crate::io::{ERROR_PREFIX, WARNING_PREFIX};
 use crate::io::{PREFIX_ERROR, PREFIX_WARNING};
 use crate::Paint;
 /// How much time to wait between spinner animation updates.

                                 write!(animation, "\r{CLEAR_UNTIL_NEWLINE}").ok();
                                 writeln!(
                                     completion,
                                     "{ERROR_PREFIX} {} {}",
                                     "{PREFIX_ERROR} {} {}",
                                     &progress.message,
                                     Paint::red("<canceled>")
                                 )

                             message,
                         } => {
                             write!(animation, "\r{CLEAR_UNTIL_NEWLINE}").ok();
                             writeln!(completion, "{} {message}", Paint::green("✓")).ok();
                             writeln!(completion, "{} {message}", super::PREFIX_SUCCESS).ok();
                             break;
                         }
                         Progress {