Alice initializes a *private* repo.

``` ~alice

Initializing private radicle 👾 project in .

Your project's Repository ID (RID) is rad:z2ug5mwNKZB8KGpBDRTrWHAMbvHCu.

```

Bob tries to clone it, and even though he's connected to Alice, it fails.

the `init` command:

```

Your project's Repository ID (RID) is rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji.

```

`init` command.  Make sure you have [authenticated](../rad-auth.md) beforehand.

```

{

  "name": "heartwood",

  "description": "Radicle Heartwood Protocol & Stack",

}

Your project's Repository ID (RID) is rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji.

```

Projects can be listed with the `ls` command:

Alice creates a project and Bob clones it.

``` ~alice

Your project's Repository ID (RID) is rad:zhbMU4DUXrzB8xT6qAJh6yZ7bFMK.

```

``` ~bob

    if let Ok(version) = radicle::git::version() {

        if version < radicle::git::VERSION_REQUIRED {

                "Your git version is unsupported, please upgrade to {} or later",

                radicle::git::VERSION_REQUIRED,

            ));

fn warn_out_of_date(revision: &Revision, previous: &Identity<Oid>) {

    if revision.current != previous.current {

        term::warning("Revision is out of date");

        term::tip!("Consider using 'rad id rebase' to update the proposal to the latest identity");

    }

}

#![allow(clippy::or_fun_call)]

use std::convert::TryFrom;

use std::env;

use std::ffi::OsString;

use std::path::PathBuf;

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

use serde_json as json;

use radicle::git::RefString;

use radicle::identity::Visibility;

use radicle::node::tracking::Scope;

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

use crate::git;

use crate::terminal as term;

        --description <string>     Description of the project

        --default-branch <name>    The default branch of the project

        --scope <scope>            Tracking scope (default: all)

    -u, --set-upstream             Setup the upstream of the default branch

        --setup-signing            Setup the radicle key as a signing key for this repository

        --no-confirm               Don't ask for confirmation during setup

    -v, --verbose                  Verbose mode

        --help                     Print help

    pub description: Option<String>,

    pub branch: Option<String>,

    pub interactive: Interactive,

    pub setup_signing: bool,

    pub scope: Scope,

    pub set_upstream: bool,

    pub verbose: bool,

    pub track: bool,

}

        let mut interactive = Interactive::Yes;

        let mut set_upstream = false;

        let mut setup_signing = false;

        let mut scope = Scope::All;

        let mut track = true;

        let mut verbose = false;

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

            match arg {

                Long("setup-signing") => {

                    setup_signing = true;

                }

                Long("no-confirm") => {

                    interactive = Interactive::No;

                }

                    track = false;

                }

                Long("private") => {

                }

                Long("verbose") | Short('v') => {

                    verbose = true;

                interactive,

                set_upstream,

                setup_signing,

                track,

                visibility,

                verbose,

    term::headline(format!(

        "Initializing{}radicle 👾 project in {}",

        } else {

            term::format::default(" ")

        },

        if path == cwd {

        } else {

        }

    ));

    if let Ok((remote, _)) = git::rad_remote(&repo) {

        if let Some(remote) = remote.url() {

            bail!("repository is already initialized with remote {remote}");

        }

    }

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

    let head: String = repo

        .head()

    });

    let branch = RefString::try_from(branch.clone())

        .map_err(|e| anyhow!("invalid branch name {:?}: {}", branch, e))?;

    let mut node = radicle::Node::new(profile.socket());

    let mut spinner = term::spinner("Initializing...");

        &name,

        &description,

        branch,

        &signer,

        &profile.storage,

    ) {

            }

            spinner.message(format!(

                term::format::highlight(proj.name())

            ));

            spinner.finish();

                self::setup_signing(profile.id(), &repo, interactive)?;

            }

            term::blank();

            term::info!(

                "Your project's Repository ID {} is {}.",

                term::format::highlight(id.urn())

            );

            term::info!(

                term::format::command("rad .")

            );

                term::blank();

            }

        }

        Err(err) => {

            spinner.failed();

    Ok(())

}

/// Setup radicle key as commit signing key in repository.

pub fn setup_signing(

    node_id: &NodeId,

        let mut rid: Option<Id> = None;

        let mut json: bool = false;

        let mut addr: Option<PeerAddr<NodeId, Address>> = None;

        let mut count: usize = usize::MAX;

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

        let mut verbose = false;

    };

    if let Err(e) = result {

        term::warning("Make sure to untrack this repository when your node is running");

    } else {

        term::success!("Untracked {rid}")

        .map_err(|err| err.into())

        .and_then(|repo| git::remove_remote(&repo, rid))

    {

            "Attempted to remove 'rad' remote from working copy: {e}"

        ));

        term::warning("In case a working copy exists, make sure to `git remote remove rad`");

                "Radicle Heartwood Protocol & Stack",

                "--default-branch",

                "master",

            ],

            working.join("alice"),

        )

    prompt_prefix: Styled::new("?").with_fg(Color::LightBlue),

    answered_prompt_prefix: Styled::new("✓").with_fg(Color::LightGreen),

    answer: StyleSheet::new(),

    help_message: StyleSheet::new().with_fg(Color::DarkGrey),

    default_value: StyleSheet::new().with_fg(Color::LightBlue),

    error_message: ErrorMessageRenderConfig::default_colored()

    println!("{}", style(format!("Running `{msg}`...")).dim());

}

    println!(

        "{} {} {warning}",

        WARNING_PREFIX,

    Ok(Passphrase::from(input.trim_end().to_owned()))

}

where

    T: fmt::Display + Eq + PartialEq,

{

}

pub fn markdown(content: &str) {

            "editor",

            "prompt",

        ],

    )?;

            if terminal::confirm("Would you like to proceed?") {

                terminal::success!("You said 'yes'");

            }

        }

            let output = terminal::editor::Editor::new()

                .extension("rs")

                .edit("// Enter code here.");

                }

            }

        }

            let mut spinner = terminal::spinner("Spinning turbines..");

            thread::sleep(time::Duration::from_secs(1));

            spinner.message("Still spinning..");

            spinner.finish();

        }

            let _spinner = terminal::spinner("Spinning turbines..");

            thread::sleep(time::Duration::from_secs(3));

        }

            let spinner = terminal::spinner("Spinning turbines..");

            thread::sleep(time::Duration::from_secs(3));

            spinner.error("broken turbine");

        }

            let fruit = terminal::io::select(

                "Enter your favorite fruit:",

                &["apple", "pear", "banana", "strawberry"],

            )?;

        }

        _ => {}

    }