Migrate to new CLI structure.

Author: simi

Cargo.lock

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.2.0"
+version = "0.3.0"
 edition = "2024"
 authors = ["RubyElders.com"]
 description = "A sophisticated Ruby environment manager that orchestrates installations and gem collections with distinguished precision"

Cargo.toml

@@ -0,0 +1,34 @@
+pub mod config;
+pub mod env;
+pub mod project;
+pub mod runtime;
+
+use rb_core::butler::{ButlerError, ButlerRuntime};
+use std::path::PathBuf;
+
+use crate::InfoCommands;
+use crate::config::TrackedConfig;
+
+pub fn info_command(
+    command: &InfoCommands,
+    butler_runtime: &ButlerRuntime,
+    project_file: Option<PathBuf>,
+) -> Result<(), ButlerError> {
+    match command {
+        InfoCommands::Runtime => runtime::runtime_command(butler_runtime),
+        InfoCommands::Env => env::environment_command(butler_runtime, project_file),
+        InfoCommands::Project => project::project_command(butler_runtime, project_file),
+        InfoCommands::Config => {
+            // Config command doesn't actually need the runtime, but we have it available
+            // For now, return an error - this will be handled specially in dispatch
+            Err(ButlerError::General(
+                "Config command should be handled in dispatch".to_string(),
+            ))
+        }
+    }
+}
+
+/// Info command for config specifically (doesn't need runtime)
+pub fn info_config_command(config: &TrackedConfig) -> Result<(), ButlerError> {
+    config::config_command(config)
+}

crates/rb-cli/src/commands/config.rs crates/rb-cli/src/commands/info/config.rscrates/rb-cli/src/commands/config.rs renamed to crates/rb-cli/src/commands/info/config.rs

@@ -0,0 +1,103 @@
+use colored::*;
+use log::{debug, info};
+use rb_core::butler::{ButlerError, ButlerRuntime};
+use rb_core::project::{ProjectRuntime, RbprojectDetector};
+use std::path::PathBuf;
+
+pub fn project_command(
+    butler_runtime: &ButlerRuntime,
+    project_file: Option<PathBuf>,
+) -> Result<(), ButlerError> {
+    info!("Inspecting project configuration");
+    present_project_info(butler_runtime, project_file)?;
+    Ok(())
+}
+
+fn present_project_info(
+    butler_runtime: &ButlerRuntime,
+    project_file: Option<PathBuf>,
+) -> Result<(), ButlerError> {
+    println!("{}", "📁 Project Configuration".to_string().bold());
+    println!();
+
+    // Load project file - either specified or discovered
+    let project_runtime = if let Some(path) = project_file {
+        debug!(
+            "Loading project config from specified path: {}",
+            path.display()
+        );
+        ProjectRuntime::from_file(&path).ok()
+    } else {
+        let current_dir = std::env::current_dir()
+            .map_err(|e| ButlerError::General(format!("Failed to get current directory: {}", e)))?;
+        RbprojectDetector::discover(current_dir.as_path())
+            .ok()
+            .flatten()
+    };
+
+    match project_runtime {
+        Some(project_runtime) => {
+            println!(
+                "  {} {}",
+                "Project File:".bold(),
+                project_runtime.rbproject_path().display()
+            );
+            println!();
+
+            if let Some(name) = &project_runtime.metadata.name {
+                println!("  {} {}", "Name:".bold(), name.cyan());
+            }
+
+            if let Some(description) = &project_runtime.metadata.description {
+                println!("  {} {}", "Description:".bold(), description.dimmed());
+            }
+
+            if !project_runtime.scripts.is_empty() {
+                println!();
+                println!("  {}", "Scripts:".bold());
+                for (name, script) in &project_runtime.scripts {
+                    if let Some(desc) = script.description() {
+                        println!(
+                            "    {} → {} {}",
+                            name.cyan(),
+                            script.command().dimmed(),
+                            format!("({})", desc).bright_black()
+                        );
+                    } else {
+                        println!("    {} → {}", name.cyan(), script.command().dimmed());
+                    }
+                }
+            }
+        }
+        None => {
+            println!(
+                "  {}",
+                "No rbproject.toml found in current directory or parents".dimmed()
+            );
+            println!();
+            println!("  {} Run {} to create one.", "Tip:".bold(), "rb new".cyan());
+        }
+    }
+
+    println!();
+
+    // Show effective configuration
+    println!("{}", "🔧 Effective Configuration".to_string().bold());
+    println!();
+    println!(
+        "  {} {}",
+        "Rubies Directory:".bold(),
+        butler_runtime.rubies_dir().display()
+    );
+
+    if let Some(gem_base) = butler_runtime.gem_base_dir() {
+        println!("  {} {}", "Gem Home:".bold(), gem_base.display());
+    }
+
+    if let Some(requested) = butler_runtime.requested_ruby_version() {
+        println!("  {} {}", "Requested Ruby:".bold(), requested);
+    }
+
+    println!();
+    Ok(())
+}

