Initializing your 🌱 profile and identity

ok Creating your 🌱 Ed25519 keypair...

Your radicle Node ID is z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi. This identifies your device.

```

$ rad self

Key (hash)     SHA256:UIedaL6Cxm6OUErh9GQUzzglSk7VpQlVTI1TAFB/HWA

Key (full)     AAAAC3NzaC1lZDI1NTE5AAAAIHahWSBEpuT1ESZbynOmBNkLBSnR32Ar4woZqSV2YNH1

Storage (git)  [..]/storage

work.

```

Added delegate 'did:key:z6MkjchhfUsD6mmvni8mCdXHw216Xrm9bQe2mBH1P5RDjVJG'

ok Update successful!

```

the torch and remove ourselves from the delegate set.

```

Removed delegate 'did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi'

ok Update successful!

```

delegates creating proposals concurrently.

```

ok Identity proposal '57332790a2eabc0b2fd8c7ff48c3579d5812d405' created 🌱

title: Add Alice

description: Add Alice as a delegate

```

```

ok Identity proposal 'c3698d4e85f9d4c0ee536b34d6122fc7c81f7e2e' created 🌱

title: Add Bob

description: Add Bob as a delegate

We can now update the proposal to have both keys in the delegates set:

```

ok Identity proposal 'c3698d4e85f9d4c0ee536b34d6122fc7c81f7e2e' updated 🌱

ok Revision 'z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/6'

title: Add Bob

gather a quorum of signatures to update the Radicle identity. To do

this, we use the `rad id` command.

```

ok Identity proposal '06d9efa2a9aad06bfdf25a25690e1ec7db2c3c39' created 🌱

title: Add Bob

description: Add Bob as a delegate

Let's assign ourselves to this one.

```

```

It will now show in the list of issues assigned to us.

```

$ rad issue list --assigned

```

Note: this can always be undone with the `unassign` subcommand.

```

```

Great, now we have communicated to the world about our car's defect.

use std::str::FromStr;

use anyhow::anyhow;

use crate::terminal as term;

use crate::terminal::args;

    usage: r#"

Usage

Options

#[derive(Debug)]

pub struct Options {

    pub id: issue::IssueId,

}

impl args::Args for Options {

        let mut parser = lexopt::Parser::from_args(args);

        let mut id: Option<issue::IssueId> = None;

        while let Some(arg) = parser.next()? {

            match arg {

                        id = Some(val);

                    } else if peer.is_none() {

                    } else {

                        return Err(anyhow!(arg.unexpected()));

                    }

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

        _ => err.into(),

    })?;

    Ok(())

}

    term::success!(

        "Profile {} created.",

    );

    term::blank();

use anyhow::{anyhow, Context as _};

use radicle::identity::Id;

use crate::terminal as term;

use crate::terminal::args::{Args, Error, Help};

    usage: r#"

Usage

    rad delegate list [<id>]

    The `add` and `remove` commands are limited to managing delegates

#[derive(Debug, Eq, PartialEq)]

pub enum Operation {

    List { id: Option<Id> },

}

        let mut parser = lexopt::Parser::from_args(args);

        let mut id: Option<Id> = None;

        let mut op: Option<OperationName> = None;

        while let Some(arg) = parser.next()? {

            match arg {

                    unknown => anyhow::bail!("unknown operation '{}'", unknown),

                },

                        }

                    }

                _ => return Err(anyhow!(arg.unexpected())),

            }

        }

            OperationName::List => Operation::List { id },

            OperationName::Add => Operation::Add {

                id,

            },

            OperationName::Remove => Operation::Remove {

                id,

            },

        };

    let storage = &profile.storage;

    match options.op {

        Operation::List { id } => list::run(&profile, storage, get_id(id)?)?,

    }

use radicle::cob::identity::{self, Proposal, ProposalId, Proposals, Revision, RevisionId};

use radicle::git::Oid;

use radicle::identity::Identity;

use radicle::storage::ReadStorage as _;

use crate::terminal::args::{Args, Error, Help};

use crate::terminal::{self as term, Interactive};

