feat!: consolidate cot cli commands into one

cot-cli/Cargo.toml

@@ -42,6 +42,8 @@ quote.workspace = true
 syn.workspace = true
 tracing.workspace = true
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
+serde = { workspace = true, features = ["derive"] }
+serde_json = {workspace = true}
 
 [dev-dependencies]
 cot-cli = { path = ".", features = ["test_utils"] }

cot-cli/src/args.rs

@@ -1,8 +1,15 @@
+use std::ffi::OsString;
 use std::path::PathBuf;
 
 use clap::{Args, Parser, Subcommand};
 use clap_verbosity_flag::Verbosity;
 
+pub const PACKAGE_LONG_FLAG: &str = "--package";
+pub const PACKAGE_SHORT_FLAG: &str = "-p";
+pub const RELEASE_FLAG: &str = "--release";
+pub const HELP_LONG_FLAG: &str = "--help";
+pub const HELP_SHORT_FLAG: &str = "-h";
+
 #[derive(Debug, Parser)]
 #[command(
     name = "cot",
@@ -11,6 +18,13 @@ use clap_verbosity_flag::Verbosity;
     long_about = None
 )]
 pub struct Cli {
+    /// Use target/release instead of target/debug when looking for the project
+    /// binary
+    #[arg(long, global = true)]
+    release: bool,
+    /// Package to use, in case you're running this in a workspace
+    #[arg(short = 'p', long, global = true, value_name = "PACKAGE")]
+    pub package: Option<String>,
     #[command(flatten)]
     pub verbose: Verbosity,
     #[command(subcommand)]
@@ -29,6 +43,9 @@ pub enum Commands {
     /// Manage Cot CLI
     #[command(subcommand)]
     Cli(CliCommands),
+
+    #[command(external_subcommand)]
+    External(Vec<OsString>),
 }
 
 #[derive(Debug, Args)]
@@ -119,3 +136,71 @@ pub struct CompletionsArgs {
     /// Shell to generate completions for
     pub shell: clap_complete::Shell,
 }
+
+/// Pulls `-p <name>` / `--package <name>` / `--package=<name>` out of raw
+/// argv, before clap has parsed anything. Needed because `project::load`
+/// must run before `Cli::parse()` for the `--help` interception path.
+#[must_use]
+pub fn extract_package_arg(raw: &[String]) -> Option<String> {
+    let mut iter = raw.iter();
+    while let Some(arg) = iter.next() {
+        if let Some(value) = arg.strip_prefix(&format!("{PACKAGE_LONG_FLAG}=")) {
+            return Some(value.to_string());
+        }
+        if arg == PACKAGE_LONG_FLAG || arg == PACKAGE_SHORT_FLAG {
+            return iter.next().cloned();
+        }
+    }
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn args(raw: &[&str]) -> Vec<String> {
+        raw.iter().map(|arg| (*arg).to_string()).collect()
+    }
+
+    #[test]
+    fn extract_package_arg_long_with_separate_value() {
+        let raw = args(&["cot", "--release", "--package", "blog", "check"]);
+
+        assert_eq!(extract_package_arg(&raw), Some("blog".to_string()));
+    }
+
+    #[test]
+    fn extract_package_arg_long_with_equals_value() {
+        let raw = args(&["cot", "--package=blog", "check"]);
+
+        assert_eq!(extract_package_arg(&raw), Some("blog".to_string()));
+    }
+
+    #[test]
+    fn extract_package_arg_short_with_value() {
+        let raw = args(&["cot", "-p", "blog", "check"]);
+
+        assert_eq!(extract_package_arg(&raw), Some("blog".to_string()));
+    }
+
+    #[test]
+    fn extract_package_arg_returns_first_package_flag() {
+        let raw = args(&["cot", "-p", "first", "--package", "second", "check"]);
+
+        assert_eq!(extract_package_arg(&raw), Some("first".to_string()));
+    }
+
+    #[test]
+    fn extract_package_arg_missing_value_returns_none() {
+        let raw = args(&["cot", "check", "-p"]);
+
+        assert_eq!(extract_package_arg(&raw), None);
+    }
+
+    #[test]
+    fn extract_package_arg_absent_returns_none() {
+        let raw = args(&["cot", "--release", "check"]);
+
+        assert_eq!(extract_package_arg(&raw), None);
+    }
+}

cot-cli/src/handlers.rs

@@ -1,7 +1,11 @@
+use std::ffi::OsString;
+#[cfg(unix)]
+use std::os::unix::process::CommandExt;
 use std::path::PathBuf;
 
 use anyhow::Context;
 use clap::CommandFactory;
+use cot::metadata::CommandMeta;
 
 use crate::args::{
     Cli, CompletionsArgs, ManpagesArgs, MigrationListArgs, MigrationMakeArgs, MigrationNewArgs,
@@ -11,6 +15,7 @@ use crate::migration_generator::{
     MigrationGeneratorOptions, create_new_migration, list_migrations, make_migrations,
 };
 use crate::new_project::{CotSource, new_project};
+use crate::project::ProjectBinary;
 
 pub fn handle_new_project(
     ProjectNewArgs { path, name, source }: ProjectNewArgs,
@@ -95,6 +100,90 @@ pub fn handle_cli_completions(CompletionsArgs { shell }: CompletionsArgs) -> any
     Ok(())
 }
 
+pub fn handle_external(
+    args: &[OsString],
+    project: Option<ProjectBinary>,
+    _release: bool,
+) -> anyhow::Result<()> {
+    let subcmd = args[0].to_string_lossy();
+
+    let Some(proj) = project else {
+        anyhow::bail!(
+            "Unknown command `{subcmd}` and no project binary was found in target/.\n\
+             Hint: run `cargo build` first, or `cargo build --release`."
+        );
+    };
+
+    let known = proj
+        .metadata
+        .commands
+        .iter()
+        .any(|c| c.name == subcmd.as_ref() || c.aliases.iter().any(|a| a == subcmd.as_ref()));
+
+    if !known {
+        anyhow::bail!(
+            "Unknown command `{subcmd}`.\n\
+             Run `cot --help` to see all available commands."
+        );
+    }
+
+    exec(&proj, args)
+}
+
+fn exec(proj: &ProjectBinary, args: &[OsString]) -> anyhow::Result<()> {
+    #[cfg(unix)]
+    {
+        let err = std::process::Command::new(&proj.path).args(args).exec();
+        anyhow::bail!("Failed to exec {}: {err}", proj.path.display());
+    }
+
+    #[cfg(not(unix))]
+    {
+        let status = std::process::Command::new(&proj.path).args(args).status()?;
+        std::process::exit(status.code().unwrap_or(1));
+    }
+}
+
+/// Build a fresh [`clap::Command`] and inject the project's subcommands into
+/// it before printing.
+pub fn handle_combined_help(project: Option<&ProjectBinary>) -> anyhow::Result<()> {
+    let mut cmd = combined_help_command(project);
+
+    cmd.print_long_help()?;
+    println!();
+    Ok(())
+}
+
+fn combined_help_command(project: Option<&ProjectBinary>) -> clap::Command {
+    let mut cmd = Cli::command();
+
+    if let Some(proj) = project {
+        for meta_cmd in &proj.metadata.commands {
+            cmd = cmd.subcommand(build_clap_subcommand(meta_cmd));
+        }
+    }
+
+    cmd
+}
+
+fn build_clap_subcommand(meta: &CommandMeta) -> clap::Command {
+    let mut cmd = clap::Command::new(&meta.name);
+
+    if let Some(about) = &meta.about {
+        cmd = cmd.about(about.clone());
+    }
+
+    for alias in &meta.aliases {
+        cmd = cmd.visible_alias(alias.clone());
+    }
+
+    for sub in &meta.subcommands {
+        cmd = cmd.subcommand(build_clap_subcommand(sub));
+    }
+
+    cmd
+}
+
 fn generate_completions(shell: clap_complete::Shell, writer: &mut impl std::io::Write) {
     clap_complete::generate(shell, &mut Cli::command(), "cot", writer);
 }
@@ -180,4 +269,98 @@ mod tests {
 
         assert!(!output.is_empty());
     }
+
+    #[test]
+    fn external_command_without_project_reports_build_hint() {
+        let result = handle_external(&[OsString::from("serve")], None, false);
+
+        assert!(result.is_err());
+        let message = result.unwrap_err().to_string();
+        assert!(message.contains("Unknown command `serve`"));
+        assert!(message.contains("run `cargo build` first"));
+    }
+
+    #[test]
+    fn external_command_unknown_to_project_reports_unknown_command() {
+        let project = ProjectBinary {
+            path: PathBuf::from("target/debug/example"),
+            metadata: cot::metadata::ProjectMetadata {
+                binary_name: "example".to_string(),
+                commands: vec![CommandMeta {
+                    name: "check".to_string(),
+                    about: None,
+                    aliases: vec![],
+                    subcommands: vec![],
+                }],
+            },
+        };
+
+        let result = handle_external(&[OsString::from("foo")], Some(project), false);
+
+        assert!(result.is_err());
+        let message = result.unwrap_err().to_string();
+        assert!(message.contains("Unknown command `foo`"));
+        assert!(message.contains("cot --help"));
+    }
+
+    #[test]
+    fn build_clap_subcommand_preserves_about_aliases_and_nested_subcommands() {
+        let meta = CommandMeta {
+            name: "migration".to_string(),
+            about: Some("Migration commands".to_string()),
+            aliases: vec!["database".to_string()],
+            subcommands: vec![CommandMeta {
+                name: "rollback".to_string(),
+                about: Some("Rollback migrations".to_string()),
+                aliases: vec!["rbk".to_string()],
+                subcommands: vec![],
+            }],
+        };
+
+        let cmd = build_clap_subcommand(&meta);
+
+        assert_eq!(cmd.get_name(), "migration");
+        assert_eq!(cmd.get_about().unwrap().to_string(), "Migration commands");
+        assert!(cmd.get_all_aliases().any(|alias| alias == "database"));
+        let nested = cmd
+            .get_subcommands()
+            .find(|subcommand| subcommand.get_name() == "rollback")
+            .unwrap();
+        assert_eq!(
+            nested.get_about().unwrap().to_string(),
+            "Rollback migrations"
+        );
+        assert!(nested.get_all_aliases().any(|alias| alias == "rbk"));
+    }
+
+    #[test]
+    fn combined_help_command_includes_project_commands_and_builtin_commands() {
+        let project = ProjectBinary {
+            path: PathBuf::from("target/debug/example"),
+            metadata: cot::metadata::ProjectMetadata {
+                binary_name: "example".to_string(),
+                commands: vec![CommandMeta {
+                    name: "health".to_string(),
+                    about: Some("Check the server health".to_string()),
+                    aliases: vec![],
+                    subcommands: vec![],
+                }],
+            },
+        };
+
+        let cmd = combined_help_command(Some(&project));
+
+        assert!(
+            cmd.get_subcommands()
+                .any(|subcommand| subcommand.get_name() == "new")
+        );
+        let health = cmd
+            .get_subcommands()
+            .find(|subcommand| subcommand.get_name() == "health")
+            .unwrap();
+        assert_eq!(
+            health.get_about().unwrap().to_string(),
+            "Check the server health"
+        );
+    }
 }

cot-cli/src/lib.rs

@@ -4,6 +4,7 @@ pub mod args;
 pub mod handlers;
 pub mod migration_generator;
 pub mod new_project;
+pub mod project;
 #[cfg(feature = "test_utils")]
 pub mod test_utils;
 mod utils;