[[package]]

name = "base64"

version = "0.21.7"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"

[[package]]

name = "git-ref-format"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "git-ref-format-core",

 "git-ref-format-macro",

[[package]]

name = "git-ref-format-core"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "bstr",

 "serde",

[[package]]

name = "git-ref-format-macro"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "git-ref-format-core",

 "quote",

 "syn 2.0.89",

]

[[package]]

name = "nonempty"

version = "0.9.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "995defdca0a589acfdd1bd2e8e3b896b4d4f7675a31fd14c32611440c7f608e6"

]

[[package]]

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "proc-macro2",

 "quote",

]

[[package]]

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "proc-macro2",

 "quote",

]

[[package]]

 "localtime",

 "log",

 "multibase",

 "pretty_assertions",

 "qcheck",

 "qcheck-macros",

 "radicle-cob",

 "radicle-crypto",

 "radicle-ssh",

 "schemars",

 "serde",

 "chrono",

 "clap",

 "dunce",

 "human-panic",

 "itertools",

 "lexopt",

 "localtime",

 "log",

 "pretty_assertions",

 "radicle",

 "radicle-cli-test",

 "radicle-cob",

 "radicle-crypto",

 "radicle-node",

 "radicle-surf",

 "radicle-term",

version = "0.17.0"

dependencies = [

 "fastrand",

 "git2",

 "log",

 "qcheck",

 "qcheck-macros",

 "radicle-crypto",

 "radicle-dag",

 "serde",

 "serde_json",

 "signature 2.2.0",

 "gix-protocol",

 "gix-transport",

 "log",

 "radicle",

 "thiserror 1.0.69",

]

[[package]]

name = "radicle-git-ext"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "git-ref-format",

 "git2",

]

[[package]]

name = "radicle-node"

version = "0.16.0"

dependencies = [

 "localtime",

 "log",

 "mio 1.0.4",

 "qcheck",

 "qcheck-macros",

 "radicle",

 "radicle-crypto",

 "radicle-fetch",

 "radicle-protocol",

 "radicle-signals",

 "radicle-systemd",

]

[[package]]

name = "radicle-protocol"

version = "0.4.0"

dependencies = [

 "fastrand",

 "localtime",

 "log",

 "paste",

 "qcheck",

 "qcheck-macros",

 "radicle",

 "radicle-crypto",

 "radicle-fetch",

 "scrypt",

 "serde",

 "serde_json",

 "radicle",

 "radicle-cli",

 "radicle-crypto",

 "thiserror 1.0.69",

]

[[package]]

name = "radicle-std-ext"

source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]

name = "radicle-surf"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "anyhow",

 "flate2",

 "git2",

 "log",

 "radicle-git-ext",

 "radicle-std-ext",

 "tar",

cyphernet = "0.5.2"

dunce = "1.0.5"

fastrand = { version = "2.0.0", default-features = false }

human-panic = "2"

itertools = "0.14"

lexopt = "0.3.0"

radicle-crypto = { version = "0.14", path = "crates/radicle-crypto" }

radicle-dag = { version = "0.10", path = "crates/radicle-dag" }

radicle-fetch = { version = "0.16", path = "crates/radicle-fetch" }

radicle-node = { version = "0.16", path = "crates/radicle-node" }

radicle-protocol = { version = "0.4", path = "crates/radicle-protocol" }

radicle-signals = { version = "0.11", path = "crates/radicle-signals" }

radicle-ssh = { version = "0.10", path = "crates/radicle-ssh", default-features = false }

radicle-systemd = { version = "0.11", path = "crates/radicle-systemd" }

radicle-term = { version = "0.16", path = "crates/radicle-term" }

serde_json = "1.0"

shlex = "1.1.0"

signature = "2.2"

winpipe = "0.1.1"

zeroize = "1.5.7"

[workspace.lints]

clippy.type_complexity = "allow"

clippy.enum_variant_names = "allow"

chrono = { workspace = true, features = ["clock", "std"] }

clap = { version = "4.5.44", features = ["derive"] }

