From 8ba3087cb996d38b84bfed4acdb568ea0457ab91 Mon Sep 17 00:00:00 2001
From: Richard Levitte <richard@levitte.org>
Date: Fri, 3 Oct 2025 22:01:04 +0200
Subject: [PATCH] cli/init: use Clap

---
 crates/radicle-cli/src/commands/help.rs      |   5 +-
 crates/radicle-cli/src/commands/init.rs      | 223 +++----------------
 crates/radicle-cli/src/commands/init/args.rs | 141 ++++++++++++
 crates/radicle-cli/src/main.rs               |   5 +-
 4 files changed, 185 insertions(+), 189 deletions(-)
 create mode 100644 crates/radicle-cli/src/commands/init/args.rs

diff --git a/crates/radicle-cli/src/commands/help.rs b/crates/radicle-cli/src/commands/help.rs
index d9962998..66a53974 100644
--- a/crates/radicle-cli/src/commands/help.rs
+++ b/crates/radicle-cli/src/commands/help.rs
@@ -58,7 +58,10 @@ const COMMANDS: &[CommandItem] = &[
     },
     CommandItem::Lexopt(crate::commands::help::HELP),
     CommandItem::Lexopt(crate::commands::id::HELP),
-    CommandItem::Lexopt(crate::commands::init::HELP),
+    CommandItem::Clap {
+        name: "init",
+        about: crate::commands::init::ABOUT,
+    },
     CommandItem::Lexopt(crate::commands::inbox::HELP),
     CommandItem::Lexopt(crate::commands::inspect::HELP),
     CommandItem::Clap {
diff --git a/crates/radicle-cli/src/commands/init.rs b/crates/radicle-cli/src/commands/init.rs
index f79d004b..0d74ccf7 100644
--- a/crates/radicle-cli/src/commands/init.rs
+++ b/crates/radicle-cli/src/commands/init.rs
@@ -1,10 +1,14 @@
 #![allow(clippy::or_fun_call)]
 #![allow(clippy::collapsible_else_if)]
+
+mod args;
+
+pub use args::Args;
+pub(crate) use args::ABOUT;
+
 use std::collections::HashSet;
 use std::convert::TryFrom;
 use std::env;
-use std::ffi::OsString;
-use std::path::PathBuf;
 use std::str::FromStr;
 
 use anyhow::{anyhow, bail, Context as _};
@@ -18,7 +22,6 @@ use radicle::git::RefString;
 use radicle::identity::project::ProjectName;
 use radicle::identity::{Doc, RepoId, Visibility};
 use radicle::node::events::UploadPack;
-use radicle::node::policy::Scope;
 use radicle::node::{Event, Handle, NodeId, DEFAULT_SUBSCRIBE_TIMEOUT};
 use radicle::storage::ReadStorage as _;
 use radicle::{profile, Node};
@@ -26,168 +29,12 @@ use radicle::{profile, Node};
 use crate::commands;
 use crate::git;
 use crate::terminal as term;
-use crate::terminal::args::{Args, Error, Help};
 use crate::terminal::Interactive;
 
-pub const HELP: Help = Help {
-    name: "init",
-    description: "Initialize a Radicle repository",
-    version: env!("RADICLE_VERSION"),
-    usage: r#"
-Usage
-
-    rad init [<path>] [<option>...]
-
-Options
-
-        --name <string>            Name of the repository
-        --description <string>     Description of the repository
-        --default-branch <name>    The default branch of the repository
-        --scope <scope>            Repository follow scope: `followed` or `all` (default: all)
-        --private                  Set repository visibility to *private*
-        --public                   Set repository visibility to *public*
-        --existing <rid>           Setup repository as an existing Radicle repository
-    -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
-        --no-seed                  Don't seed this repository after initializing it
-    -v, --verbose                  Verbose mode
-        --help                     Print help
-"#,
-};
-
-#[derive(Default)]
-pub struct Options {
-    pub path: Option<PathBuf>,
-    pub name: Option<ProjectName>,
-    pub description: Option<String>,
-    pub branch: Option<String>,
-    pub interactive: Interactive,
-    pub visibility: Option<Visibility>,
-    pub existing: Option<RepoId>,
-    pub setup_signing: bool,
-    pub scope: Scope,
-    pub set_upstream: bool,
-    pub verbose: bool,
-    pub seed: bool,
-}
-
-impl Args for Options {
-    fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {
-        use lexopt::prelude::*;
-
-        let mut parser = lexopt::Parser::from_args(args);
-        let mut path: Option<PathBuf> = None;
-
-        let mut name = None;
-        let mut description = None;
-        let mut branch = None;
-        let mut interactive = Interactive::Yes;
-        let mut set_upstream = false;
-        let mut setup_signing = false;
-        let mut scope = Scope::All;
-        let mut existing = None;
-        let mut seed = true;
-        let mut verbose = false;
-        let mut visibility = None;
-
-        while let Some(arg) = parser.next()? {
-            match arg {
-                Long("name") if name.is_none() => {
-                    let value = parser.value()?;
-                    let value = term::args::string(&value);
-                    let value = ProjectName::try_from(value)?;
-
-                    name = Some(value);
-                }
-                Long("description") if description.is_none() => {
-                    let value = parser
-                        .value()?
-                        .to_str()
-                        .ok_or(anyhow::anyhow!(
-                            "invalid repository description specified with `--description`"
-                        ))?
-                        .to_owned();
-
-                    description = Some(value);
-                }
-                Long("default-branch") if branch.is_none() => {
-                    let value = parser
-                        .value()?
-                        .to_str()
-                        .ok_or(anyhow::anyhow!(
-                            "invalid branch specified with `--default-branch`"
-                        ))?
-                        .to_owned();
-
-                    branch = Some(value);
-                }
-                Long("scope") => {
-                    let value = parser.value()?;
-
-                    scope = term::args::parse_value("scope", value)?;
-                }
-                Long("set-upstream") | Short('u') => {
-                    set_upstream = true;
-                }
-                Long("setup-signing") => {
-                    setup_signing = true;
-                }
-                Long("no-confirm") => {
-                    interactive = Interactive::No;
-                }
-                Long("no-seed") => {
-                    seed = false;
-                }
-                Long("private") => {
-                    visibility = Some(Visibility::private([]));
-                }
-                Long("public") => {
-                    visibility = Some(Visibility::Public);
-                }
-                Long("existing") if existing.is_none() => {
-                    let val = parser.value()?;
-                    let rid = term::args::rid(&val)?;
-
-                    existing = Some(rid);
-                }
-                Long("verbose") | Short('v') => {
-                    verbose = true;
-                }
-                Long("help") | Short('h') => {
-                    return Err(Error::Help.into());
-                }
-                Value(val) if path.is_none() => {
-                    path = Some(val.into());
-                }
-                _ => anyhow::bail!(arg.unexpected()),
-            }
-        }
-
-        Ok((
-            Options {
-                path,
-                name,
-                description,
-                branch,
-                scope,
-                existing,
-                interactive,
-                set_upstream,
-                setup_signing,
-                seed,
-                visibility,
-                verbose,
-            },
-            vec![],
-        ))
-    }
-}
-
-pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
+pub fn run(args: Args, ctx: impl term::Context) -> anyhow::Result<()> {
     let profile = ctx.profile()?;
     let cwd = env::current_dir()?;
-    let path = options.path.as_deref().unwrap_or(cwd.as_path());
+    let path = args.path.as_deref().unwrap_or(cwd.as_path());
     let repo = match git::Repository::open(path) {
         Ok(r) => r,
         Err(e) if e.is_not_found() => {
@@ -201,20 +48,18 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
         }
     }
 
-    if let Some(rid) = options.existing {
-        init_existing(repo, rid, options, &profile)
+    if let Some(rid) = args.existing {
+        init_existing(repo, rid, args, &profile)
     } else {
-        init(repo, options, &profile)
+        init(repo, args, &profile)
     }
 }
 
-pub fn init(
-    repo: git::Repository,
-    options: Options,
-    profile: &profile::Profile,
-) -> anyhow::Result<()> {
+pub fn init(repo: git::Repository, args: Args, profile: &profile::Profile) -> anyhow::Result<()> {
     let path = dunce::canonicalize(repo.workdir().unwrap_or_else(|| repo.path()))?;
-    let interactive = options.interactive;
+    let interactive = args.interactive();
+    let visibility = args.visibility();
+    let seed = args.seed();
 
     let default_branch = match find_default_branch(&repo) {
         Err(err @ DefaultBranchError::Head) => {
@@ -233,21 +78,22 @@ pub fn init(
 
     term::headline(format!(
         "Initializing{}radicle 👾 repository in {}..",
-        if let Some(visibility) = &options.visibility {
-            term::format::spaced(term::format::visibility(visibility))
-        } else {
-            term::format::default(" ").into()
+        match visibility {
+            Some(ref visibility) => term::format::spaced(term::format::visibility(visibility)),
+            None => term::format::default(" ").into(),
         },
         term::format::dim(path.display())
     ));
 
-    let name: ProjectName = match options.name {
+    let name: ProjectName = match args.name {
         Some(name) => name,
         None => {
             let default = path
                 .file_name()
                 .and_then(|f| f.to_str())
                 .and_then(|f| ProjectName::try_from(f).ok());
+            // TODO(finto): this is interactive without checking `interactive` –
+            // this should check if interactive and use the default if not
             let name = term::input(
                 "Name",
                 default,
@@ -257,13 +103,13 @@ pub fn init(
             name.ok_or_else(|| anyhow::anyhow!("A project name is required."))?
         }
     };
-    let description = match options.description {
+    let description = match args.description {
         Some(desc) => desc,
         None => {
             term::input("Description", None, Some("You may leave this blank"))?.unwrap_or_default()
         }
     };
-    let branch = match options.branch {
+    let branch = match args.branch {
         Some(branch) => branch,
         None if interactive.yes() => term::input(
             "Default branch",
@@ -275,9 +121,11 @@ pub fn init(
     };
     let branch = RefString::try_from(branch.clone())
         .map_err(|e| anyhow!("invalid branch name {:?}: {}", branch, e))?;
-    let visibility = if let Some(v) = options.visibility {
+    let visibility = if let Some(v) = visibility {
         v
     } else {
+        // TODO(finto): this is interactive without checking `interactive` –
+        // this should check if interactive and use the `private` if not
         let selected = term::select(
             "Visibility",
             &["public", "private"],
@@ -309,20 +157,20 @@ pub fn init(
             ));
             spinner.finish();
 
-            if options.verbose {
+            if args.verbose {
                 term::blob(json::to_string_pretty(&proj)?);
             }
             // It's important to seed our own repositories to make sure that our node signals
             // interest for them. This ensures that messages relating to them are relayed to us.
-            if options.seed {
-                profile.seed(rid, options.scope, &mut node)?;
+            if seed {
+                profile.seed(rid, args.scope, &mut node)?;
 
                 if doc.is_public() {
                     profile.add_inventory(rid, &mut node)?;
                 }
             }
 
-            if options.set_upstream || git::branch_remote(&repo, proj.default_branch()).is_err() {
+            if args.set_upstream || git::branch_remote(&repo, proj.default_branch()).is_err() {
                 // Setup eg. `master` -> `rad/master`
                 radicle::git::set_upstream(
                     &repo,
@@ -334,7 +182,7 @@ pub fn init(
                 push_cmd = format!("git push {} {branch}", *radicle::rad::REMOTE_NAME);
             }
 
-            if options.setup_signing {
+            if args.setup_signing {
                 // Setup radicle signing key.
                 self::setup_signing(profile.id(), &repo, interactive)?;
             }
@@ -379,12 +227,13 @@ pub fn init(
 pub fn init_existing(
     working: git::Repository,
     rid: RepoId,
-    options: Options,
+    args: Args,
     profile: &profile::Profile,
 ) -> anyhow::Result<()> {
     let stored = profile.storage.repository(rid)?;
     let project = stored.project()?;
     let url = radicle::git::Url::from(rid);
+    let interactive = args.interactive();
 
     radicle::git::configure_repository(&working)?;
     radicle::git::configure_remote(
@@ -394,7 +243,7 @@ pub fn init_existing(
         &url.clone().with_namespace(profile.public_key),
     )?;
 
-    if options.set_upstream {
+    if args.set_upstream {
         // Setup eg. `master` -> `rad/master`
         radicle::git::set_upstream(
             &working,
@@ -404,9 +253,9 @@ pub fn init_existing(
         )?;
     }
 
-    if options.setup_signing {
+    if args.setup_signing {
         // Setup radicle signing key.
-        self::setup_signing(profile.id(), &working, options.interactive)?;
+        self::setup_signing(profile.id(), &working, interactive)?;
     }
 
     term::success!(
diff --git a/crates/radicle-cli/src/commands/init/args.rs b/crates/radicle-cli/src/commands/init/args.rs
new file mode 100644
index 00000000..f1fb5f0d
--- /dev/null
+++ b/crates/radicle-cli/src/commands/init/args.rs
@@ -0,0 +1,141 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+use radicle::{
+    identity::{project::ProjectName, Visibility},
+    node::policy::Scope,
+    prelude::RepoId,
+};
+use radicle_term::Interactive;
+
+pub(crate) const ABOUT: &str = "Initialize a Radicle repository";
+
+#[derive(Debug, Parser)]
+#[command(about = ABOUT, disable_version_flag = true)]
+pub struct Args {
+    /// Directory to be initialized
+    pub(super) path: Option<PathBuf>,
+    /// Name of the repository
+    #[arg(long, value_name = "STRING")]
+    pub(super) name: Option<ProjectName>,
+    /// Description of the repository
+    #[arg(long, value_name = "STRING")]
+    pub(super) description: Option<String>,
+    /// The default branch of the repository
+    #[arg(long = "default-branch", value_name = "STRING")]
+    pub(super) branch: Option<String>,
+    /// Repository follow scope
+    #[arg(
+        long,
+        default_value_t = Scope::All,
+        value_name = "SCOPE",
+        value_parser = ScopeParser,
+    )]
+    pub(super) scope: Scope,
+    /// Set repository visibility to *private*
+    #[arg(long, conflicts_with = "public")]
+    private: bool,
+    /// Set repository visibility to *public*
+    #[arg(long, conflicts_with = "private")]
+    public: bool,
+    /// Setup repository as an existing Radicle repository
+    ///
+    /// [example values: rad:z3Tr6bC7ctEg2EHmLvknUr29mEDLH, z3Tr6bC7ctEg2EHmLvknUr29mEDLH]
+    #[arg(long, value_name = "RID")]
+    pub(super) existing: Option<RepoId>,
+    /// Setup the upstream of the default branch
+    #[arg(short = 'u', long)]
+    pub(super) set_upstream: bool,
+    /// Setup the radicle key as a signing key for this repository
+    #[arg(long)]
+    pub(super) setup_signing: bool,
+    /// Don't ask for confirmation during setup
+    #[arg(long)]
+    no_confirm: bool,
+    /// Don't seed this repository after initializing it
+    #[arg(long)]
+    no_seed: bool,
+    /// Verbose mode
+    #[arg(short, long)]
+    pub(super) verbose: bool,
+}
+
+impl Args {
+    pub(super) fn interactive(&self) -> Interactive {
+        if self.no_confirm {
+            Interactive::No
+        } else {
+            Interactive::Yes
+        }
+    }
+
+    pub(super) fn visibility(&self) -> Option<Visibility> {
+        if self.private {
+            debug_assert!(!self.public, "BUG: `private` and `public` should conflict");
+            Some(Visibility::private([]))
+        } else if self.public {
+            Some(Visibility::Public)
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn seed(&self) -> bool {
+        !self.no_seed
+    }
+}
+
+// TODO(finto): this is duplicated from `clone::args`. Consolidate these once
+// the `clap` migration has finished and we can organise the shared code.
+#[derive(Clone, Debug)]
+struct ScopeParser;
+
+impl clap::builder::TypedValueParser for ScopeParser {
+    type Value = Scope;
+
+    fn parse_ref(
+        &self,
+        cmd: &clap::Command,
+        arg: Option<&clap::Arg>,
+        value: &std::ffi::OsStr,
+    ) -> Result<Self::Value, clap::Error> {
+        <Scope as std::str::FromStr>::from_str.parse_ref(cmd, arg, value)
+    }
+
+    fn possible_values(
+        &self,
+    ) -> Option<Box<dyn Iterator<Item = clap::builder::PossibleValue> + '_>> {
+        use clap::builder::PossibleValue;
+        Some(Box::new(
+            [PossibleValue::new("all"), PossibleValue::new("followed")].into_iter(),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Args;
+    use clap::error::ErrorKind;
+    use clap::Parser;
+
+    #[test]
+    fn should_parse_rid_non_urn() {
+        let args = Args::try_parse_from(["init", "--existing", "z3Tr6bC7ctEg2EHmLvknUr29mEDLH"]);
+        assert!(args.is_ok())
+    }
+
+    #[test]
+    fn should_parse_rid_urn() {
+        let args =
+            Args::try_parse_from(["init", "--existing", "rad:z3Tr6bC7ctEg2EHmLvknUr29mEDLH"]);
+        assert!(args.is_ok())
+    }
+
+    #[test]
+    fn should_not_parse_rid_url() {
+        let err =
+            Args::try_parse_from(["init", "--existing", "rad://z3Tr6bC7ctEg2EHmLvknUr29mEDLH"])
+                .unwrap_err();
+        assert_eq!(err.kind(), ErrorKind::ValueValidation);
+    }
+}
diff --git a/crates/radicle-cli/src/main.rs b/crates/radicle-cli/src/main.rs
index 8c448d44..8ff87d50 100644
--- a/crates/radicle-cli/src/main.rs
+++ b/crates/radicle-cli/src/main.rs
@@ -50,6 +50,7 @@ enum Commands {
     Clone(clone::Args),
     Debug(debug::Args),
     Fork(fork::Args),
+    Init(init::Args),
     Issue(issue::Args),
     Path(path::Args),
     Publish(publish::Args),
@@ -231,7 +232,9 @@ pub(crate) fn run_other(exe: &str, args: &[OsString]) -> Result<(), Option<anyho
             term::run_command_args::<inbox::Options, _>(inbox::HELP, inbox::run, args.to_vec())
         }
         "init" => {
-            term::run_command_args::<init::Options, _>(init::HELP, init::run, args.to_vec());
+            if let Some(Commands::Init(args)) = CliArgs::parse().command {
+                term::run_command_fn(init::run, args);
+            }
         }
         "inspect" => {
             term::run_command_args::<inspect::Options, _>(