$ cd my-repo

    $ rad init

repository is created, the Repository Identifier (RID) will be printed.

Share this with collaborators so that they can clone your repository.

✓ Your Radicle DID is did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi. This identifies your device. Run `rad self` to show it at all times.

✓ You're all set.

To get a list of all commands, run `rad help`.

```

│ Radicle Heartwood Protocol & Stack │

│ 0 issues · 0 patches               │

╰────────────────────────────────────╯

```

We can now have a look at the new working copy that was created from the cloned

│ Radicle Heartwood Protocol & Stack │

│ 0 issues · 0 patches               │

╰────────────────────────────────────╯

```

│ Radicle Heartwood Protocol & Stack │

│ 0 issues · 0 patches               │

╰────────────────────────────────────╯

```

Note that attempting to clone into a directory that already exists,

│ Radicle Heartwood Protocol & Stack │

│ 0 issues · 0 patches               │

╰────────────────────────────────────╯

```

We can now have a look at the new working copy that was created from the cloned

```

$ rad fork rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji

```

Now, if we `rad inspect` the project's refs again we will see that we

│ Radicle Heartwood Protocol & Stack │

│ 0 issues · 0 patches               │

╰────────────────────────────────────╯

$ cd ./heartwood

$ git push rad master

```

│ Radicle Heartwood Protocol & Stack │

│ 0 issues · 0 patches               │

╰────────────────────────────────────╯

$ cd ./heartwood

$ git push rad master

```

│ radicle heartwood protocol & stack │

│ 0 issues · 0 patches               │

╰────────────────────────────────────╯

```

```

$ rad init --name heartwood --description "radicle heartwood protocol & stack" --no-confirm --private

You can show it any time by running `rad .` from this directory.

You have created a private repository.

```

$ rad init --name heartwood --description "Radicle Heartwood Protocol & Stack" --no-confirm --public --scope followed

You can show it any time by running `rad .` from this directory.

✗ Announcing.. <canceled>

Check for peer connections with `rad node status`.

To push changes, run `git push`.

```

$ rad init --name heartwood --description "Radicle Heartwood Protocol & Stack" --no-confirm --public --scope followed

You can show it any time by running `rad .` from this directory.

View it in your browser at:

    https://app.radicle.xyz/nodes/[...]/rad:z3Rry7rpdWuGpfjPYGzdJKQADsoNW

```

$ rad init --name heartwood --description "Radicle Heartwood Protocol & Stack" --no-confirm --public --scope followed

You can show it any time by running `rad .` from this directory.

To push changes, run `git push`.

```

the `init` command:

```

$ rad init --name heartwood --description "Radicle Heartwood Protocol & Stack" --no-confirm --public --scope followed

You can show it any time by running `rad .` from this directory.

To push changes, run `git push`.

```

```

$ rad init --name heartwood --description "Heartwood Protocol & Stack" --no-confirm --public

You can show it any time by running `rad .` from this directory.

You can start your node with `rad node start`.

To push changes, run `git push rad master`.

```

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

```

$ rad init --name heartwood --description "Radicle Heartwood Protocol & Stack" --no-confirm --public -v

{

  "name": "heartwood",

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

  "defaultBranch": "master"

}

You can show it any time by running `rad .` from this directory.

You can start your node with `rad node start`.

To push changes, run `git push`.

```

Let's look at how patch updates work.

``` ~alice

$ rad init --name heartwood --description "radicle heartwood protocol & stack" --no-confirm --public

You can show it any time by running `rad .` from this directory.

To push changes, run `git push`.

```

│ radicle heartwood protocol & stack │

│ 0 issues · 0 patches               │

╰────────────────────────────────────╯

```

We fork the repository by pushing to `master`, and wait for Alice to sync

    term::success!("You're all set.");

    term::blank();

    term::info!(

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

    );

    term::info!(

        term::format::command("rad clone <rid>"),

        term::format::command("rad clone rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5")

    );