dunce = { workspace = true }

human-panic.workspace = true

itertools.workspace = true

lexopt = { workspace = true }

radicle = { workspace = true, features = ["logger", "schemars"] }

radicle-cob = { workspace = true }

radicle-crypto = { workspace = true }

radicle-term = { workspace = true }

schemars = { workspace = true }

serde = { workspace = true }

pub fn setup_remote(

    setup: &project::SetupRemote,

    remote_id: &NodeId,

    aliases: &impl AliasStore,

    let remote_name = if let Some(name) = remote_name {

        name

    } else {

        } else {

            remote_id.to_human()

        };

            .map_err(|_| anyhow!("invalid remote name: '{name}'"))?

    };

    let (remote, branch) = setup.run(&remote_name, *remote_id)?;

use anyhow::anyhow;

use localtime::LocalTime;

use radicle::cob::TypedId;

use radicle::identity::Identity;

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

use radicle::node::notifications;

use radicle::node::notifications::*;

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

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

use radicle::{cob, git, Storage};

use term::Element as _;

use radicle::crypto::ssh;

use radicle::explorer::ExplorerUrl;

use radicle::git::raw;

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

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

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

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

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

use radicle::cob::{patch, Label, Reaction};

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

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

use radicle::{prelude::*, Node};

use anyhow::anyhow;

use radicle::cob::patch;

use radicle::cob::patch::RevisionId;

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

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

use radicle::patch::PatchId;

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

            Some(refname) => Ok(Qualified::from_refstr(refname)

                .map_or_else(|| refname.clone(), |q| q.to_ref_string())),

            // SAFETY: Patch IDs are valid refstrings.

                .join(RefString::try_from(term::format::cob(id).item).unwrap())),

        }

    }

    let mut spinner = term::spinner("Performing checkout...");

    let patch_branch = opts.branch(patch_id)?;

            }

    if opts.force {

        builder.force();

        working.checkout_tree(commit.as_object(), Some(&mut builder))?;

    } else {

    stored: &Repository,

    working: &'a git::raw::Repository,

) -> anyhow::Result<git::raw::Commit<'a>> {

    match working.find_commit(head) {

        Ok(commit) => Ok(commit),

use radicle::cob::{CodeLocation, CodeRange};

use radicle::crypto;

use radicle::git;

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

use radicle::prelude::*;

use radicle::storage::git::{cob::DraftStore, Repository};

use radicle_surf::diff::*;

use radicle_term::{Element, VStack};

    fn paths(&self) -> (Option<(&Path, Oid)>, Option<(&Path, Oid)>) {

        match self {

            Self::FileMoved { moved } => (

            ),

            Self::FileCopied { copied } => (

            ),

        }

    }

/// of changes introduced by a patch.

pub struct Brain<'a> {

    /// Where the review draft is being stored.

    /// The commit pointed to by the ref.

    head: git::raw::Commit<'a>,

    /// The tree of accepted changes pointed to by the head commit.

    }

    /// Get the brain's refname given the patch and remote.

        git::refs::storage::draft::review(remote, patch)

    }

}

use radicle::cob::patch;

use radicle::git;

use radicle::prelude::*;

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

/// Run patch update.

