let storage = &profile.storage;

    let (_, id) = radicle::rad::cwd()?;

    let repo = storage.repository_mut(id)?;

    let mut issue = issues.get_mut(&options.id).map_err(|err| match err {

        cob::store::Error::NotFound(_, _) => anyhow!("issue not found '{}'", options.id),

        return Ok(());

    }

    match issues.get_mut(&options.id) {

        Ok(mut issue) => {

            let comment_id = options.reply_to.unwrap_or_else(|| {

        Err(e) => return Err(e.into()),

    }

    match patches.get_mut(&options.id) {

        Ok(mut patch) => {

            let (revision_id, _) = patch.revisions().last().expect("patch has a revision");

    let storage = &profile.storage;

    let (_, id) = radicle::rad::cwd()?;

    let repo = storage.repository(id)?;

    let previous = Identity::load(signer.public_key(), &repo)?;

    let interactive = &options.interactive;

    let storage = &profile.storage;

    let (_, id) = radicle::rad::cwd()?;

    let repo = storage.repository_mut(id)?;

    match options.op {

        Operation::Open {

        .identity_doc_of(profile.id())

        .context(format!("couldn't load project {id} from local state"))?;

    let repository = profile.storage.repository(id)?;

    if repo.head_detached()? {

        anyhow::bail!("HEAD is in a detached state; can't merge");

            list::run(&repository, &profile, Some(workdir))?;

        }

        Operation::Show { ref patch_id } => {

        }

        Operation::Update {

            patch_id,

            )?;

        }

        Operation::Checkout { ref patch_id } => {

        }

    }

    Ok(())

use anyhow::anyhow;

use radicle::cob::patch::{self, PatchId};

use radicle::git::{self, RefString};

use radicle::storage::git::Repository;

pub fn run(

    storage: &Repository,

    git_workdir: &git::raw::Repository,

    patch_id: &PatchId,

) -> anyhow::Result<()> {

    let patch = patches

        .get(patch_id)?

        .ok_or_else(|| anyhow!("Patch `{patch_id}` not found"))?;

    merge_base: Oid,

    patches: &Patches,

    workdir: &git::raw::Repository,

) -> anyhow::Result<Vec<(PatchId, Patch, Clock)>> {

    // My patches.

    let mut matches = Vec::new();

    for (id, patch, clock) in proposed {

    message: term::patch::Message,

    options: Options,

) -> anyhow::Result<()> {

    let project = storage.project_of(&profile.public_key).context(format!(

        "couldn't load project {} from local state",

        storage.id

    show_patch_commit_info(

        &project,

        workdir,

        &head_branch,

        &target_peer,

        target_oid,

    workdir: Option<git::raw::Repository>,

) -> anyhow::Result<()> {

    let me = *profile.id();

    let proposed = patches.proposed()?;

    // Patches the user authored.

        for (id, patch) in &mut other {

            term::blank();

        }

    }

    term::blank();

use super::common::*;

use super::*;

use radicle::cob::patch;

use radicle::git;

use radicle::storage::git::Repository;

fn show_patch_diff(

    patch: &patch::Patch,

    storage: &Repository,

pub fn run(

    storage: &Repository,

    workdir: &git::raw::Repository,

    patch_id: &PatchId,

) -> anyhow::Result<()> {

    let Some(patch) = patches.get(patch_id)? else {

        anyhow::bail!("Patch `{patch_id}` not found");

    };

    workdir: &git::raw::Repository,

    head_branch: &git::raw::Branch,

    target_oid: git::Oid,

) -> anyhow::Result<patch::PatchId> {

    let head_oid = branch_oid(head_branch)?;

    let base_oid = workdir.merge_base(*target_oid, *head_oid)?;

    let mut spinner = term::spinner("Finding patches to update...");

    let Some((id, patch, _)) = result.pop() else {

        spinner.failed();

    push_to_storage(storage, &head_branch, options)?;

    let (_, target_oid) = get_merge_target(&project, storage, &head_branch)?;

    let patch_id = match patch_id {

        Some(patch_id) => patch_id,

    };

    let Ok(mut patch) = patches.get_mut(&patch_id) else {

        anyhow::bail!("Patch `{patch_id}` not found");

    let _project = repository

        .identity_doc_of(profile.id())

        .context(format!("couldn't load project {id} from local state"))?;

    let patch_id = options.id;

    let mut patch = patches

    let storage = &profile.storage;

    let (_, id) = radicle::rad::cwd()?;

    let repo = storage.repository_mut(id)?;

    let mut issue = issues.get_mut(&options.id).map_err(|err| match err {

        cob::store::Error::NotFound(_, _) => anyhow!("issue '{}' not found", options.id),

        let doc = repo.identity_doc()?.1.verified()?;

        let payload = doc.project()?;

        let delegates = doc.delegates;

        Ok(project::Info {

            payload,

                return None;

            }

            let Ok(issues) = issues.counts() else { return None };

            let Ok(patches) = patches.counts() else { return None };

            Some(Info {

            let Ok((_, doc)) = repo.identity_doc() else { return None };

            let Ok(doc) = doc.verified() else { return None };

            let Ok(payload) = doc.project() else { return None };

            let Ok(issues) = issues.counts() else { return None };

            let Ok(patches) = patches.counts() else { return None };

            let delegates = doc.delegates;

    let per_page = per_page.unwrap_or(10);

    let storage = &ctx.profile.storage;

    let repo = storage.repository(project)?;

    let mut issues: Vec<_> = issues.all()?.filter_map(|r| r.ok()).collect::<Vec<_>>();

    issues.sort_by(|(_, a, _), (_, b, _)| b.timestamp().cmp(&a.timestamp()));

    let issues = issues

        .signer()

        .map_err(|_| Error::Auth("Unauthorized"))?;

    let repo = storage.repository(project)?;

    let issue = issues

        .create(

            issue.title,

    let storage = &ctx.profile.storage;

    let signer = ctx.profile.signer().unwrap();

    let repo = storage.repository(project)?;

    let mut issue = issues.get_mut(&issue_id.into())?;

    match action {

) -> impl IntoResponse {

    let storage = &ctx.profile.storage;

    let repo = storage.repository(project)?;

        .get(&issue_id.into())?

        .ok_or(Error::NotFound)?;

        .signer()

        .map_err(|_| Error::Auth("Unauthorized"))?;

    let repo = storage.repository(project)?;

    let base_oid = repo.raw().merge_base(*patch.target, *patch.oid)?;

    let patch = patches

    let per_page = per_page.unwrap_or(10);

    let storage = &ctx.profile.storage;

    let repo = storage.repository(project)?;

    let mut patches = patches.all()?.filter_map(|r| r.ok()).collect::<Vec<_>>();

    patches.sort_by(|(_, a, _), (_, b, _)| b.timestamp().cmp(&a.timestamp()));

    let patches = patches

) -> impl IntoResponse {

    let storage = &ctx.profile.storage;

    let repo = storage.repository(project)?;

        .get(&patch_id.into())?

        .ok_or(Error::NotFound)?;

use radicle::storage::ReadStorage;

use radicle_cli::commands::rad_init;

use radicle_crypto::ssh::keystore::MemorySigner;

use crate::api::{auth, Context};

    let storage = &profile.storage;

    let (_, id) = radicle::rad::repo(&workdir).unwrap();

    let repo = storage.repository(id).unwrap();

    issues

        .create(

            "Issue #1".to_string(),

        .unwrap();

    // eq. rad patch open

    let oid = radicle::git::Oid::from_str(HEAD).unwrap();

    let base = radicle::git::Oid::from_str(HEAD_1).unwrap();

    patches

impl<'a> Proposals<'a> {

    /// Open a proposals store.

        Ok(Self { raw })

    }

use crate::cob::thread;

use crate::cob::thread::{CommentId, Thread};

use crate::cob::{store, ActorId, ObjectId, OpId, TypeName};

use crate::prelude::Did;

use crate::storage::git as storage;

impl<'a> Issues<'a> {

    /// Open an issues store.

        Ok(Self { raw })

    }

    fn test_issue_create_and_assign() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let assignee: ActorId = arbitrary::gen(1);

        let assignee_two: ActorId = arbitrary::gen(1);

    fn test_issue_create_and_reassign() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let assignee: ActorId = arbitrary::gen(1);

        let assignee_two: ActorId = arbitrary::gen(1);

    fn test_issue_create_and_get() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let created = issues

            .create("My first issue", "Blah blah blah.", &[], &[], &signer)

            .unwrap();

        assert_eq!(created, issue);

        assert_eq!(issue.title(), "My first issue");

        assert_eq!(issue.description(), Some("Blah blah blah."));

        assert_eq!(issue.comments().count(), 1);

        assert_eq!(issue.state(), &State::Open);

    fn test_issue_create_and_change_state() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let mut issue = issues

            .create("My first issue", "Blah blah blah.", &[], &[], &signer)

            .unwrap();

    fn test_issue_create_and_unassign() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let assignee: ActorId = arbitrary::gen(1);

        let assignee_two: ActorId = arbitrary::gen(1);

    fn test_issue_edit_title() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let mut issue = issues

            .create("My first issue", "Blah blah blah.", &[], &[], &signer)

            .unwrap();

    fn test_issue_react() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let mut issue = issues

            .create("My first issue", "Blah blah blah.", &[], &[], &signer)

            .unwrap();

    fn test_issue_reply() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let mut issue = issues

            .create("My first issue", "Blah blah blah.", &[], &[], &signer)

            .unwrap();

    fn test_issue_tag() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let bug_tag = Tag::new("bug").unwrap();

        let ux_tag = Tag::new("ux").unwrap();

        let wontfix_tag = Tag::new("wontfix").unwrap();

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let author = *signer.public_key();

        let mut issue = issues

            .create("My first issue", "Blah blah blah.", &[], &[], &signer)

            .unwrap();

    fn test_issue_all() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        issues.create("First", "Blah", &[], &[], &signer).unwrap();

        issues.create("Second", "Blah", &[], &[], &signer).unwrap();

    fn test_issue_multilines() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let created = issues

            .create(

                "My first issue",

        assert_eq!(created, issue);

        assert_eq!(issue.title(), "My first issue");

        assert_eq!(issue.description(), Some("Blah blah blah.\nYah yah yah"));

        assert_eq!(issue.comments().count(), 1);

        assert_eq!(issue.state(), &State::Open);

impl<'a> Patches<'a> {

    /// Open an patches store.

        Ok(Self { raw })

    }

    fn test_patch_create_and_get() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let author: Did = signer.public_key().into();

        let target = MergeTarget::Delegates;

        let oid = git::Oid::from_str("e2a85016a458cd809c0ecee81f8c99613b0b0945").unwrap();

    fn test_patch_discussion() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let patch = patches

            .create(

                "My first patch",

        let (_, signer, project) = test::setup::context(&tmp);

        let oid = git::Oid::from_str("e2a85016a458cd809c0ecee81f8c99613b0b0945").unwrap();

        let base = git::Oid::from_str("cb18e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();

        let mut patch = patches

            .create(

                "My first patch",

        let (_, signer, project) = test::setup::context(&tmp);

        let base = git::Oid::from_str("cb18e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();

        let oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();

        let mut patch = patches

            .create(

                "My first patch",

        let (_, signer, project) = test::setup::context(&tmp);

        let base = git::Oid::from_str("cb18e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();

        let oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();

        let mut patch = patches

            .create(

                "My first patch",

        let base = git::Oid::from_str("af08e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();

        let rev0_oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();

        let rev1_oid = git::Oid::from_str("cb18e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();

        let mut patch = patches

            .create(

                "My first patch",

use rand::{RngCore as _, SeedableRng};

use serde::{Deserialize, Serialize};

use crate::cob::op::{Nonce, Op, OpId, Ops};

use crate::cob::CollaborativeObject;

use crate::cob::{ActorId, Create, History, ObjectId, TypeName, Update};

use crate::git;

use crate::prelude::*;

use crate::storage::git as storage;

/// Storage for collaborative objects of a specific type `T` in a single repository.

pub struct Store<'a, T> {

    parent: git::Oid,

    repo: &'a storage::Repository,

    witness: PhantomData<T>,

impl<'a, T> Store<'a, T> {

    /// Open a new generic store.

        let rng = rng::std();

        let identity = repo.identity()?;

        Ok(Self {

            parent: identity.current,

            repo,

            witness: PhantomData,

            rng,

        })

    }

    /// Derive a new RNG from the existing one.

    pub fn rng(&self) -> StdRng {

        StdRng::from_rng(self.rng.clone()).expect("Store::rng: failed to derive RNG")

    /// Remove an object.

    pub fn remove<G: Signer>(&self, id: &ObjectId, signer: &G) -> Result<(), Error> {

        self.repo.sign_refs(signer).map_err(Error::SignRefs)?;

        Ok(())