resolver = "2"

[workspace.package]

homepage = "https://radicle.xyz"

license = "MIT OR Apache-2.0"

repository = "https://app.radicle.xyz/seeds/seed.radicle.xyz/rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5"

use std::str::FromStr;

use radicle::crypto::ssh;

use radicle::crypto::ssh::Passphrase;

use radicle::node::Alias;

use radicle::profile::env;

use crate::terminal as term;

#[cfg(test)]

mod test {

    use clap::Parser;

    use super::Args;

use std::path::PathBuf;

use anyhow::Context as _;

use radicle::git;

use radicle::node::AliasStore;

use clap::Parser;

use radicle::identity::IdError;

use radicle::node::policy::Scope;

use radicle::prelude::*;

use radicle::storage::refs;

use crate::common_args::{

};

use crate::node::SyncSettings;

use crate::terminal;

pub use args::Args;

fn embeds(

    repo: &storage::git::Repository,

#[cfg(test)]

mod test {

    use super::Args;

    use clap::Parser;

    const ARGS: &[&str] = &[

        "--repo",

use std::path::Path;

use crate::terminal as term;

use crate::terminal::Element as _;

mod args;

use radicle_term::{Element as _, Paint, Table};

use crate::terminal as term;

#[cfg(test)]

mod test {

    use super::Args;

    use clap::Parser;

    #[test]

    fn should_parse_rid_non_urn() {

use std::collections::BTreeSet;

use radicle::cob::Title;

use radicle::identity::doc::update;

use radicle::node::NodeId;

use radicle::storage::{ReadStorage as _, WriteRepository};

use radicle_surf::diff::Diff;

use radicle_term::Element;

use crate::git::Rev;

use crate::terminal as term;

use crate::terminal::args::Error;

use crate::terminal::format::Author;

use thiserror::Error;

use radicle::cob::{Title, TypeNameParse};

use radicle::identity::doc::update::EditVisibility;

use radicle::identity::doc::update::PayloadUpsert;

use radicle::prelude::{Did, RepoId};

use crate::git::Rev;

#[cfg(test)]

mod test {

    use clap::Parser;

    #[test]

    fn should_parse_single_payload() {

use localtime::LocalTime;

use radicle::cob::TypedId;

use radicle::git::BranchName;

use radicle::identity::Identity;

use radicle::issue::cache::Issues as _;

use radicle::node::notifications;

use radicle::patch::cache::Patches as _;

use radicle::prelude::{NodeId, Profile, RepoId};

use radicle::storage::{ReadRepository, ReadStorage};

use term::Element as _;

use std::env;

use std::str::FromStr;

use serde_json as json;

use radicle::crypto::ssh;

use radicle::identity::project::ProjectName;

use radicle::identity::{Doc, RepoId, Visibility};

use radicle::node::events::UploadPack;

use radicle::storage::ReadStorage as _;

use crate::commands;

use crate::git;

    let default_branch = match find_default_branch(&repo) {

        Err(err @ DefaultBranchError::Head) => {

            term::error(err);

            anyhow::bail!("aborting `rad init`")

        }

        Err(err @ DefaultBranchError::NoHead) => {

                term::warning(format!(

                    "There was an error announcing your repository to the network: {e}"

                ));

                term::blank();

            }

            term::info!("To push changes, run {}.", term::format::command(push_cmd));

                term::blank();

                term::info!(

                    "You are not connected to any peers. Your repository will be announced as soon as \

                term::info!("Check for peer connections with `rad node status`.");

                term::blank();

            }

use clap::Parser;

use radicle::{

    node::policy::Scope,

    prelude::RepoId,

};

#[cfg(test)]

mod test {

    use super::Args;

    use clap::Parser;

    #[test]

    fn should_parse_rid_non_urn() {

use radicle::identity::RepoId;

use radicle::identity::{DocAt, Identity};

use radicle::node::AliasStore as _;

use radicle::storage::git::{Repository, Storage};

use radicle::storage::refs::{FeatureLevel, RefsAt, SignedRefs};

use radicle::storage::{ReadRepository, ReadStorage};

use crate::terminal as term;

use crate::terminal::Element;

pub use args::Args;

use args::Target;

use radicle::cob::common::Label;

use radicle::cob::issue::{CloseReason, State};

use radicle::crypto;

use radicle::issue::cache::Issues as _;

use radicle::node::NodeId;

use radicle::prelude::Did;

use radicle::profile;

use radicle::storage;

use radicle::storage::{WriteRepository, WriteStorage};

pub use args::Args;

use args::{Assigned, Command, CommentAction, StateArg};

use crate::git::Rev;

use crate::node;

use crate::terminal as term;

use crate::terminal::args::Error;

use crate::terminal::format::Author;

use crate::terminal::issue::Format;

const ABOUT: &str = "Manage issues";

use radicle::{

    cob::{Label, Reaction, Title},

    issue::{CloseReason, State},

};

use std::ops::ControlFlow;

use radicle::issue::IssueId;

use radicle::storage::ReadStorage as _;

use crate::terminal as term;

use radicle::cob::thread;

use radicle::storage::WriteRepository;

use radicle::{cob, git, issue, storage};

use crate::git::Rev;

use crate::terminal as term;

use crate::terminal::Element as _;

pub(super) fn comment(

    profile: &Profile,

use std::{process, time};

use radicle::node::address::Store as AddressStore;

use radicle::node::config::ConnectAddress;

use radicle::node::routing::Store;

use crate::commands::node::args::Only;

use crate::terminal as term;

use std::io::{BufRead, BufReader, Read, Seek, SeekFrom, Write};

use std::{path::Path, process, thread, time};

use localtime::LocalTime;

use radicle::node;

use radicle::node::{Address, ConnectResult, Handle as _, NodeId};

use radicle::profile::env::RAD_PASSPHRASE;

use crate::commands::node::logs::{LogRotatorFileSystem, Rotated};

use crate::terminal as term;

use anyhow::anyhow;

use radicle::cob::patch::PatchId;

use radicle::patch::cache::Patches as _;

use radicle::storage::git::transport;

use crate::git::Rev;

use crate::node;

use std::ops::ControlFlow;

use radicle::patch::PatchId;

use radicle::storage::ReadStorage as _;

use crate::terminal as term;

use radicle::git::fmt::Qualified;

use radicle::git::fmt::RefString;

use radicle::git::raw::ErrorExt as _;

use radicle::patch::PatchId;

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

use crate::terminal as term;

use anyhow::anyhow;

use radicle::cob;

use radicle::cob::patch;

use radicle::cob::thread;

use radicle::patch::ByRevision;

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

use crate::git;

use crate::terminal as term;

use anyhow::anyhow;

use radicle::cob;

use radicle::cob::patch;

use radicle::cob::thread;

use radicle::patch::ByRevision;

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

use crate::git;

use crate::terminal as term;

use anyhow::anyhow;

use radicle::cob;

use radicle::cob::patch;

use radicle::cob::thread;

use radicle::patch::ByRevision;

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

use crate::git;

use crate::terminal as term;

use super::*;

use radicle::cob;

use radicle::cob::Title;

use radicle::crypto;

use radicle::node::device::Device;

use radicle::prelude::*;

use radicle::profile::Profile;

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

use term::format::Author;

use term::table::{Table, TableOptions};

use crate::terminal as term;

use crate::terminal::patch as common;

use anyhow::anyhow;

use radicle::cob;

use radicle::patch::ByRevision;

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

use crate::git;

use crate::terminal as term;

use anyhow::anyhow;

use radicle::cob::thread::CommentId;

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

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

use crate::terminal as term;

mod builder;

use radicle::cob::patch::{PatchId, RevisionId, Verdict};

use radicle::git;

use radicle::git::Oid;

use radicle::node::device::Device;

use radicle::prelude::*;

use radicle_surf::diff::*;

use radicle_term::{Element, VStack};

mod args;

use radicle::cob;

use radicle::identity::{Identity, Visibility};

#[cfg(test)]

mod test {

    use super::Args;

    use clap::Parser;

    #[test]

    fn should_parse_rid_non_urn() {

use std::str::FromStr;

use radicle::git;

use radicle::git::fmt::RefString;

use radicle::prelude::*;

use radicle_crypto::PublicKey;

use crate::commands::checkout;

use std::collections::HashSet;

use radicle::git::Url;

use radicle::identity::{Did, RepoId};

use radicle::node::{Alias, AliasStore as _, NodeId};

use radicle::storage::ReadStorage as _;

use radicle_term::{Element, Table};

use crate::git;

mod args;

use radicle::node::policy;

use radicle::node::policy::{Policy, Scope};

use radicle_term::Element as _;

use crate::commands::sync;

use std::collections::HashSet;

use std::time;

use radicle::node;

use radicle::node::address::Store;

use radicle::node::sync;

use radicle::node::sync::fetch::SuccessfulOutcome;

use radicle::node::{AliasStore, Handle as _, Node, Seed, SyncStatus};

use radicle::prelude::{NodeId, Profile, RepoId};

use radicle::storage::ReadRepository;

use clap::{Parser, Subcommand, ValueEnum};

use radicle::{

    prelude::RepoId,

    storage::refs,

};

use crate::common_args::{

};

use crate::node::SyncSettings;

pub mod args;

use crate::terminal as term;

use std::{thread, time};

use radicle::git;

use radicle::git::raw::ErrorExt as _;

use std::process::Command;

use std::str::FromStr;

use anyhow::Context as _;

use thiserror::Error;

use radicle::crypto::ssh;

use radicle::git;

use radicle::prelude::{NodeId, RepoId};

use radicle::storage::git::transport;

pub use radicle::git::Oid;

pub use radicle::git::raw::{

};

pub const CONFIG_COMMIT_GPG_SIGN: &str = "commit.gpgsign";

            (v1, v2) => {

                return Err(unified_diff::Error::syntax(format!(

                    "indicator character expected, but got '{v1}{v2}'"

            }

        };

use radicle_surf::diff::{Added, Copied, Deleted, FileStats, Hunks, Modified, Moved};

use radicle_surf::diff::{Diff, DiffContent, FileDiff, Hunk, Modification};

use radicle_term as term;

use term::VStack;

use crate::git::unified_diff::FileHeader;

use crate::terminal::highlight::{Highlighter, Theme};

            Some(c) => {

                return Err(Error::syntax(format!(

                    "indicator character expected, but got '{c}'",

            }

            None => return Err(Error::UnexpectedEof),

        };

use std::{io::ErrorKind, process};

use anyhow::anyhow;

use clap::builder::Styles;

use clap::{CommandFactory as _, Parser, Subcommand};

use radicle::version::Version;

        exe

    }

        match self.exe().into_string() {

            Ok(exe) => exe,

            Err(exe) => format!("{exe:?}"),

use radicle::node::sync;

use radicle::node::{Handle as _, NodeId};

use radicle::{Node, Profile};

use crate::terminal as term;

    match announce_(repo, settings, reporting, node, profile) {

        Ok(result) => Ok(result),

        Err(e) if e.is_connection_err() => {

            Ok(None)

        }

        Err(e) => Err(e),

}

#[derive(Debug, Error)]

pub(crate) struct BlockTargetParseError {

    repo: radicle::identity::IdError,

    node: radicle::crypto::PublicKeyError,

}

#[derive(Debug, thiserror::Error)]

pub(crate) struct NodeIdParseError {

    did: radicle::identity::did::DidError,

    nid: radicle::crypto::PublicKeyError,

use radicle::{

    cob::{

        self,

        cache::{MigrateCallback, MigrateProgress},

    prelude::NodeId,

    profile,

    storage::ReadRepository,

};

use radicle_term as term;

use radicle::Profile;

use crate::terminal as term;

use crate::terminal::format::Author;

use localtime::LocalTime;

pub use radicle_term::format::*;

use radicle::cob::ObjectId;

use radicle::identity::Visibility;

use radicle::node::policy::Policy;

use radicle::node::{Alias, AliasStore, NodeId};

use radicle::prelude::Did;

use radicle::storage::RefUpdate;

use radicle_term::element::Line;

use anyhow::anyhow;

use radicle::cob::issue::Issue;

use radicle::cob::thread::{Comment, CommentId};

use radicle::crypto::ssh::Keystore;

use radicle::node::device::{BoxedDevice, Device};

use radicle::profile::Profile;

pub use radicle_term::io::*;

pub use radicle_term::spinner;

use radicle_term::table::TableOptions;

use radicle_term::{Table, VStack};

use radicle::cob;

use radicle::cob::issue;

use radicle::cob::issue::CloseReason;

use crate::terminal as term;

use crate::terminal::Element;

pub const OPEN_MSG: &str = r#"

<!--

use thiserror::Error;

use radicle::cob;

use radicle::cob::Title;

use radicle::git;

use radicle::patch::{Patch, PatchId};

use radicle::prelude::Profile;

use radicle::storage::WriteRepository as _;

use crate::terminal as term;

use crate::terminal::Element;

use std::collections::HashMap;

use std::sync::LazyLock;

use radicle::node::Address;

use radicle::profile::Config;

static NODES_RENAMED: LazyLock<HashMap<Address, Address>> = LazyLock::new(|| {

use crate::test;

use crate::util::environment::Environment;

use radicle::node;

use radicle::node::address::Store as _;

use radicle::node::policy::Scope;

use radicle::node::routing::Store as _;

use radicle::node::{Alias, Handle as _};

use radicle::prelude::{NodeId, RepoId};

use radicle::storage::ReadStorage as _;

use crate::test;

use crate::util::environment::Environment;

use crate::util::formula::formula;

use radicle::node::DEFAULT_TIMEOUT;

use radicle::node::{Alias, Handle as _};

use radicle::prelude::RepoId;

use radicle::storage::ReadStorage as _;

use crate::test;

use crate::util::environment::Environment;

use radicle::node::Address;

use radicle::node::UserAgent;

use radicle::node::{Alias, Handle as _};

use radicle::test::fixtures;

use radicle_localtime::LocalTime;

use crate::test;

use crate::util::environment::Environment;

use crate::util::formula::formula;

use radicle::node::Handle as _;

use radicle::prelude::RepoId;

use radicle::test::fixtures;

use std::str::FromStr;

use crate::test;

use crate::util::environment::Environment;

use radicle::node;

use radicle::node::Alias;

#[test]

fn rad_seed_and_follow() {

use std::str::FromStr as _;

use radicle::node::config::DefaultSeedingPolicy;

use radicle::node::policy::Scope;

use radicle::prelude::RepoId;

use radicle::storage::{ReadStorage as _, RemoteRepository as _};

use std::str::FromStr as _;

use radicle::node::DEFAULT_TIMEOUT;

use radicle::node::{Alias, Handle as _};

use radicle::prelude::RepoId;

use radicle::profile;

    let mut environment = Environment::new();

    let alias = Alias::new("alice");

    let profile = environment.profile_with(profile::Config {

        ..profile::Config::new(alias)

    });

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

use std::str::FromStr;

use radicle::cob::cache::COBS_DB_FILE;

use radicle::crypto::{KeyPair, Seed};

use radicle::git;

use radicle::node::policy::store as policy;

                },

                ..Limits::default()

            },

            ..node(alias)

        }

    }

use crate::signatures;

use crate::trailers::CommitTrailer;

use crate::{

    signatures::{ExtendedSignature, Signatures},

};

use super::commit::Commit;

use git2::{ObjectType, Oid};

use metadata::author::Author;

use metadata::commit::headers::Headers;

use metadata::commit::trailers::OwnedTrailer;

use trailers::Trailers;

use serde::{Deserialize, Serialize};

use crate::object::collaboration::error::{Create, Update};

/// Change entry storage.

pub trait Storage {

use oid::Oid;

use crate::{

};

#[derive(Debug, thiserror::Error)]

mod trailers;

pub mod change;

pub use change::Entry;

pub mod history;

pub use history::History;

pub mod object;

pub use object::{

};

#[cfg(test)]

pub mod collaboration;

pub use collaboration::{

};

pub mod storage;

use oid::Oid;

use crate::change::store::{Manifest, Version};

pub mod error;

mod create;

mod get;

pub use get::get;

pub use remove::remove;

mod update;

/// A collaborative object

#[derive(Debug, Clone, PartialEq, Eq)]

use crypto::ssh::ExtendedSignature;

use super::error;

    T: Evaluate<S>,

    S: crate::object::Storage,

    S: crate::change::Storage<

{

    let tip_refs = storage

        .objects(typename, oid)

use crypto::ssh::ExtendedSignature;

use oid::Oid;

use super::error;

where

    S: crate::object::Storage,

    S: crate::change::Storage<

{

    let tip_refs = storage

        .objects(typename, oid)

// Copyright © 2022 The Radicle Link Contributors

use super::error;

    T: Evaluate<S>,

    S: crate::object::Storage,

    S: crate::change::Storage<

{

    let references = storage

        .types(typename)

use oid::Oid;

use crate::{

};

use super::error;

    ops::{Deref, DerefMut},

};

use metadata::commit::{

    CommitData,

};

pub use ssh::ExtendedSignature;

use tempfile::TempDir;

use crate::{

    object::{self, Reference},

};

pub mod error {

use radicle_git_ref_format::refname;

#[cfg(feature = "git2")]

mod git {

    use crypto::test::signer::MockSigner;

    use crypto::{PublicKey, Signer};

    use qcheck::Arbitrary;

    use crate::{

    };

    use crate::test;

    #[test]

    fn roundtrip() {

        let storage = test::Storage::new();

        let terry = test::Person::new(&storage, "terry", *signer.public_key()).unwrap();

        let proj = test::Project::new(&storage, "discworld", *signer.public_key()).unwrap();

        let proj = test::RemoteProject {

    #[test]

    fn list_cobs() {

        let storage = test::Storage::new();

        let terry = test::Person::new(&storage, "terry", *signer.public_key()).unwrap();

        let proj = test::Project::new(&storage, "discworld", *signer.public_key()).unwrap();

        let proj = test::RemoteProject {

    #[test]

    fn update_cob() {

        let storage = test::Storage::new();

        let terry = test::Person::new(&storage, "terry", *signer.public_key()).unwrap();

        let proj = test::Project::new(&storage, "discworld", *signer.public_key()).unwrap();

        let proj = test::RemoteProject {

    #[test]

    fn traverse_cobs() {

        let storage = test::Storage::new();

        let neil = test::Person::new(&storage, "gaiman", *neil_signer.public_key()).unwrap();

        let terry = test::Person::new(&storage, "pratchett", *terry_signer.public_key()).unwrap();

        let proj = test::Project::new(&storage, "discworld", *terry_signer.public_key()).unwrap();

        let terry_proj = test::RemoteProject {

        Ok(())

    }

    }

}

        assert!(TypeName::from_str("abc..ghi").is_err());

        assert!(TypeName::from_str("abc.-123.ghi").is_err());

        assert!(TypeName::from_str("abc.123-.ghi").is_err());

    }

}

mod serde_impls {

    use alloc::string::String;

    use super::RepoId;

    fn invalid() {

        assert!("".parse::<RepoId>().is_err());

        assert!("not-a-valid-rid".parse::<RepoId>().is_err());

        assert!("rad:".parse::<RepoId>().is_err());

        assert!("rad:z3gqcJUoA1n9HaHKuf".parse::<RepoId>().is_err());

    }

    #[test]

    fn valid() {

        assert!("z3gqcJUoA1n9HaHKufZs5FCSGazv5".parse::<RepoId>().is_ok());

        assert!("z3XncAdkZjeK9mQS5Sdc4qhw98BUX".parse::<RepoId>().is_ok());

    }

use serde::{Deserialize, Serialize};

use thiserror::Error;

pub extern crate signature;

    where

        Self: Sized,

    {

        let pk = ms.public;

        (ms, pk)

    }

    /// Generate a new memory signer.

        let keypair = KeyPair::generate();

        let sk = keypair.sk;

use qcheck::Arbitrary;

impl Arbitrary for MockSigner {

    fn arbitrary(g: &mut qcheck::Gen) -> Self {

#[derive(Debug, Clone)]

pub struct MockSigner {

use std::collections::HashMap;

use radicle::git::Oid;

use radicle::prelude::PublicKey;

use super::refs::{Applied, RefUpdate, Update};

use std::collections::BTreeMap;

use either::Either;

use radicle::git::Oid;

use radicle::prelude::PublicKey;

pub use radicle::storage::RefUpdate;

use either::Either;

use radicle::git::raw::ErrorExt as _;

use radicle::git::{

    fmt::{Namespaced, Qualified},

};

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

use radicle::git::{

    fmt::{Namespaced, Qualified},

};

use thiserror::Error;

use std::sync::Arc;

use bstr::BString;

use radicle::crypto::PublicKey;

use radicle::git::Oid;

use radicle::identity::{Doc, DocError};

use radicle::storage::ReadRepository;

use crate::policy::{Allowed, BlockList};

use crate::transport::{ConnectionStream, Transport};

use std::io;

use std::time::Instant;

pub use handle::Handle;

pub use policy::{Allowed, BlockList, Scope};

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

pub use transport::Transport;

use radicle::crypto::PublicKey;

use radicle::storage::ReadRepository as _;

use state::FetchState;

use thiserror::Error;

use either::Either;

use radicle::crypto::PublicKey;

use radicle::git::{

    fmt::{Component, Namespaced, Qualified},

};

use thiserror::Error;

use std::ops::Not as _;

pub use radicle::storage::refs::SignedRefs;

use radicle::{crypto::PublicKey, storage::ValidateRepository};

pub mod error {

use gix_protocol::handshake::Ref;

use nonempty::NonEmpty;

use radicle::crypto::PublicKey;

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