pub fn run(

    patch_id: patch::PatchId,

    message: term::patch::Message,

    profile: &Profile,

    repository: &Repository,

    let head_oid = branch_oid(&head_branch)?;

    let base_oid = match base_id {

        Some(oid) => oid,

    };

    // N.b. we don't update if both the head and base are the same as

    // any previous revision

    if patch

        .revisions()

    {

        return Ok(());

    }

    let (_, revision) = patch.latest();

    let signer = term::signer(profile)?;

    term::print(revision);

use anyhow::anyhow;

use radicle::prelude::NodeId;

use radicle::storage::ReadStorage;

use std::str::FromStr;

use radicle::git;

use radicle::prelude::*;

use radicle::Profile;

use radicle_crypto::PublicKey;

            let remote = remote?;

            let sigrefs = repo.reference_oid(&remote, &git::refs::storage::SIGREFS_BRANCH)?;

            let mut walk = repo.raw().revwalk()?;

            stats.local.pushes += walk.count();

            stats.local.forks += 1;

pub struct Options {

    rid: Option<RepoId>,

    target: Option<git::Oid>,

    nid: Option<NodeId>,

    interval: time::Duration,

        let mut rid = None;

        let mut nid: Option<NodeId> = None;

        let mut target: Option<git::Oid> = None;

        let mut interval: Option<time::Duration> = None;

        let mut timeout: time::Duration = time::Duration::MAX;

fn reference<R: ReadRepository>(

    repo: &R,

    nid: &NodeId,

) -> Result<Option<git::Oid>, git::raw::Error> {

    match repo.reference_oid(nid, qual) {

        Ok(oid) => Ok(Some(oid)),

use radicle::crypto::ssh;

use radicle::git;

use radicle::git::{Version, VERSION_REQUIRED};

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

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

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

};

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

        &self.0

    }

    where

    {

        let object = repo.revparse_single(self.as_str())?;

        Ok(object.id().into())

    pub url: radicle::git::Url,

    pub pushurl: Option<radicle::git::Url>,

}

    type Error = RemoteError;

        let url = value.url().map_or(Err(RemoteError::MissingUrl), |url| {

            Ok(radicle::git::Url::from_str(url)?)

        })?;

}

impl<'a> Deref for Remote<'a> {

    fn deref(&self) -> &Self::Target {

        &self.inner

}

/// Return the list of radicle remotes for the given repository.

    let remotes: Vec<_> = repo

        .remotes()?

        .iter()

}

/// Check if the git remote is configured for the `Repository`.

    match repo.find_remote(alias) {

        Ok(_) => Ok(true),

        Err(err) => Err(err.into()),

    }

}

