cli: Add new `rad inbox` command — heartwood

Shows you updates on local repositories.

Included here is a basic implementation of a notification system. A new database is created and updated after every fetch, with refs that have changed.

The rad inbox command can then list items in the database and delete them.

 ``` ~alice
 $ cd heartwood
 $ rad inbox
 Your inbox is empty.
 ```
 ``` ~bob
 $ cd heartwood
 $ rad issue open --title "No license file" --description "..." -q
 ✓ Synced with 1 node(s)
 $ git commit -m "Change copyright" --allow-empty -q
 $ git push rad HEAD:bob/copy
 $ cd ..
 $ cd radicle-git
 $ git commit -m "Change copyright" --allow-empty -q
 $ git push rad -o patch.message="Copyright fixes" HEAD:refs/patches
 ```
 ``` ~alice
 $ rad inbox --sort-by id
 ╭──────────────────────────────────────────────────────────────╮
 │ heartwood                                                    │
 ├──────────────────────────────────────────────────────────────┤
 │ 1   ●   issue    No license file    [  ..  ]   opened    now │
 │ 2   ●   branch   Change copyright   bob/copy   created   now │
 ╰──────────────────────────────────────────────────────────────╯
 ```
 ``` ~alice
 $ rad inbox --all --sort-by id
 ╭──────────────────────────────────────────────────────────────╮
 │ heartwood                                                    │
 ├──────────────────────────────────────────────────────────────┤
 │ 1   ●   issue    No license file    [  ..  ]   opened    now │
 │ 2   ●   branch   Change copyright   bob/copy   created   now │
 ╰──────────────────────────────────────────────────────────────╯
 ╭──────────────────────────────────────────────────────────╮
 │ radicle-git                                              │
 ├──────────────────────────────────────────────────────────┤
 │ 3   ●   patch   Copyright fixes   [ ... ]   opened   now │
 ╰──────────────────────────────────────────────────────────╯
 ```
 ``` ~alice
 $ rad inbox show 2
 commit 141c9073066e3910f1dfe356904a0120542e1cc9
 Author: radicle <radicle@localhost>
 Date:   Thu Dec 15 17:28:04 2022 +0000
     Change copyright
 commit f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354
 Author: anonymous <anonymous@radicle.xyz>
 Date:   Mon Jan 1 14:39:16 2018 +0000
     Second commit
 commit 08c788dd1be6315de09e3fe09b5b1b7a2b8711d9
 Author: anonymous <anonymous@radicle.xyz>
 Date:   Mon Jan 1 14:39:16 2018 +0000
     Initial commit
 ```
 ``` ~alice
 $ rad inbox list --sort-by id
 ╭──────────────────────────────────────────────────────────────╮
 │ heartwood                                                    │
 ├──────────────────────────────────────────────────────────────┤
 │ 1   ●   issue    No license file    [ ... ]    opened    now │
 │ 2       branch   Change copyright   bob/copy   created   now │
 ╰──────────────────────────────────────────────────────────────╯
 ```
 ``` ~alice
 $ rad inbox show 1
 ╭──────────────────────────────────────────────────╮
 │ Title   No license file                          │
 │ Issue   [ ...                                  ] │
 │ Author  bob z6Mkt67…v4N1tRk                      │
 │ Status  open                                     │
 │                                                  │
 │ ...                                              │
 ╰──────────────────────────────────────────────────╯
 ```
 ``` ~alice
 $ rad inbox clear
 ✓ Cleared 2 item(s) from your inbox
 $ rad inbox
 Your inbox is empty.
 $ rad inbox --all
 ╭──────────────────────────────────────────────────────────╮
 │ radicle-git                                              │
 ├──────────────────────────────────────────────────────────┤
 │ 3   ●   patch   Copyright fixes   [ ... ]   opened   now │
 ╰──────────────────────────────────────────────────────────╯
 ```
 ``` ~alice
 $ rad inbox clear --all
 ✓ Cleared 1 item(s) from your inbox
 ```
 ``` ~alice
 $ rad inbox clear --all
 Your inbox is empty.
 ```

 The contributor's changes are now visible to us.
 ```
 $ rad inbox --sort-by id
 ╭──────────────────────────────────────────────────────────────────────╮
 │ heartwood                                                            │
 ├──────────────────────────────────────────────────────────────────────┤
 │ 1   ●   issue   flux capacitor underpowered   d060989   opened   now │
 │ 2   ●   patch   Define power requirements     a99d55e   opened   now │
 ╰──────────────────────────────────────────────────────────────────────╯
 $ git branch -r
   bob/patches/a99d55e5958a8c52ff7efbc8ff000d9bbdac79c7
   rad/master

 pub mod rad_help;
 #[path = "commands/id.rs"]
 pub mod rad_id;
 #[path = "commands/inbox.rs"]
 pub mod rad_inbox;
 #[path = "commands/init.rs"]
 pub mod rad_init;
 #[path = "commands/inspect.rs"]

 mod checkout;
 #[path = "patch/comment.rs"]
 mod comment;
 #[path = "patch/common.rs"]
 mod common;
 #[path = "patch/delete.rs"]
 mod delete;
 #[path = "patch/diff.rs"]

 use anyhow::anyhow;
 use radicle::git;
 use radicle::git::raw::Oid;
 use radicle::prelude::*;
 use radicle::storage::git::Repository;
 use crate::terminal as term;
 /// Give the oid of the branch or an appropriate error.
 #[inline]
 pub fn branch_oid(branch: &git::raw::Branch) -> anyhow::Result<git::Oid> {
     let oid = branch
         .get()
         .target()
         .ok_or(anyhow!("invalid HEAD ref; aborting"))?;
     Ok(oid.into())
 }
 #[inline]
 fn get_branch(git_ref: git::Qualified) -> git::RefString {
     let (_, _, head, tail) = git_ref.non_empty_components();
     std::iter::once(head).chain(tail).collect()
 }
 /// Determine the merge target for this patch. This can be any followed remote's "default" branch,
 /// as well as your own (eg. `rad/master`).
 pub fn get_merge_target(
     storage: &Repository,
     head_branch: &git::raw::Branch,
 ) -> anyhow::Result<(git::RefString, git::Oid)> {
     let (qualified_ref, target_oid) = storage.canonical_head()?;
     let head_oid = branch_oid(head_branch)?;
     let merge_base = storage.raw().merge_base(*head_oid, *target_oid)?;
     if head_oid == merge_base.into() {
         anyhow::bail!("commits are already included in the target branch; nothing to do");
     }
     Ok((get_branch(qualified_ref), (*target_oid).into()))
 }
 /// Get the diff stats between two commits.
 /// Should match the default output of `git diff <old> <new> --stat` exactly.
 pub fn diff_stats(
     repo: &git::raw::Repository,
     old: &Oid,
     new: &Oid,
 ) -> Result<git::raw::DiffStats, git::raw::Error> {
     let old = repo.find_commit(*old)?;
     let new = repo.find_commit(*new)?;
     let old_tree = old.tree()?;
     let new_tree = new.tree()?;
     let mut diff = repo.diff_tree_to_tree(Some(&old_tree), Some(&new_tree), None)?;
     let mut find_opts = git::raw::DiffFindOptions::new();
     diff.find_similar(Some(&mut find_opts))?;
     diff.stats()
 }
 /// Create a human friendly message about git's sync status.
 pub fn ahead_behind(
     repo: &git::raw::Repository,
     revision_oid: Oid,
     head_oid: Oid,
 ) -> anyhow::Result<term::Line> {
     let (a, b) = repo.graph_ahead_behind(revision_oid, head_oid)?;
     if a == 0 && b == 0 {
         return Ok(term::Line::new(term::format::dim("up to date")));
     }
     let ahead = term::format::positive(a);
     let behind = term::format::negative(b);
     Ok(term::Line::default()
         .item("ahead ")
         .item(ahead)
         .item(", behind ")
         .item(behind))
 }
 /// Get the branches that point to a commit.
 pub fn branches(target: &Oid, repo: &git::raw::Repository) -> anyhow::Result<Vec<String>> {
     let mut branches: Vec<String> = vec![];
     for r in repo.references()?.flatten() {
         if !r.is_branch() {
             continue;
         }
         if let (Some(oid), Some(name)) = (&r.target(), &r.shorthand()) {
             if oid == target {
                 branches.push(name.to_string());
             };
         };
     }
     Ok(branches)
 }
 #[inline]
 pub fn try_branch(reference: git::raw::Reference<'_>) -> anyhow::Result<git::raw::Branch> {
     let branch = if reference.is_branch() {
         git::raw::Branch::wrap(reference)
     } else {
         anyhow::bail!("cannot create patch from detached head; aborting")
     };
     Ok(branch)
 }

 use std::ffi::OsString;
 use std::process;
 use anyhow::anyhow;
 use localtime::LocalTime;
 use radicle::issue::Issues;
 use radicle::node::notifications;
 use radicle::node::notifications::*;
 use radicle::patch::Patches;
 use radicle::prelude::{Profile, RepoId};
 use radicle::storage::RefUpdate;
 use radicle::storage::{ReadRepository, ReadStorage};
 use radicle::{cob, Storage};
 use term::Element as _;
 use crate::terminal as term;
 use crate::terminal::args;
 use crate::terminal::args::{Args, Error, Help};
 pub const HELP: Help = Help {
     name: "inbox",
     description: "Manage your Radicle notifications inbox",
     version: env!("CARGO_PKG_VERSION"),
     usage: r#"
 Usage
     rad inbox [<option>...]
     rad inbox list [<option>...]
     rad inbox clear [<option>...]
     By default, this command lists all items in your inbox.
     If your working directory is a Radicle repository, it only shows item
     belonging to this repository, unless `--all` is used.
 Options
     --all                Operate on all repositories
     --repo <rid>         Operate on the given repository (default: rad .)
     --sort-by <field>    Sort by `id` or `timestamp` (default: timestamp)
     --reverse, -r        Reverse the list
     --help               Print help
 "#,
 };
 #[derive(Debug, Default, PartialEq, Eq)]
 enum Operation {
     #[default]
     List,
     Show,
     Clear,
 }
 #[derive(Default, Debug)]
 enum Mode {
     #[default]
     Contextual,
     All,
     ById(Vec<NotificationId>),
     ByRepo(RepoId),
 }
 #[derive(Clone, Copy, Debug)]
 struct SortBy {
     reverse: bool,
     field: &'static str,
 }
 pub struct Options {
     op: Operation,
     mode: Mode,
     sort_by: SortBy,
 }
 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<Operation> = None;
         let mut mode = None;
         let mut ids = Vec::new();
         let mut reverse = None;
         let mut field = None;
         while let Some(arg) = parser.next()? {
             match arg {
                 Long("help") | Short('h') => {
                     return Err(Error::Help.into());
                 }
                 Long("all") | Short('a') if mode.is_none() => {
                     mode = Some(Mode::All);
                 }
                 Long("reverse") | Short('r') => {
                     reverse = Some(true);
                 }
                 Long("sort-by") => {
                     let val = parser.value()?;
                     match term::args::string(&val).as_str() {
                         "timestamp" => field = Some("timestamp"),
                         "id" => field = Some("rowid"),
                         other => {
                             return Err(anyhow!(
                                 "unknown sorting field `{other}`, see `rad inbox --help`"
                             ))
                         }
                     }
                 }
                 Long("repo") if mode.is_none() && op.is_some() => {
                     let val = parser.value()?;
                     let repo = args::rid(&val)?;
                     mode = Some(Mode::ByRepo(repo));
                 }
                 Value(val) if op.is_none() => match val.to_string_lossy().as_ref() {
                     "list" => op = Some(Operation::List),
                     "show" => op = Some(Operation::Show),
                     "clear" => op = Some(Operation::Clear),
                     cmd => return Err(anyhow!("unknown command `{cmd}`, see `rad inbox --help`")),
                 },
                 Value(val) if op.is_some() && mode.is_none() => {
                     let id = term::args::number(&val)? as NotificationId;
                     ids.push(id);
                 }
                 _ => return Err(anyhow::anyhow!(arg.unexpected())),
             }
         }
         let mode = if ids.is_empty() {
             mode.unwrap_or_default()
         } else {
             Mode::ById(ids)
         };
         let op = op.unwrap_or_default();
         let sort_by = if let Some(field) = field {
             SortBy {
                 field,
                 reverse: reverse.unwrap_or(false),
             }
         } else {
             SortBy {
                 field: "timestamp",
                 reverse: true,
             }
         };
         Ok((Options { op, mode, sort_by }, vec![]))
     }
 }
 pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
     let profile = ctx.profile()?;
     let storage = &profile.storage;
     let mut notifs = profile.notifications_mut()?;
     let Options { op, mode, sort_by } = options;
     match op {
         Operation::List => list(mode, sort_by, &notifs.read_only(), storage),
         Operation::Clear => clear(mode, &mut notifs),
         Operation::Show => show(mode, &mut notifs, storage, &profile),
     }
 }
 fn list(
     mode: Mode,
     sort_by: SortBy,
     notifs: &notifications::StoreReader,
     storage: &Storage,
 ) -> anyhow::Result<()> {
     let repos: Vec<term::VStack<'_>> = match mode {
         Mode::Contextual => {
             if let Ok((_, rid)) = radicle::rad::cwd() {
                 list_repo(rid, sort_by, notifs, storage)?
                     .into_iter()
                     .collect()
             } else {
                 list_all(sort_by, notifs, storage)?
             }
         }
         Mode::ByRepo(rid) => list_repo(rid, sort_by, notifs, storage)?
             .into_iter()
             .collect(),
         Mode::All => list_all(sort_by, notifs, storage)?,
         Mode::ById(_) => anyhow::bail!("the `list` command does not take IDs"),
     };
     if repos.is_empty() {
         term::print(term::format::italic("Your inbox is empty."));
     } else {
         for repo in repos {
             repo.print();
         }
     }
     Ok(())
 }
 fn list_all<'a>(
     sort_by: SortBy,
     notifs: &notifications::StoreReader,
     storage: &Storage,
 ) -> anyhow::Result<Vec<term::VStack<'a>>> {
     let mut repos = Vec::new();
     for repo in storage.repositories()? {
         let repo = list_repo(repo.rid, sort_by, notifs, storage)?;
         repos.extend(repo.into_iter());
     }
     Ok(repos)
 }
 fn list_repo<'a, R: ReadStorage>(
     rid: RepoId,
     sort_by: SortBy,
     notifs: &notifications::StoreReader,
     storage: &R,
 ) -> anyhow::Result<Option<term::VStack<'a>>>
 where
     <R as ReadStorage>::Repository: cob::Store,
 {
     let mut table = term::Table::new(term::TableOptions {
         spacing: 3,
         ..term::TableOptions::default()
     });
     let repo = storage.repository(rid)?;
     let doc = repo.identity_doc()?;
     let proj = doc.project()?;
     let issues = Issues::open(&repo)?;
     let patches = Patches::open(&repo)?;
     let mut notifs = notifs.by_repo(&rid, sort_by.field)?.collect::<Vec<_>>();
     if !sort_by.reverse {
         // Notifications are returned in descendant order by default.
         notifs.reverse();
     }
     for n in notifs {
         let n: Notification = n?;
         let seen = if n.status.is_read() {
             term::Label::blank()
         } else {
             term::format::tertiary(String::from("●")).into()
         };
         let (category, summary, status, name) = match n.kind {
             NotificationKind::Branch { name } => {
                 let commit = if let Some(head) = n.update.new() {
                     repo.commit(head)?.summary().unwrap_or_default().to_owned()
                 } else {
                     String::new()
                 };
                 let status = match n.update {
                     RefUpdate::Updated { .. } => "updated",
                     RefUpdate::Created { .. } => "created",
                     RefUpdate::Deleted { .. } => "deleted",
                     RefUpdate::Skipped { .. } => "skipped",
                 };
                 ("branch".to_string(), commit, status, name.to_string())
             }
             NotificationKind::Cob { type_name, id } => {
                 let (category, summary) = if type_name == *cob::issue::TYPENAME {
                     let issue = issues.get(&id)?.ok_or(anyhow!("missing"))?;
                     (String::from("issue"), issue.title().to_owned())
                 } else if type_name == *cob::patch::TYPENAME {
                     let patch = patches.get(&id)?.ok_or(anyhow!("missing"))?;
                     (String::from("patch"), patch.title().to_owned())
                 } else {
                     (type_name.to_string(), "".to_owned())
                 };
                 let status = match n.update {
                     RefUpdate::Updated { .. } => "updated",
                     RefUpdate::Created { .. } => "opened",
                     RefUpdate::Deleted { .. } => "deleted",
                     RefUpdate::Skipped { .. } => "skipped",
                 };
                 (category, summary, status, term::format::cob(&id))
             }
         };
         table.push([
             n.id.to_string().into(),
             seen,
             category.into(),
             summary.into(),
             name.into(),
             status.into(),
             term::format::timestamp(n.timestamp).into(),
         ]);
     }
     if table.is_empty() {
         Ok(None)
     } else {
         Ok(Some(
             term::VStack::default()
                 .border(Some(term::colors::FAINT))
                 .child(term::label(proj.name()))
                 .divider()
                 .child(table),
         ))
     }
 }
 fn clear(mode: Mode, notifs: &mut notifications::StoreWriter) -> anyhow::Result<()> {
     let cleared = match mode {
         Mode::All => notifs.clear_all()?,
         Mode::ById(ids) => notifs.clear(&ids)?,
         Mode::ByRepo(rid) => notifs.clear_by_repo(&rid)?,
         Mode::Contextual => {
             if let Ok((_, rid)) = radicle::rad::cwd() {
                 notifs.clear_by_repo(&rid)?
             } else {
                 return Err(Error::WithHint {
                     err: anyhow!("not a radicle repository"),
                     hint: "to clear all repository notifications, use the `--all` flag",
                 }
                 .into());
             }
         }
     };
     if cleared > 0 {
         term::success!("Cleared {cleared} item(s) from your inbox");
     } else {
         term::print(term::format::italic("Your inbox is empty."));
     }
     Ok(())
 }
 fn show(
     mode: Mode,
     notifs: &mut notifications::StoreWriter,
     storage: &Storage,
     profile: &Profile,
 ) -> anyhow::Result<()> {
     let id = match mode {
         Mode::ById(ids) => match ids.as_slice() {
             [id] => *id,
             [] => anyhow::bail!("a Notification ID must be given"),
             _ => anyhow::bail!("too many Notification IDs given"),
         },
         _ => anyhow::bail!("a Notification ID must be given"),
     };
     let n = notifs.get(id)?;
     let repo = storage.repository(n.repo)?;
     match n.kind {
         NotificationKind::Cob { type_name, id } if type_name == *cob::issue::TYPENAME => {
             let issues = Issues::open(&repo)?;
             let issue = issues.get(&id)?.unwrap();
             term::issue::show(&issue, &id, term::issue::Format::default(), profile)?;
         }
         NotificationKind::Cob { type_name, id } if type_name == *cob::patch::TYPENAME => {
             let patches = Patches::open(&repo)?;
             let patch = patches.get(&id)?.unwrap();
             term::patch::show(&patch, &id, false, &repo, None, profile)?;
         }
         NotificationKind::Branch { .. } => {
             let refstr = if let Some(remote) = n.remote {
                 n.qualified
                     .with_namespace(remote.to_component())
                     .to_string()
             } else {
                 n.qualified.to_string()
             };
             process::Command::new("git")
                 .current_dir(repo.path())
                 .args(["log", refstr.as_str()])
                 .spawn()?
                 .wait()?;
         }
         _ => {
             todo!();
         }
     }
     notifs.set_status(NotificationStatus::ReadAt(LocalTime::now()), &[id])?;
     Ok(())
 }

 use std::collections::BTreeSet;
 use std::iter;
 use radicle::cob;
 use radicle::cob::patch;
 use radicle::cob::patch::{Patch, PatchId, Patches, Verdict};
 use radicle::git;
 use radicle::patch::{Merge, Review, Revision, RevisionId};
 use radicle::cob::patch::{Patch, PatchId, Patches};
 use radicle::prelude::*;
 use radicle::profile::Profile;
 use radicle::storage::git::Repository;

 use term::table::{Table, TableOptions};
 use term::Element as _;
 use super::common;
 use crate::terminal as term;
 use crate::terminal::patch as common;
 /// List patches.
 pub fn run(

             .into(),
     ])
 }
 pub fn timeline<'a>(
     profile: &'a Profile,
     patch: &'a Patch,
 ) -> impl Iterator<Item = term::Line> + 'a {
     Timeline::build(profile, patch).into_lines(profile)
 }
 /// The timeline of a [`Patch`].
 ///
 /// A `Patch` will always have opened with a root revision and may
 /// have a series of revisions that update the patch.
 ///
 /// The function, [`timeline`], builds a `Timeline` and converts it
 /// into a series of [`term::Line`]s.
 struct Timeline<'a> {
     opened: Opened<'a>,
     revisions: Vec<RevisionEntry<'a>>,
 }
 impl<'a> Timeline<'a> {
     fn build(profile: &Profile, patch: &'a Patch) -> Self {
         let opened = Opened::from_patch(patch, profile);
         let mut revisions = patch
             .revisions()
             .skip(1) // skip the root revision since it's handled in `Opened::from_patch`
             .map(|(id, revision)| {
                 (
                     revision.timestamp(),
                     RevisionEntry::from_revision(patch, id, revision, profile),
                 )
             })
             .collect::<Vec<_>>();
         revisions.sort_by_key(|(t, _)| *t);
         Timeline {
             opened,
             revisions: revisions.into_iter().map(|(_, e)| e).collect(),
         }
     }
     fn into_lines(self, profile: &'a Profile) -> impl Iterator<Item = term::Line> + 'a {
         self.opened.into_lines(profile).chain(
             self.revisions
                 .into_iter()
                 .flat_map(|r| r.into_lines(profile)),
         )
     }
 }
 /// The root `Revision` of the `Patch`.
 struct Opened<'a> {
     /// The `Author` of the patch.
     author: Author<'a>,
     /// When the patch was created.
     timestamp: cob::Timestamp,
     /// The commit head of the `Revision`.
     head: git::Oid,
     /// Any updates performed on the root `Revision`.
     updates: Vec<Update<'a>>,
 }
 impl<'a> Opened<'a> {
     fn from_patch(patch: &'a Patch, profile: &Profile) -> Self {
         let (root, revision) = patch.root();
         let mut updates = Vec::new();
         updates.extend(revision.reviews().map(|(_, review)| {
             (
                 review.timestamp(),
                 Update::Reviewed {
                     review: review.clone(),
                 },
             )
         }));
         updates.extend(patch.merges().filter_map(|(_, merge)| {
             if merge.revision == root {
                 Some((
                     merge.timestamp,
                     Update::Merged {
                         author: Author::new(&revision.author().id, profile),
                         merge: merge.clone(),
                     },
                 ))
             } else {
                 None
             }
         }));
         updates.sort_by_key(|(t, _)| *t);
         Opened {
             author: Author::new(&patch.author().id, profile),
             timestamp: patch.timestamp(),
             head: revision.head(),
             updates: updates.into_iter().map(|(_, up)| up).collect(),
         }
     }
     fn into_lines(self, profile: &'a Profile) -> impl Iterator<Item = term::Line> + 'a {
         iter::once(
             term::Line::spaced([
                 term::format::positive("●").into(),
                 term::format::default("opened by").into(),
             ])
             .space()
             .extend(self.author.line())
             .space()
             .extend(term::Line::spaced([
                 term::format::parens(term::format::secondary(term::format::oid(self.head))).into(),
                 term::format::dim(term::format::timestamp(self.timestamp)).into(),
             ])),
         )
         .chain(self.updates.into_iter().map(|up| {
             term::Line::spaced([term::Label::space(), term::Label::from("└─ ")])
                 .extend(up.into_line(profile))
         }))
     }
 }
 /// A revision entry in the [`Timeline`].
 enum RevisionEntry<'a> {
     /// An `Updated` entry means that the original author of the
     /// `Patch` created a new revision.
     Updated {
         /// When the `Revision` was created.
         timestamp: cob::Timestamp,
         /// The id of the `Revision`.
         id: RevisionId,
         /// The commit head of the `Revision`.
         head: git::Oid,
         /// All [`Update`]s that occurred on the `Revision`.
         updates: Vec<Update<'a>>,
     },
     /// A `Revised` entry means that an author other than the original
     /// author of the `Patch` created a new revision.
     Revised {
         /// The `Author` that created the `Revision` (that is not the
         /// `Patch` author).
         author: Author<'a>,
         /// When the `Revision` was created.
         timestamp: cob::Timestamp,
         /// The id of the `Revision`.
         id: RevisionId,
         /// The commit head of the `Revision`.
         head: git::Oid,
         /// All [`Update`]s that occurred on the `Revision`.
         updates: Vec<Update<'a>>,
     },
 }
 impl<'a> RevisionEntry<'a> {
     fn from_revision(
         patch: &Patch,
         id: RevisionId,
         revision: &'a Revision,
         profile: &Profile,
     ) -> Self {
         let mut updates = Vec::new();
         updates.extend(revision.reviews().map(|(_, review)| {
             (
                 review.timestamp(),
                 Update::Reviewed {
                     review: review.clone(),
                 },
             )
         }));
         updates.extend(patch.merges().filter_map(|(_, merge)| {
             if merge.revision == id {
                 Some((
                     merge.timestamp,
                     Update::Merged {
                         author: Author::new(&revision.author().id, profile),
                         merge: merge.clone(),
                     },
                 ))
             } else {
                 None
             }
         }));
         updates.sort_by_key(|(t, _)| *t);
         if revision.author() == patch.author() {
             RevisionEntry::Updated {
                 timestamp: revision.timestamp(),
                 id,
                 head: revision.head(),
                 updates: updates.into_iter().map(|(_, up)| up).collect(),
             }
         } else {
             RevisionEntry::Revised {
                 author: Author::new(&revision.author().id, profile),
                 timestamp: revision.timestamp(),
                 id,
                 head: revision.head(),
                 updates: updates.into_iter().map(|(_, up)| up).collect(),
             }
         }
     }
     fn into_lines(self, profile: &'a Profile) -> Vec<term::Line> {
         match self {
             RevisionEntry::Updated {
                 timestamp,
                 id,
                 head,
                 updates,
             } => Self::updated(profile, timestamp, id, head, updates).collect(),
             RevisionEntry::Revised {
                 author,
                 timestamp,
                 id,
                 head,
                 updates,
             } => Self::revised(profile, author, timestamp, id, head, updates).collect(),
         }
     }
     fn updated(
         profile: &'a Profile,
         timestamp: cob::Timestamp,
         id: RevisionId,
         head: git::Oid,
         updates: Vec<Update<'a>>,
     ) -> impl Iterator<Item = term::Line> + 'a {
         iter::once(term::Line::spaced([
             term::format::tertiary("↑").into(),
             term::format::default("updated to").into(),
             term::format::dim(id).into(),
             term::format::parens(term::format::secondary(term::format::oid(head))).into(),
             term::format::dim(term::format::timestamp(timestamp)).into(),
         ]))
         .chain(updates.into_iter().map(|up| {
             term::Line::spaced([term::Label::space(), term::Label::from("└─ ")])
                 .extend(up.into_line(profile))
         }))
     }
     fn revised(
         profile: &'a Profile,
         author: Author<'a>,
         timestamp: cob::Timestamp,
         id: RevisionId,
         head: git::Oid,
         updates: Vec<Update<'a>>,
     ) -> impl Iterator<Item = term::Line> + 'a {
         let (alias, nid) = author.labels();
         iter::once(term::Line::spaced([
             term::format::tertiary("*").into(),
             term::format::default("revised by").into(),
             alias,
             nid,
             term::format::default("in").into(),
             term::format::dim(term::format::oid(id)).into(),
             term::format::parens(term::format::secondary(term::format::oid(head))).into(),
             term::format::dim(term::format::timestamp(timestamp)).into(),
         ]))
         .chain(updates.into_iter().map(|up| {
             term::Line::spaced([term::Label::space(), term::Label::from("└─ ")])
                 .extend(up.into_line(profile))
         }))
     }
 }
 /// An update in the [`Patch`]'s timeline.
 enum Update<'a> {
     /// A revision of the patch was reviewed.
     Reviewed { review: Review },
     /// A revision of the patch was merged.
     Merged { author: Author<'a>, merge: Merge },
 }
 impl<'a> Update<'a> {
     fn timestamp(&self) -> cob::Timestamp {
         match self {
             Update::Reviewed { review } => review.timestamp(),
             Update::Merged { merge, .. } => merge.timestamp,
         }
     }
     fn into_line(self, profile: &Profile) -> term::Line {
         let timestamp = self.timestamp();
         let mut line = match self {
             Update::Reviewed { review } => {
                 let verdict = review.verdict();
                 let verdict_symbol = match verdict {
                     Some(Verdict::Accept) => term::format::positive("✓"),
                     Some(Verdict::Reject) => term::format::negative("✗"),
                     None => term::format::dim("⋄"),
                 };
                 let verdict_verb = match verdict {
                     Some(Verdict::Accept) => term::format::default("accepted"),
                     Some(Verdict::Reject) => term::format::default("rejected"),
                     None => term::format::default("reviewed"),
                 };
                 term::Line::spaced([
                     verdict_symbol.into(),
                     verdict_verb.into(),
                     term::format::default("by").into(),
                 ])
                 .space()
                 .extend(Author::new(&review.author().id.into(), profile).line())
             }
             Update::Merged { author, merge } => {
                 let (alias, nid) = author.labels();
                 term::Line::spaced([
                     term::format::primary("✓").bold().into(),
                     term::format::default("merged by").into(),
                     alias,
                     nid,
                     term::format::default("at revision").into(),
                     term::format::dim(term::format::oid(merge.revision)).into(),
                     term::format::parens(term::format::secondary(term::format::oid(merge.commit)))
                         .into(),
                 ])
             }
         };
         line.push(term::Label::space());
         line.push(term::format::dim(term::format::timestamp(timestamp)));
         line
     }
 }

     Ok(())
 }
 fn patch_commits(patch: &patch::Patch, stored: &Repository) -> anyhow::Result<Vec<term::Line>> {
     let (from, to) = patch.range()?;
     let range = format!("{}..{}", from, to);
     let mut revwalk = stored.revwalk(*patch.head())?;
     let mut lines = Vec::new();
     revwalk.push_range(&range)?;
     for commit in revwalk {
         let commit = commit?;
         let commit = stored.raw().find_commit(commit)?;
         lines.push(term::Line::spaced([
             term::label(term::format::secondary::<String>(
                 term::format::oid(commit.id()).into(),
             )),
             term::label(term::format::default(
                 commit.summary().unwrap_or_default().to_owned(),
             )),
         ]));
     }
     Ok(lines)
 }
 pub fn run(
     patch_id: &PatchId,
     diff: bool,

         println!("{:#?}", patch);
         return Ok(());
     }
     let (_, revision) = patch.latest();
     let state = patch.state();
     let branches = common::branches(&revision.head(), workdir)?;
     let ahead_behind = common::ahead_behind(
         stored.raw(),
         *revision.head(),
         *patch.target().head(stored)?,
     )?;
     let author = patch.author();
     let author = term::format::Author::new(author.id(), profile);
     let labels = patch.labels().map(|l| l.to_string()).collect::<Vec<_>>();
     let mut attrs = Table::<2, term::Line>::new(TableOptions {
         spacing: 2,
         ..TableOptions::default()
     });
     attrs.push([
         term::format::tertiary("Title".to_owned()).into(),
         term::format::bold(patch.title().to_owned()).into(),
     ]);
     attrs.push([
         term::format::tertiary("Patch".to_owned()).into(),
         term::format::default(patch_id.to_string()).into(),
     ]);
     attrs.push([
         term::format::tertiary("Author".to_owned()).into(),
         author.line(),
     ]);
     if !labels.is_empty() {
         attrs.push([
             term::format::tertiary("Labels".to_owned()).into(),
             term::format::secondary(labels.join(", ")).into(),
         ]);
     }
     attrs.push([
         term::format::tertiary("Head".to_owned()).into(),
         term::format::secondary(revision.head().to_string()).into(),
     ]);
     if verbose {
         attrs.push([
             term::format::tertiary("Base".to_owned()).into(),
             term::format::secondary(revision.base().to_string()).into(),
         ]);
     }
     if !branches.is_empty() {
         attrs.push([
             term::format::tertiary("Branches".to_owned()).into(),
             term::format::yellow(branches.join(", ")).into(),
         ]);
     }
     attrs.push([
         term::format::tertiary("Commits".to_owned()).into(),
         ahead_behind,
     ]);
     attrs.push([
         term::format::tertiary("Status".to_owned()).into(),
         match state {
             patch::State::Open { .. } => term::format::positive(state.to_string()),
             patch::State::Draft => term::format::dim(state.to_string()),
             patch::State::Archived => term::format::yellow(state.to_string()),
             patch::State::Merged { .. } => term::format::primary(state.to_string()),
         }
         .into(),
     ]);
     let commits = patch_commits(&patch, stored)?;
     let description = patch.description().trim();
     let mut widget = VStack::default()
         .border(Some(term::colors::FAINT))
         .child(attrs)
         .children(if !description.is_empty() {
             vec![term::Label::blank().boxed(), textarea(description).boxed()]
         } else {
             vec![]
         })
         .divider()
         .children(commits.into_iter().map(|l| l.boxed()))
         .divider();
     for line in list::timeline(profile, &patch) {
         widget.push(line);
     }
     widget.print();
     term::patch::show(&patch, patch_id, verbose, stored, Some(workdir), profile)?;
     if diff {
         term::blank();

         "id" => {
             term::run_command_args::<rad_id::Options, _>(rad_id::HELP, rad_id::run, args.to_vec());
         }
         "inbox" => term::run_command_args::<rad_inbox::Options, _>(
             rad_inbox::HELP,
             rad_inbox::run,
             args.to_vec(),
         ),
         "init" => {
             term::run_command_args::<rad_init::Options, _>(
                 rad_init::HELP,

 mod common;
 mod timeline;
 use std::fmt;
 use std::fmt::Write;
 use std::io;

 use radicle::cob;
 use radicle::cob::patch;
 use radicle::git;
 use radicle::patch::{Patch, PatchId};
 use radicle::prelude::Profile;
 use radicle::storage::git::Repository;
 use radicle::storage::WriteRepository as _;
 use crate::terminal as term;
 use crate::terminal::Element;
 pub use common::*;
 #[derive(Debug, Error)]
 pub enum Error {
     #[error(transparent)]

 }
 #[test]
 fn rad_inbox() {
     let mut environment = Environment::new();
     let mut alice = environment.node(Config::test(Alias::new("alice")));
     let bob = environment.node(Config::test(Alias::new("bob")));
     let working = environment.tmp().join("working");
     let (repo1, _) = fixtures::repository(working.join("alice").join("heartwood"));
     let (repo2, _) = fixtures::repository(working.join("alice").join("radicle-git"));
     let rid1 = alice.project_from("heartwood", "Radicle Heartwood Protocol & Stack", &repo1);
     let rid2 = alice.project_from("radicle-git", "Radicle Git", &repo2);
     let alice = alice.spawn();
     let mut bob = bob.spawn();
     bob.connect(&alice).converge([&alice]);
     bob.clone(rid1, working.join("bob")).unwrap();
     bob.clone(rid2, working.join("bob")).unwrap();
     formula(&environment.tmp(), "examples/rad-inbox.md")
         .unwrap()
         .home(
             "alice",
             working.join("alice"),
             [("RAD_HOME", alice.home.path().display())],
         )
         .home(
             "bob",
             working.join("bob"),
             [("RAD_HOME", bob.home.path().display())],
         )
         .run()
         .unwrap();
 }
 #[test]
 fn rad_patch_fetch_2() {
     let mut environment = Environment::new();
     let alice = environment.node(Config::test(Alias::new("alice")));

     }
     #[cfg(feature = "radicle-git-ext")]
     pub fn to_component(&self) -> radicle_git_ext::ref_format::Component {
         radicle_git_ext::ref_format::Component::from(self)
     }
     #[cfg(feature = "radicle-git-ext")]
     pub fn from_namespaced(
         refstr: &radicle_git_ext::ref_format::Namespaced,
     ) -> Result<Self, PublicKeyError> {

 use radicle::node;
 use radicle::node::address;
 use radicle::node::address::Store as _;
 use radicle::node::notifications;
 use radicle::node::Handle as _;
 use radicle::profile::Home;
 use radicle::Storage;

 use crate::node::{routing, NodeId};
 use crate::service::message::NodeAnnouncement;
 use crate::service::{gossip, policy, Event};
 use crate::wire::Wire;
 use crate::wire::{self, Decode};
 use crate::wire;
 use crate::wire::{Decode, Wire};
 use crate::worker;
 use crate::{service, LocalTime};

     /// A policies database error.
     #[error("policies database error: {0}")]
     Policy(#[from] policy::Error),
     /// A notifications database error.
     #[error("notifications database error: {0}")]
     Notifications(#[from] notifications::Error),
     /// A gossip database error.
     #[error("gossip database error: {0}")]
     Gossip(#[from] gossip::Error),

         log::info!(target: "node", "Opening policy database..");
         let policies = home.policies_mut()?;
         let policies = policy::Config::new(policy, scope, policies);
         let notifications = home.notifications_mut()?;
         log::info!(target: "node", "Default seeding policy set to '{}'", &policy);
         log::info!(target: "node", "Initializing service ({:?})..", network);

         }
         let reactor = Reactor::named(wire, popol::Poller::new(), thread::name(&id, "service"))?;
         let handle = Handle::new(home.clone(), reactor.controller(), emitter);
         let atomic = git::version()? >= git::VERSION_REQUIRED;
         if !atomic {
             log::warn!(
                 target: "node",
                 "Disabling atomic fetches; git version >= {} required", git::VERSION_REQUIRED
             );
         }
         let nid = *signer.public_key();
         let fetch = worker::FetchConfig {

             worker_recv,
             nid,
             handle.clone(),
             notifications,
             worker::Config {
                 capacity: 8,
                 timeout: time::Duration::from_secs(9),

         .map(|(id, _, _)| id)
         .unwrap();
         assert!(self
             .policies
             .seed(&id, node::policy::Scope::Followed)
             .unwrap());
         assert!(self.policies.seed(&id, node::policy::Scope::All).unwrap());
         log::debug!(
             target: "test",

 use crossbeam_channel as chan;
 use radicle::identity::RepoId;
 use radicle::node::notifications;
 use radicle::prelude::NodeId;
 use radicle::storage::refs::RefsAt;
 use radicle::storage::{ReadRepository, ReadStorage};

     tasks: chan::Receiver<Task>,
     handle: Handle,
     policies: policy::Config<policy::store::Read>,
     notifications: notifications::StoreWriter,
 }
 impl Worker {

         } = task;
         let remote = fetch.remote();
         let channels = channels::ChannelsFlush::new(self.handle.clone(), channels, remote, stream);
         let result = self._process(fetch, stream, channels);
         let result = self._process(fetch, stream, channels, self.notifications.clone());
         log::trace!(target: "worker", "Sending response back to service..");

         fetch: FetchRequest,
         stream: StreamId,
         mut channels: channels::ChannelsFlush,
         notifs: notifications::StoreWriter,
     ) -> FetchResult {
         match fetch {
             FetchRequest::Initiator {

                 timeout: _timeout,
             } => {
                 log::debug!(target: "worker", "Worker processing outgoing fetch for {rid}");
                 let result = self.fetch(rid, remote, refs_at, channels);
                 let result = self.fetch(rid, remote, refs_at, channels, notifs);
                 FetchResult::Initiator { rid, result }
             }
             FetchRequest::Responder { remote } => {

         remote: NodeId,
         refs_at: Option<Vec<RefsAt>>,
         channels: channels::ChannelsFlush,
         notifs: notifications::StoreWriter,
     ) -> Result<fetch::FetchResult, FetchError> {
         let FetchConfig {
             limit,

         let allowed = radicle_fetch::Allowed::from_config(rid, &self.policies)?;
         let blocked = radicle_fetch::BlockList::from_config(&self.policies)?;
         let handle = fetch::Handle::new(rid, *local, &self.storage, allowed, blocked, channels)?;
         let handle = fetch::Handle::new(
             rid,
             *local,
             &self.storage,
             allowed,
             blocked,
             channels,
             notifs,
         )?;
         let result = handle.fetch(rid, &self.storage, *limit, remote, refs_at)?;
         if let Err(e) = garbage::collect(&self.storage, rid, *expiry) {

         tasks: chan::Receiver<Task>,
         nid: NodeId,
         handle: Handle,
         notifications: notifications::StoreWriter,
         config: Config,
     ) -> Result<Self, policy::Error> {
         let mut pool = Vec::with_capacity(config.capacity);

                 storage: config.storage.clone(),
                 fetch_config: config.fetch.clone(),
                 policies,
                 notifications: notifications.clone(),
             };
             let thread = thread::spawn(&nid, format!("worker#{i}"), || worker.run());

 pub mod error;
 use std::collections::HashSet;
 use std::str::FromStr;
 use localtime::LocalTime;
 use radicle::crypto::PublicKey;
 use radicle::prelude::RepoId;
 use radicle::storage::refs::RefsAt;
 use radicle::storage::{ReadStorage as _, RefUpdate, WriteRepository as _};
 use radicle::Storage;
 use radicle::storage::{ReadStorage as _, RefUpdate, RemoteRepository, WriteRepository as _};
 use radicle::{git, node, Storage};
 use radicle_fetch::{Allowed, BlockList, FetchLimit};
 use super::channels::ChannelsFlush;

     },
     Pull {
         handle: radicle_fetch::Handle<ChannelsFlush>,
         notifications: node::notifications::StoreWriter,
     },
 }

         follow: Allowed,
         blocked: BlockList,
         channels: ChannelsFlush,
         notifications: node::notifications::StoreWriter,
     ) -> Result<Self, error::Handle> {
         let exists = storage.contains(&rid)?;
         if exists {
             let repo = storage.repository(rid)?;
             let handle = radicle_fetch::Handle::new(local, repo, follow, blocked, channels)?;
             Ok(Handle::Pull { handle })
             Ok(Handle::Pull {
                 handle,
                 notifications,
             })
         } else {
             let (repo, tmp) = storage.lock_repository(rid)?;
             let handle = radicle_fetch::Handle::new(local, repo, follow, blocked, channels)?;