pub const HELP: Help = Help {

    name: "checkout",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

    rad checkout <rid> [--remote <did>] [<option>...]

Options

    --remote <did>  Remote peer to checkout

        Ok((

            Options {

                remote,

            },

            vec![],

    let doc: Doc<_> = storage

        .repository(id)?

        .identity_doc()

        .into();

    let payload = doc.project()?;

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

pub const HELP: Help = Help {

    name: "clean",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

pub const HELP: Help = Help {

    name: "clone",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

    let default_branch = proj.default_branch().clone();

    let path = working.workdir().unwrap(); // SAFETY: The working copy is not bare.

    radicle::git::configure_repository(&working)?;

    checkout::setup_remotes(

        project::SetupRemote {

        .directory

        .map_or(proj.name().to_string(), |loc| loc.display().to_string());

    term::info!(

        term::format::command(format!("cd ./{location}")),

    );

    let results = sync::fetch(id, mode, timeout, node)?;

    let Ok(repository) = storage.repository(id) else {

        // there's nothing we can do.

        if results.is_empty() {

            return Err(CloneError::NoSeeds(id));

pub const HELP: Help = Help {

    name: "fork",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

        Some(rid) => rid,

        None => {

            let (_, rid) =

            rid

        }

    };

    rad::fork(rid, &signer, &storage)?;

    Ok(())

}

pub const HELP: Help = Help {

    name: "init",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

Options

        --scope <scope>            Repository follow scope (default: all)

        --private                  Set repository visibility to *private*

        --public                   Set repository visibility to *public*

                        .all(|c| c.is_alphanumeric() || allowed.contains(&c))

                    {

                        anyhow::bail!(

                            only alphanumeric characters, '-', '_' and '.' are allowed"

                        );

                    }

                        .value()?

                        .to_str()

                        .ok_or(anyhow::anyhow!(

                        ))?

                        .to_owned();

        .ok_or_else(|| anyhow!("repository head must point to a commit"))?;

    term::headline(format!(

        if let Some(visibility) = &options.visibility {

            term::format::spaced(term::format::visibility(visibility))

        } else {

            let proj = doc.project()?;

            spinner.message(format!(

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

            ));

            spinner.finish();

            term::blank();

            term::info!(

                term::format::dim("(RID)"),

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

            );

            if let Err(e) = announce(rid, doc, &mut node, &profile.config) {

                term::blank();

                term::warning(format!(

                ));

                term::warning("Try again with `rad sync --announce`, or check your logs with `rad node logs`.");

                term::blank();

    if !replicas.is_empty() {

        spinner.message(format!(

            replicas.len()

        ));

        spinner.finish();

        }

        Ok(SyncResult::Synced { result: None })

    } else {

        spinner.finish();

        Ok(SyncResult::NotSynced)

            }) => {

                term::blank();

                term::info!(

                    now discoverable by peers.",

                );

                term::info!("View it in your browser at:");

            Ok(SyncResult::Synced { result: None, .. }) => {

                term::blank();

                term::info!(

                    now discoverable by peers.",

                );

                if !config.preferred_seeds.is_empty() {

                    term::info!(

                        your preferred seeds."

                    );

                }

            Ok(SyncResult::NotSynced) => {

                term::blank();

                term::info!(

                    now discoverable by peers.",

                );

                term::info!(

                    `rad sync status`."

                );

                term::blank();

            Ok(SyncResult::NoPeersConnected) => {

                term::blank();

                term::info!(

                    your node establishes a connection with the network.");

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

                term::blank();

            }

            Ok(SyncResult::NodeStopped) => {

                term::info!(

                );

                term::info!(

                    "You can start your node with {}.",

        Some(rid) => rid,

        None => radicle::rad::cwd()

            .map(|(_, rid)| rid)

    };

    if options.target == Target::RepoId {

    let storage = &profile.storage;

    let repo = storage

        .repository(rid)

    let project = repo.identity_doc()?;

    match options.target {

pub const HELP: Help = Help {

    name: "ls",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

    let (workdir, id) = radicle::rad::cwd()

    let profile = ctx.profile()?;

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

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

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

    let _project = repository.identity_doc().context(format!(

        repository.id

    ))?;

    let mut patches = Patches::open(repository)?;

        Some(rid) => rid,

        None => radicle::rad::cwd()

            .map(|(_, rid)| rid)

    };

    let repo = profile.storage.repository_mut(rid)?;

pub const HELP: Help = Help {

    name: "remote",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

pub fn run(options: Options, ctx: impl Context) -> anyhow::Result<()> {

    let (working, rid) = radicle::rad::cwd()

    let profile = ctx.profile()?;

    match options.op {

        Some(rid) => rid,

        None => {

            let (_, rid) =

            rid

        }

        Some(rid) => rid,

        None => {

            let (_, rid) =

            rid

        }

    };

    Storage(#[from] storage::Error),

    #[error("payload: {0}")]

    Payload(#[from] doc::PayloadError),

    NotFound(RepoId),

    #[error("repository: {0}")]

    Repository(#[from] RepositoryError),

    Git(#[from] git2::Error),

    #[error("payload: {0}")]

    Payload(#[from] doc::PayloadError),

    NotFound(RepoId),

    #[error("repository: {0}")]

    Repository(#[from] RepositoryError),

    Ok(())

}

///

/// It will atempt to search parent directories if `path` did not find

/// a git repository.