/// Get the repository's "rad" remote.

    match radicle::rad::remote(repo) {

        Ok((remote, id)) => Ok((remote, id)),

        Err(radicle::rad::RemoteError::NotFound(_)) => Err(anyhow!(

}

pub fn add_tag(

    message: &str,

    patch_tag_name: &str,

    let head = repo.head()?;

    let oid = repo.tag(patch_tag_name, &commit, &repo.signature()?, message, false)?;

    Ok(oid)

use std::path::{Path, PathBuf};

use radicle::git;

use radicle_surf::diff;

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

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

impl Repo for git::raw::Repository {

    fn blob(&self, oid: git::Oid) -> Result<Blob, git::raw::Error> {

        if blob.is_binary() {

            Ok(Blob::Binary)

        repo: &R,

    ) -> Self::Output {

        let old = None;

        pretty_modification(header, &self.diff, old, new, repo, hi)

    }

        header: &Self::Context,

        repo: &R,

    ) -> Self::Output {

        let new = None;

        pretty_modification(header, &self.diff, old, new, repo, hi)

        header: &Self::Context,

        repo: &R,

    ) -> Self::Output {

        pretty_modification(header, &self.diff, old, new, repo, hi)

    }

    use term::Element;

    use super::*;

    #[test]

    #[ignore]

use thiserror::Error;

use radicle::git;

use radicle_surf::diff;

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

                if old.mode == new.mode {

                    w.meta(format!(

                        "index {}..{} {:o}",

                        u32::from(old.mode.clone()),

                    ))?;

                } else {

                    w.meta(format!("new mode {:o}", u32::from(new.mode.clone())))?;

                    w.meta(format!(

                        "index {}..{}",

                    ))?;

                }

                w.meta(format!("new file mode {:o}", u32::from(new.mode.clone())))?;

                w.meta(format!(

                    "index {}..{}",

                ))?;

                w.meta("--- /dev/null")?;

                ))?;

                w.meta(format!(

                    "index {}..{}",

                ))?;

                w.meta(format!("--- a/{}", path.display()))?;

use radicle::prelude::*;

use crate::git;

use radicle::node::NodeId;

/// Setup a repository remote and tracking branch.

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

use radicle::crypto;

use radicle::node::{Address, Alias};

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

/// Return commits between the merge base and a head.

pub fn patch_commits<'a>(

    repo: &'a git::raw::Repository,

) -> Result<Vec<git::raw::Commit<'a>>, git::raw::Error> {

    let mut commits = Vec::new();

    let mut revwalk = repo.revwalk()?;

/// The message shown in the editor when creating a `Patch`.

fn create_display_message(

    repo: &git::raw::Repository,

) -> Result<String, Error> {

    let commits = patch_commits(repo, base, head)?;

    if commits.is_empty() {

pub fn get_create_message(

    message: term::patch::Message,

    repo: &git::raw::Repository,

) -> Result<(Title, String), Error> {

    let display_msg = create_display_message(repo, base, head)?;

    let message = message.get(&display_msg)?;

/// The message shown in the editor when updating a `Patch`.

fn update_display_message(

    repo: &git::raw::Repository,

) -> Result<String, Error> {

        return Ok(REVISION_MSG.trim_start().to_string());

    }

    message: term::patch::Message,

    repo: &git::raw::Repository,

    latest: &patch::Revision,

) -> Result<String, Error> {

    let message = message.get(&display_msg)?;

    let message = message.trim();

    } else {

        vec![]

    };

    let author = patch.author();

    let author = term::format::Author::new(author.id(), profile, verbose);

    let labels = patch.labels().map(|l| l.to_string()).collect::<Vec<_>>();

    let (from, to) = patch.range()?;

    let mut lines = Vec::new();

        lines.push(term::Line::spaced([

            term::label(term::format::secondary::<String>(

                term::format::oid(commit.id()).into(),

#[cfg(test)]

mod test {

    use super::*;

    use radicle::test::fixtures;

    use std::path;

    fn commit(

        repo: &git::raw::Repository,

        msg: &str,

        let sig = git::raw::Signature::new(

            "anonymous",

            "anonymous@radicle.example.com",

            &git::raw::Time::new(0, 0),

        )

        .unwrap();

        let tree =

            git::write_tree(path::Path::new("README"), "Hello World!\n".as_bytes(), repo).unwrap();

        let branch = git::refs::branch(branch);

        let commit = git::commit(repo, &head, &branch, msg, &sig, &tree).unwrap();

    }

    #[test]

    fn test_create_display_message() {

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

        let (repo, commit_0) = fixtures::repository(&tmpdir);

        let commit_1 = commit(

            &repo,

            &refname!("feature"),

    fn test_update_display_message() {

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

        let (repo, commit_0) = fixtures::repository(&tmpdir);

        let commit_1 = commit(&repo, &refname!("feature"), &commit_0, "commit 1\n");

        let commit_2 = commit(&repo, &refname!("feature"), &commit_1, "commit 2\n");

use anyhow::anyhow;

use radicle::git;

use radicle::prelude::*;

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

/// Give the oid of the branch or an appropriate error.

#[inline]

    let oid = branch

        .get()

        .target()

}

#[inline]

    let (_, _, head, tail) = git_ref.non_empty_components();

    std::iter::once(head).chain(tail).collect()

}

pub fn get_merge_target(

    storage: &Repository,

    head_branch: &git::raw::Branch,

    let (qualified_ref, target_oid) = storage.canonical_head()?;

    let head_oid = branch_oid(head_branch)?;

        anyhow::bail!("commits are already included in the target branch; nothing to do");

    }

}

/// Get the diff stats between two commits.

    old: &Oid,

    new: &Oid,

) -> Result<git::raw::DiffStats, git::raw::Error> {

    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)?;

    revision_oid: Oid,

    head_oid: Oid,

) -> anyhow::Result<term::Line> {

    if a == 0 && b == 0 {

        return Ok(term::Line::new(term::format::dim("up to date")));

    }

            continue;

        }

        if let (Some(oid), Some(name)) = (&r.target(), &r.shorthand()) {

                branches.push(name.to_string());

            };

        };

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

use radicle::crypto::ssh::{keystore::MemorySigner, Keystore};

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

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

use radicle::node::{self, UserAgent};

use radicle::node::{Alias, Config, POLICIES_DB_FILE};

    pub fn repository(

        &self,

        has_alias: &impl HasAlias,

        radicle::test::fixtures::repository(self.work(has_alias).as_path())

    }

default = []

# Only used for testing. Ensures that commit ids are stable.

stable-commit-ids = []

[dependencies]

fastrand = { workspace = true }

log = { workspace = true }

nonempty = { workspace = true, features = ["serialize"] }

radicle-crypto = { workspace = true, features = ["ssh"] }

radicle-dag = { workspace = true }

serde = { workspace = true, features = ["derive"] }

serde_json = { workspace = true }

signature = { workspace = true }

qcheck = { workspace = true }

qcheck-macros = { workspace = true }

radicle-crypto = { workspace = true, features = ["test", "git-ref-format-core"] }

tempfile = { workspace = true }

// Copyright © 2022 The Radicle Link Contributors

pub mod git;

// Copyright © 2022 The Radicle Team

/// Environment variable to set to overwrite the commit date for both the author and the committer.

///

use std::path::PathBuf;

use std::sync::LazyLock;

use nonempty::NonEmpty;

use crate::change::store::Version;

use crate::signatures;

    trailers, Embed,

};

/// Name of the COB manifest file.

pub const MANIFEST_BLOB_NAME: &str = "manifest";

/// Path under which COB embeds are kept.

    use std::str::Utf8Error;

    use std::string::FromUtf8Error;

    use thiserror::Error;

    use crate::signatures::error::Signatures;

    #[derive(Debug, Error)]

    pub enum Create {

        #[error(transparent)]

        #[error(transparent)]

        FromUtf8(#[from] FromUtf8Error),

        #[error(transparent)]

    #[derive(Debug, Error)]

    pub enum Load {

        #[error(transparent)]

        #[error(transparent)]

        Signatures(#[from] Signatures),

        #[error(transparent)]

        let (id, timestamp) = write_commit(

            self,

            // Commit to tips, extra parents and resource.

            tips.iter()

                .cloned()

            signature.clone(),

            related

                .iter()

            tree,

        )?;

    fn parents_of(&self, id: &Oid) -> Result<Vec<Oid>, Self::LoadError> {

        Ok(self

            .parent_ids()

            .map(Oid::from)

            .collect::<Vec<_>>())

    }

    fn manifest_of(&self, id: &Oid) -> Result<crate::Manifest, Self::LoadError> {

        let tree = commit.tree()?;

        load_manifest(self, &tree)

    }

    fn load(&self, id: Self::ObjectId) -> Result<Entry, Self::LoadError> {

        let trailers = parse_trailers(commit.trailers())?;

        let (resources, related): (Vec<_>, Vec<_>) = trailers.iter().partition(|t| match t {

            CommitTrailer::Resource(_) => true,

            CommitTrailer::Related(_) => false,

        });

        let parents = commit

            .parents()

            .map(Oid::from)

            .filter(|p| !resources.contains(p) && !related.contains(p))

            .collect();

            .into_iter()

            .collect::<Vec<_>>();

        let Some((key, sig)) = signatures.pop() else {

) -> Result<(Oid, Timestamp), error::Create> {

    let trailers: Vec<OwnedTrailer> = trailers

        .into_iter()

        .collect();

    let author = repo.signature()?;

    #[allow(unused_variables)]

            .map_err(signatures::error::Signatures::from)?

            .as_str(),

    );

    #[cfg(feature = "stable-commit-ids")]

    // Ensures the commit id doesn't change on every run.

    let (author, timestamp) = {

        (

            Author {

                ..author

            },

            stable,

        )

    };

        let Ok(timestamp) = s.trim().parse::<i64>() else {

            panic!(

                "Invalid timestamp value {s:?} for `{}`",

            );

        };

        let author = Author {

            ..author

        };

        (author, timestamp)

            let oid = embed.content;

            let path = PathBuf::from(embed.name);

        }

        let oid = embeds_tree.write()?;