feat(turbo): g

crates/turborepo-lib/src/cli.rs

@@ -14,7 +14,7 @@ use tracing::{debug, error};
 use turbopath::AbsoluteSystemPathBuf;
 
 use crate::{
-    commands::{bin, daemon, link, login, logout, unlink, CommandBase},
+    commands::{bin, daemon, generate, link, login, logout, unlink, CommandBase},
     get_version,
     shim::{RepoMode, RepoState},
     tracing::TurboSubscriber,
@@ -264,6 +264,12 @@ pub enum Command {
         #[clap(long, value_enum, default_value_t = LinkTarget::RemoteCache)]
         target: LinkTarget,
     },
+    // Generate a new app / package
+    G {
+        #[clap(subcommand)]
+        #[serde(flatten)]
+        command: Option<GenerateCommand>,
+    },
     /// Login to your Vercel account
     Login {
         #[clap(long = "sso-team")]
@@ -300,6 +306,73 @@ pub enum Command {
     },
 }
 
+#[derive(Parser, Clone, Debug, Default, Serialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct GenerateArgs {
+    /// The name of the generator to run
+    pub generator_name: Option<String>,
+    /// Generator configuration file
+    #[clap(short = 'c', long)]
+    pub config: Option<String>,
+    /// The root of your repository (default: directory with root turbo.json)
+    #[clap(short = 'r', long)]
+    pub root: Option<String>,
+    /// Arguments passed directly to generator
+    #[clap(short = 'a', long)]
+    pub args: Vec<String>,
+}
+
+#[derive(Parser, Clone, Debug, Default, Serialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct GenerateAddArgs {
+    /// Name for the new workspace
+    #[clap(short = 'n', long)]
+    pub name: Option<String>,
+    /// Generate an empty workspace
+    #[clap(
+        short = 'b',
+        long,
+        conflicts_with = "copy",
+        default_missing_value = "true"
+    )]
+    pub empty: bool,
+    /// Generate a workspace using an existing workspace as a template
+    #[clap(short = 'c', long, conflicts_with = "empty")]
+    pub copy: bool,
+    /// Where the new workspace should be created
+    #[clap(short = 'd', long)]
+    pub destination: Option<String>,
+    /// The type of workspace to create
+    #[clap(short = 'w', long)]
+    pub what: Option<String>,
+    /// The root of your repository (default: directory with root turbo.json)
+    #[clap(short = 'r', long)]
+    pub root: Option<String>,
+    /// An example package to add. You can use a GitHub URL with any branch
+    /// and/or subdirectory.
+    #[clap(short = 'e', long)]
+    pub example: Option<String>,
+    /// In a rare case, your GitHub URL might contain a branch name with a slash
+    /// (e.g. bug/fix-1) and the path to the example (e.g. foo/bar). In this
+    /// case, you must specify the path to the example separately:
+    /// --example-path foo/bar
+    #[clap(short = 'p', long)]
+    pub example_path: Option<String>,
+    /// Do not filter available dependencies by the workspace type
+    #[clap(long)]
+    pub show_all_dependencies: bool,
+}
+
+#[derive(Subcommand, Clone, Debug, Serialize, PartialEq)]
+pub enum GenerateCommand {
+    /// Add a new package or app to your project
+    #[clap(name = "add", aliases = &["a"])]
+    Add(GenerateAddArgs),
+    /// Run custom generators
+    #[clap(name = "gen", aliases = &["g"])]
+    Gen(GenerateArgs),
+}
+
 #[derive(Parser, Clone, Debug, Default, Serialize, PartialEq)]
 pub struct RunArgs {
     /// Override the filesystem cache directory.
@@ -567,6 +640,14 @@ pub async fn run(
 
             Ok(Payload::Rust(Ok(0)))
         }
+        Command::G { command } => {
+            match command {
+                Some(command) => generate::run(command),
+                None => generate::run(&GenerateCommand::Add(GenerateAddArgs::default())),
+            }?;
+
+            Ok(Payload::Rust(Ok(0)))
+        }
         Command::Daemon { command, idle_time } => {
             let base = CommandBase::new(cli_args.clone(), repo_root, version, ui)?;
 

crates/turborepo-lib/src/commands/generate.rs

@@ -0,0 +1,60 @@
+use std::process::{Command, Stdio};
+
+use anyhow::Result;
+
+use crate::{child::spawn_child, cli::GenerateCommand};
+
+fn verify_requirements() -> Result<()> {
+    let output = Command::new("npx")
+        .arg("--version")
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status();
+
+    const ERROR_MSG: &str = "Unable to run generate - missing requirements (npx)";
+    match output {
+        Ok(result) => {
+            if result.success() {
+                return Ok(());
+            }
+            return Err(anyhow::anyhow!(ERROR_MSG));
+        }
+        Err(_) => {
+            return Err(anyhow::anyhow!(ERROR_MSG));
+        }
+    }
+}
+
+fn call_turbo_gen(command: &str, raw_args: &str) -> Result<i32> {
+    let mut npx = Command::new("npx");
+    npx.arg("--yes")
+        .arg("@turbo/gen@alpha")
+        .arg("raw")
+        .arg(command)
+        .args(["--json", raw_args])
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit());
+
+    let child = spawn_child(npx)?;
+    let exit_code = child.wait()?.code().unwrap_or(2);
+    Ok(exit_code)
+}
+
+pub fn run(command: &GenerateCommand) -> Result<()> {
+    // ensure npx is available
+    verify_requirements()?;
+
+    match command {
+        GenerateCommand::Add(args) => {
+            // convert args to json
+            let raw_args = serde_json::to_string(args)?;
+            call_turbo_gen("add", &raw_args)?;
+        }
+        GenerateCommand::Gen(args) => {
+            let raw_args = serde_json::to_string(args)?;
+            call_turbo_gen("generate", &raw_args)?;
+        }
+    };
+
+    Ok(())
+}

crates/turborepo-lib/src/commands/mod.rs

@@ -15,6 +15,7 @@ use crate::{
 
 pub(crate) mod bin;
 pub(crate) mod daemon;
+pub(crate) mod generate;
 pub(crate) mod link;
 pub(crate) mod login;
 pub(crate) mod logout;