Implement COB caching — heartwood

This patch implements caching for COBs by using an SQLite database that is used as a write-thru cache. All reads are replaced with using the cache so as to avoid recomputing the COB graph each time.

 ╭──────────────────────────────────────────────────────────────────────╮
 │ heartwood                                                            │
 ├──────────────────────────────────────────────────────────────────────┤
 │ 001   ●   58fff44    No license file    issue    open      bob   now │
 │ 001   ●   [ ... ]    No license file    issue    open      bob   now │
 │ 002   ●   bob/copy   Change copyright   branch   created   bob   now │
 ╰──────────────────────────────────────────────────────────────────────╯
 ```

 ╭────────────────────────────────────────────────────────────────╮
 │ radicle-git                                                    │
 ├────────────────────────────────────────────────────────────────┤
 │ 003   ●   4dd5843   Copyright fixes   patch   open   bob   now │
 │ 003   ●   [ ... ]   Copyright fixes   patch   open   bob   now │
 ╰────────────────────────────────────────────────────────────────╯
 ╭──────────────────────────────────────────────────────────────────────╮
 │ heartwood                                                            │
 ├──────────────────────────────────────────────────────────────────────┤
 │ 001   ●   58fff44    No license file    issue    open      bob   now │
 │ 001   ●   [ ... ]    No license file    issue    open      bob   now │
 │ 002   ●   bob/copy   Change copyright   branch   created   bob   now │
 ╰──────────────────────────────────────────────────────────────────────╯
 ```

 ╭──────────────────────────────────────────────────────────────────────╮
 │ heartwood                                                            │
 ├──────────────────────────────────────────────────────────────────────┤
 │ 001   ●   58fff44    No license file    issue    open      bob   now │
 │ 001   ●   [ ... ]    No license file    issue    open      bob   now │
 │ 002       bob/copy   Change copyright   branch   created   bob   now │
 ╰──────────────────────────────────────────────────────────────────────╯
 ```

 ╭────────────────────────────────────────────────────────────────╮
 │ radicle-git                                                    │
 ├────────────────────────────────────────────────────────────────┤
 │ 003   ●   4dd5843   Copyright fixes   patch   open   bob   now │
 │ 003   ●   [ ... ]   Copyright fixes   patch   open   bob   now │
 ╰────────────────────────────────────────────────────────────────╯
 ```

 use std::time;
 use anyhow::anyhow;
 use radicle::issue::cache::Issues as _;
 use radicle::patch::cache::Patches as _;
 use thiserror::Error;
 use radicle::cob;
 use radicle::git::raw;
 use radicle::identity::doc;
 use radicle::identity::doc::{DocError, RepoId};

     info.push([term::format::bold(proj.name()).into()]);
     info.push([term::format::italic(proj.description()).into()]);
     let issues = cob::issue::Issues::open(&repo)?.counts()?;
     let patches = cob::patch::Patches::open(&repo)?.counts()?;
     let issues = profile.issues(&repo)?.counts()?;
     let patches = profile.patches(&repo)?.counts()?;
     info.push([term::Line::spaced([
         term::format::tertiary(issues.open).into(),

 use anyhow::anyhow;
 use localtime::LocalTime;
 use radicle::issue::Issues;
 use radicle::issue::cache::Issues as _;
 use radicle::node::notifications;
 use radicle::node::notifications::*;
 use radicle::patch::Patches;
 use radicle::patch::cache::Patches as _;
 use radicle::prelude::{Profile, RepoId};
 use radicle::storage::{ReadRepository, ReadStorage};
 use radicle::{cob, Storage};

     let (_, head) = repo.head()?;
     let doc = repo.identity_doc()?;
     let proj = doc.project()?;
     let issues = Issues::open(&repo)?;
     let patches = Patches::open(&repo)?;
     let issues = profile.issues(&repo)?;
     let patches = profile.patches(&repo)?;
     let mut notifs = notifs.by_repo(&rid, sort_by.field)?.collect::<Vec<_>>();
     if !sort_by.reverse {

     match n.kind {
         NotificationKind::Cob { type_name, id } if type_name == *cob::issue::TYPENAME => {
             let issues = Issues::open(&repo)?;
             let issues = profile.issues(&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 patches = profile.patches(&repo)?;
             let patch = patches.get(&id)?.unwrap();
             term::patch::show(&patch, &id, false, &repo, None, profile)?;

 #[path = "issue/cache.rs"]
 mod cache;
 use std::collections::BTreeSet;
 use std::ffi::OsString;
 use std::str::FromStr;

 use radicle::cob::common::{Label, Reaction};
 use radicle::cob::issue;
 use radicle::cob::issue::{CloseReason, Issues, State};
 use radicle::cob::issue::{CloseReason, State};
 use radicle::cob::thread;
 use radicle::crypto::Signer;
 use radicle::issue::cache::Issues as _;
 use radicle::prelude::Did;
 use radicle::profile;
 use radicle::storage;
 use radicle::storage::{WriteRepository, WriteStorage};
 use radicle::storage::{ReadRepository, WriteRepository, WriteStorage};
 use radicle::Profile;
 use radicle::{cob, Node};

     rad issue comment <issue-id> [--message <message>] [--reply-to <comment-id>] [<option>...]
     rad issue show <issue-id> [<option>...]
     rad issue state <issue-id> [--closed | --open | --solved] [<option>...]
     rad issue cache [<issue-id>] [<option>...]
 Assign options

     React,
     Show,
     State,
     Cache,
 }
 /// Command line Peer argument.

         assigned: Option<Assigned>,
         state: Option<State>,
     },
     Cache {
         id: Option<Rev>,
     },
 }
 #[derive(Debug, Default, PartialEq, Eq)]

                     "s" | "state" => op = Some(OperationName::State),
                     "assign" => op = Some(OperationName::Assign),
                     "label" => op = Some(OperationName::Label),
                     "cache" => op = Some(OperationName::Cache),
                     unknown => anyhow::bail!("unknown operation '{}'", unknown),
                 },

                 opts: label_opts,
             },
             OperationName::List => Operation::List { assigned, state },
             OperationName::Cache => Operation::Cache { id },
         };
         Ok((

                 | Operation::Label { .. }
         );
     let mut issues = Issues::open(&repo)?;
     let mut issues = profile.issues_mut(&repo)?;
     match options.op {
         Operation::Edit {

             issue.label(labels, &signer)?;
         }
         Operation::List { assigned, state } => {
             list(&issues, &assigned, &state, &profile)?;
             list(issues, &assigned, &state, &profile)?;
         }
         Operation::Delete { id } => {
             let id = id.resolve(&repo.backend)?;
             issues.remove(&id, &signer)?;
         }
         Operation::Cache { id } => {
             let id = id.map(|id| id.resolve(&repo.backend)).transpose()?;
             cache::run(id, &repo, &profile)?;
         }
     }
     if announce {

     Ok(())
 }
 fn list<R: WriteRepository + cob::Store>(
     issues: &Issues<R>,
 fn list<C>(
     cache: C,
     assigned: &Option<Assigned>,
     state: &Option<State>,
     profile: &profile::Profile,
 ) -> anyhow::Result<()> {
     if issues.is_empty()? {
 ) -> anyhow::Result<()>
 where
     C: issue::cache::Issues,
 {
     if cache.is_empty()? {
         term::print(term::format::italic("Nothing to show."));
         return Ok(());
     }

     };
     let mut all = Vec::new();
     for result in issues.all()? {
     let issues = cache.list()?;
     for result in issues {
         let Ok((id, issue)) = result else {
             // Skip issues that failed to load.
             continue;

     Ok(())
 }
 fn open<R: WriteRepository + cob::Store, G: Signer>(
 fn open<R, G>(
     title: Option<String>,
     description: Option<String>,
     labels: Vec<Label>,
     assignees: Vec<Did>,
     options: &Options,
     issues: &mut Issues<R>,
     cache: &mut issue::Cache<issue::Issues<'_, R>, cob::cache::StoreWriter>,
     signer: &G,
     profile: &Profile,
 ) -> anyhow::Result<()> {
 ) -> anyhow::Result<()>
 where
     R: ReadRepository + WriteRepository + cob::Store,
     G: Signer,
 {
     let (title, description) = if let (Some(t), Some(d)) = (title.as_ref(), description.as_ref()) {
         (t.to_owned(), d.to_owned())
     } else if let Some((t, d)) = term::issue::get_title_description(title, description)? {

     } else {
         anyhow::bail!("aborting issue creation due to empty title or description");
     };
     let issue = issues.create(
     let issue = cache.create(
         &title,
         description,
         labels.as_slice(),

     Ok(())
 }
 fn edit<'a, 'g, R: WriteRepository + cob::Store, G: radicle::crypto::Signer>(
     issues: &'a mut issue::Issues<'a, R>,
 fn edit<'a, 'g, R, G>(
     issues: &'g mut issue::Cache<issue::Issues<'a, R>, cob::cache::StoreWriter>,
     repo: &storage::git::Repository,
     id: Rev,
     title: Option<String>,
     description: Option<String>,
     signer: &G,
 ) -> anyhow::Result<issue::IssueMut<'a, 'g, R>> {
 ) -> anyhow::Result<issue::IssueMut<'a, 'g, R, cob::cache::StoreWriter>>
 where
     R: WriteRepository + ReadRepository + cob::Store,
     G: radicle::crypto::Signer,
 {
     let id = id.resolve(&repo.backend)?;
     let mut issue = issues.get_mut(&id)?;
     let (root, _) = issue.root();

 use std::ops::ControlFlow;
 use radicle::issue::IssueId;
 use radicle::storage::git::Repository;
 use radicle::Profile;
 use crate::terminal as term;
 pub fn run(id: Option<IssueId>, repository: &Repository, profile: &Profile) -> anyhow::Result<()> {
     let mut issues = profile.issues_mut(repository)?;
     match id {
         Some(id) => {
             issues.write(&id)?;
             term::success!("Successfully cached issue `{id}`");
         }
         None => issues.write_all(|result, progress| {
             match result {
                 Ok((id, _)) => term::success!("Successfully cached issue `{id}`"),
                 Err(e) => term::warning(format!("Failed to retrieve issue: {e}")),
             };
             term::info!("Cached {} of {}", progress.seen(), progress.total());
             ControlFlow::Continue(())
         })?,
     }
     Ok(())
 }

 mod archive;
 #[path = "patch/assign.rs"]
 mod assign;
 #[path = "patch/cache.rs"]
 mod cache;
 #[path = "patch/checkout.rs"]
 mod checkout;
 #[path = "patch/comment.rs"]

 use radicle::cob::patch::PatchId;
 use radicle::cob::{patch, Label};
 use radicle::patch::cache::Patches as _;
 use radicle::storage::git::transport;
 use radicle::{prelude::*, Node};

     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>] [<option>...]
 Show options

     pub delete: BTreeSet<Label>,
 }
 pub struct Filter(fn(&patch::State) -> bool);
 impl Filter {
     /// Match everything.
     fn all() -> Self {
         Self(|_| true)
     }
 }
 impl Default for Filter {
     fn default() -> Self {
         Self(|state| matches!(state, patch::State::Open { .. }))
     }
 }
 impl std::fmt::Debug for Filter {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Filter(..)")
     }
 }
 #[derive(Debug)]
 pub enum Operation {
     Show {

         opts: LabelOptions,
     },
     List {
         filter: Filter,
         filter: Option<patch::Status>,
     },
     Edit {
         patch_id: Rev,

     Set {
         patch_id: Rev,
     },
     Cache {
         patch_id: Option<Rev>,
     },
 }
 impl Operation {

             Operation::Show { .. }
             | Operation::Diff { .. }
             | Operation::Checkout { .. }
             | Operation::List { .. } => false,
             | Operation::List { .. }
             | Operation::Cache { .. } => false,
         }
     }
 }

         let mut patch_id = None;
         let mut revision_id = None;
         let mut message = Message::default();
         let mut filter = Filter::default();
         let mut filter = Some(patch::Status::Open);
         let mut diff = false;
         let mut debug = false;
         let mut undo = false;

                 // List options.
                 Long("all") => {
                     filter = Filter::all();
                     filter = None;
                 }
                 Long("draft") => {
                     filter = Filter(|s| s == &patch::State::Draft);
                     filter = Some(patch::Status::Draft);
                 }
                 Long("archived") => {
                     filter = Filter(|s| s == &patch::State::Archived);
                     filter = Some(patch::Status::Archived);
                 }
                 Long("merged") => {
                     filter = Filter(|s| matches!(s, patch::State::Merged { .. }));
                     filter = Some(patch::Status::Merged);
                 }
                 Long("open") => {
                     filter = Filter(|s| matches!(s, patch::State::Open { .. }));
                     filter = Some(patch::Status::Open);
                 }
                 Long("authored") => {
                     authored = true;

                     "comment" => op = Some(OperationName::Comment),
                     "review" => op = Some(OperationName::Review),
                     "set" => op = Some(OperationName::Set),
                     "cache" => op = Some(OperationName::Cache),
                     unknown => anyhow::bail!("unknown operation '{}'", unknown),
                 },
                 Value(val) if op == Some(OperationName::Redact) => {

             OperationName::Set => Operation::Set {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
             },
             OperationName::Cache => Operation::Cache { patch_id },
         };
         Ok((