Usage

    rad id (update|edit) [--title|-t] [--description|-d]

                         [--no-confirm]

    rad id list

    rad id (show|rebase) <id> [--rev <revision id>]

    Edit {

        title: Option<String>,

        description: Option<String>,

        threshold: Option<usize>,

    },

    Update {

        rev: Option<RevisionId>,

        title: Option<String>,

        description: Option<String>,

        threshold: Option<usize>,

    },

    Rebase {

        let mut rev: Option<RevisionId> = None;

        let mut title: Option<String> = None;

        let mut description: Option<String> = None;

        let mut threshold: Option<usize> = None;

        let mut interactive = Interactive::Yes;

        let mut show_revisions = false;

                    );

                }

                Long("delegates") => {

                }

                Long("threshold") => {

                    threshold = Some(parser.value()?.to_string_lossy().parse()?);

            let proposed = {

                let mut proposed = previous.doc.clone();

                proposed.threshold = threshold.unwrap_or(proposed.threshold);

                proposed

            };

            let proposed = {

                let mut proposed = revision.proposed.clone();

                proposed.threshold = threshold.unwrap_or(revision.proposed.threshold);

                proposed

            };

use std::str::FromStr;

use anyhow::{anyhow, Context as _};

use crate::terminal as term;

use crate::terminal::args::{Args, Error, Help};

    rad issue

    rad issue delete <id>

    rad issue open [--title <title>] [--description <text>]

    rad issue react <id> [--emoji <char>]

    rad issue show <id>

pub struct Metadata {

    title: String,

    labels: Vec<Tag>,

}

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

pub enum Assigned {

    #[default]

    Me,

}

#[derive(Debug, PartialEq, Eq)]

                }

                Long("assigned") | Short('a') if assigned.is_none() => {

                    if let Ok(val) = parser.value() {

                        assigned = Some(Assigned::Peer(peer));

                    } else {

                        assigned = Some(Assigned::Me);

                    &meta.title,

                    description.trim(),

                    meta.labels.as_slice(),

                    &signer,

                )?;

            }

        Operation::List { assigned } => {

            let assignee = match assigned {

                Some(Assigned::Me) => Some(*profile.id()),

                None => None,

            };

                let (id, issue, _) = result?;

                let assigned: Vec<_> = issue.assigned().collect();

                    continue;

                }

fn all(profile: &Profile) -> anyhow::Result<()> {

    let mut table = term::Table::default();

    let node_id = profile.id();

    let ssh_short = ssh::fmt::fingerprint(node_id);

    table.push(["Key (hash)", &term::format::tertiary(ssh_short)]);

use std::str::FromStr;

use anyhow::anyhow;

use crate::terminal as term;

use crate::terminal::args::{Args, Error, Help};

#[derive(Debug)]

pub struct Options {

    pub id: issue::IssueId,

}

impl Args for Options {

        let mut parser = lexopt::Parser::from_args(args);

        let mut id: Option<issue::IssueId> = None;

        while let Some(arg) = parser.next()? {

            match arg {

                        id = Some(val);

                    } else if peer.is_none() {

                    } else {

                        return Err(anyhow!(arg.unexpected()));

                    }

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

        _ => err.into(),

    })?;

    Ok(())

}

    Ok(())

}

    let val = val.to_string_lossy();

    let Ok(peer) = Did::from_str(&val) else {

        if crypto::PublicKey::from_str(&val).is_ok() {

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

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

use crate::crypto::{PublicKey, Signer};

use crate::storage::git as storage;

/// Issue operation.

}

impl Issue {

    }

    pub fn title(&self) -> &str {

        let id = issue.id;

        let issue = issues.get(&id).unwrap().unwrap();

        assert_eq!(1, assignees.len());

        let mut issue = issues.get_mut(&id).unwrap();

        issue.assign([assignee_two], &signer).unwrap();

        let id = issue.id;

        let issue = issues.get(&id).unwrap().unwrap();

        assert_eq!(2, assignees.len());

    }

    #[test]

        let id = issue.id;

        let issue = issues.get(&id).unwrap().unwrap();

        assert_eq!(2, assignees.len());

    }

    #[test]

        let id = issue.id;

        let issue = issues.get(&id).unwrap().unwrap();

        assert_eq!(1, assignees.len());

    }

    #[test]

use crate::crypto::ssh::{keystore, Keystore, Passphrase};

use crate::crypto::{PublicKey, Signer};

use crate::node;

use crate::storage::git::transport;

use crate::storage::git::Storage;

        &self.public_key

    }

    pub fn signer(&self) -> Result<Box<dyn Signer>, Error> {

        if let Some(passphrase) = env::read_passphrase() {

            let signer = keystore::MemorySigner::load(&self.keystore, passphrase)?;