crates/rb-cli/src/commands/environment.rs crates/rb-cli/src/commands/info/env.rscrates/rb-cli/src/commands/environment.rs renamed to crates/rb-cli/src/commands/info/env.rs

@@ -1,21 +1,17 @@
-pub mod config;
-pub mod environment;
 pub mod exec;
 pub mod help;
-pub mod init;
+pub mod info;
+pub mod new;
 pub mod run;
-pub mod runtime;
 pub mod shell_integration;
 pub mod sync;
 pub mod version;
 
-pub use config::config_command;
-pub use environment::environment_command;
 pub use exec::exec_command;
 pub use help::help_command;
-pub use init::init_command;
+pub use info::info_command;
+pub use new::init_command as new_command;
 pub use run::run_command;
-pub use runtime::runtime_command;
 pub use shell_integration::shell_integration_command;
 pub use sync::sync_command;
 pub use version::version_command;

crates/rb-cli/src/commands/info/mod.rs

@@ -1,13 +1,14 @@
 use crate::Commands;
+use crate::InfoCommands;
+use crate::commands::info::info_config_command;
 use crate::commands::{
-    config_command, environment_command, exec_command, help_command, run_command, runtime_command,
-    sync_command, version_command,
+    exec_command, help_command, info_command, run_command, sync_command, version_command,
 };
 use crate::runtime_helpers::CommandContext;
 use rb_core::butler::ButlerError;
 
 use crate::runtime_helpers::{
-    bash_complete_command, init_command_wrapper, shell_integration_command_wrapper,
+    bash_complete_command, new_command_wrapper, shell_integration_command_wrapper,
     with_butler_runtime,
 };
 
@@ -20,28 +21,35 @@ pub fn dispatch_command(
         // Utility commands - no runtime needed
         Commands::Version => version_command(),
         Commands::Help { command: help_cmd } => help_command(help_cmd),
-        Commands::Init => init_command_wrapper(),
-        Commands::Config => config_command(&context.config),
+        Commands::New => new_command_wrapper(),
         Commands::ShellIntegration { shell } => shell_integration_command_wrapper(shell),
         Commands::BashComplete { line, point } => bash_complete_command(context, &line, &point),
 
-        // Runtime commands - create ButlerRuntime lazily
-        Commands::Runtime => with_butler_runtime(context, runtime_command),
-        Commands::Environment => {
+        // Workflow commands - create ButlerRuntime
+        Commands::Run { script, args } => {
             let project_file = context.project_file.clone();
             with_butler_runtime(context, |runtime| {
-                environment_command(runtime, project_file)
+                run_command(runtime.clone(), script, args, project_file)
             })
         }
         Commands::Exec { args } => {
             with_butler_runtime(context, |runtime| exec_command(runtime.clone(), args))
         }
-        Commands::Run { script, args } => {
-            let project_file = context.project_file.clone();
-            with_butler_runtime(context, |runtime| {
-                run_command(runtime.clone(), script, args, project_file)
-            })
-        }
         Commands::Sync => with_butler_runtime(context, |runtime| sync_command(runtime.clone())),
+
+        // Diagnostic commands
+        Commands::Info { command } => match command {
+            InfoCommands::Config => {
+                // Config doesn't need runtime, just the config
+                info_config_command(&context.config)
+            }
+            _ => {
+                // Other info commands need runtime
+                let project_file = context.project_file.clone();
+                with_butler_runtime(context, |runtime| {
+                    info_command(&command, runtime, project_file)
+                })
+            }
+        },
     }
 }