chore: Improve Rust-based help command printing. (#678)

Author: cpojer

Cargo.lock

@@ -6,6 +6,7 @@
 use std::process::ExitStatus;
 
 use clap::{CommandFactory, FromArgMatches, Parser, Subcommand};
+use owo_colors::OwoColorize;
 use vite_install::commands::{
     add::SaveDependencyType, install::InstallCommandOptions, outdated::Format,
 };
@@ -1843,9 +1844,19 @@ pub async fn run_command(cwd: AbsolutePathBuf, args: Args) -> Result<ExitStatus,
             commands::delegate::execute(cwd, "pack", &args).await
         }
 
-        Commands::Run { args } => commands::run_or_delegate::execute(cwd, &args).await,
+        Commands::Run { args } => {
+            if help::maybe_print_unified_delegate_help("run", &args) {
+                return Ok(ExitStatus::default());
+            }
+            commands::run_or_delegate::execute(cwd, &args).await
+        }
 
-        Commands::Exec { args } => commands::delegate::execute(cwd, "exec", &args).await,
+        Commands::Exec { args } => {
+            if help::maybe_print_unified_delegate_help("exec", &args) {
+                return Ok(ExitStatus::default());
+            }
+            commands::delegate::execute(cwd, "exec", &args).await
+        }
 
         Commands::Preview { args } => {
             if help::maybe_print_unified_delegate_help("preview", &args) {
@@ -1854,7 +1865,12 @@ pub async fn run_command(cwd: AbsolutePathBuf, args: Args) -> Result<ExitStatus,
             commands::delegate::execute(cwd, "preview", &args).await
         }
 
-        Commands::Cache { args } => commands::delegate::execute(cwd, "cache", &args).await,
+        Commands::Cache { args } => {
+            if help::maybe_print_unified_delegate_help("cache", &args) {
+                return Ok(ExitStatus::default());
+            }
+            commands::delegate::execute(cwd, "cache", &args).await
+        }
 
         Commands::Env(args) => commands::env::execute(cwd, args).await,
 
@@ -1895,15 +1911,14 @@ pub fn command_with_help() -> clap::Command {
 
 /// Apply custom help formatting to a clap Command to match the JS CLI output.
 fn apply_custom_help(cmd: clap::Command) -> clap::Command {
-    let version = env!("CARGO_PKG_VERSION");
     let after_help = help::render_help_doc(&help::top_level_help_doc());
-    let help_template = format!(
-        "Vite+/{version}\
-{{after-help}}
-Options:
-{{options}}
-"
-    );
+    let options_heading = help::render_heading("Options");
+    let header = if help::should_style_help() {
+        "VITE+ - The Unified Toolchain for the Web".bold().to_string()
+    } else {
+        "VITE+ - The Unified Toolchain for the Web".to_string()
+    };
+    let help_template = format!("{header}{{after-help}}\n{options_heading}\n{{options}}\n");
 
     cmd.after_help(after_help).help_template(help_template)
 }

crates/vite_global_cli/src/cli.rs

@@ -120,18 +120,18 @@ pub async fn execute(cwd: AbsolutePathBuf, args: EnvArgs) -> Result<ExitStatus,
         return print_env(cwd).await;
     }
 
-    // No flags provided - show help (use clap's built-in help printer)
-    use clap::CommandFactory;
-    let bin_name = crate::cli::Args::command().get_bin_name().unwrap_or("vp").to_string();
-    let display_name: &'static str = Box::leak(format!("{bin_name} env").into_boxed_str());
-    crate::cli::Args::command()
-        .find_subcommand("env")
-        .unwrap()
-        .clone()
-        .name(display_name)
-        .disable_help_subcommand(true)
-        .print_help()
-        .ok();
+    // No flags provided - show unified help to match `vp env --help`.
+    if !crate::help::print_unified_clap_help_for_path(&["env"]) {
+        // Fallback to clap's built-in help printer if unified rendering fails.
+        use clap::CommandFactory;
+        crate::cli::Args::command()
+            .find_subcommand("env")
+            .unwrap()
+            .clone()
+            .disable_help_subcommand(true)
+            .print_help()
+            .ok();
+    }
     Ok(ExitStatus::default())
 }
 

crates/vite_global_cli/src/commands/env/mod.rs

@@ -1,33 +1,169 @@
-//! Version command (Category B: JavaScript Command).
+//! Version command.
 
-use std::process::ExitStatus;
+use std::{
+    collections::BTreeMap,
+    fs,
+    path::{Path, PathBuf},
+    process::ExitStatus,
+};
 
+use owo_colors::OwoColorize;
+use serde::Deserialize;
 use vite_path::AbsolutePathBuf;
 
-use crate::{error::Error, js_executor::JsExecutor};
+use crate::{error::Error, help};
 
-/// Execute the `--version` command by delegating to local or global vite-plus.
-///
-/// Uses the CLI's own runtime instead of the project's runtime to avoid
-/// side effects (e.g., writing `.node-version` in the caller's directory).
-pub async fn execute(cwd: AbsolutePathBuf) -> Result<ExitStatus, Error> {
-    // Pass the Rust binary's version to JS so it can display the correct global version,
-    // even when delegation resolves to a local node_modules copy.
-    unsafe {
-        std::env::set_var(
-            vite_shared::env_vars::VITE_PLUS_GLOBAL_VERSION,
-            env!("CARGO_PKG_VERSION"),
-        );
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct PackageJson {
+    version: String,
+    #[serde(default)]
+    bundled_versions: BTreeMap<String, String>,
+}
+
+#[derive(Debug)]
+struct LocalVitePlus {
+    version: String,
+    package_dir: PathBuf,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct ToolSpec {
+    display_name: &'static str,
+    package_name: &'static str,
+    bundled_version_key: Option<&'static str>,
+}
+
+const TOOL_SPECS: [ToolSpec; 7] = [
+    ToolSpec {
+        display_name: "vite",
+        package_name: "@voidzero-dev/vite-plus-core",
+        bundled_version_key: Some("vite"),
+    },
+    ToolSpec {
+        display_name: "rolldown",
+        package_name: "@voidzero-dev/vite-plus-core",
+        bundled_version_key: Some("rolldown"),
+    },
+    ToolSpec {
+        display_name: "vitest",
+        package_name: "@voidzero-dev/vite-plus-test",
+        bundled_version_key: Some("vitest"),
+    },
+    ToolSpec { display_name: "oxfmt", package_name: "oxfmt", bundled_version_key: None },
+    ToolSpec { display_name: "oxlint", package_name: "oxlint", bundled_version_key: None },
+    ToolSpec {
+        display_name: "oxlint-tsgolint",
+        package_name: "oxlint-tsgolint",
+        bundled_version_key: None,
+    },
+    ToolSpec {
+        display_name: "tsdown",
+        package_name: "@voidzero-dev/vite-plus-core",
+        bundled_version_key: Some("tsdown"),
+    },
+];
+
+fn read_package_json(package_json_path: &Path) -> Option<PackageJson> {
+    let content = fs::read_to_string(package_json_path).ok()?;
+    serde_json::from_str(&content).ok()
+}
+
+fn find_local_vite_plus(start: &Path) -> Option<LocalVitePlus> {
+    let mut current = Some(start);
+    while let Some(dir) = current {
+        let package_json_path = dir.join("node_modules").join("vite-plus").join("package.json");
+        if let Some(pkg) = read_package_json(&package_json_path) {
+            let package_dir = package_json_path.parent()?.to_path_buf();
+            return Some(LocalVitePlus { version: pkg.version, package_dir });
+        }
+        current = dir.parent();
+    }
+    None
+}
+
+fn resolve_package_json(base_dir: &Path, package_name: &str) -> Option<PackageJson> {
+    let mut current = Some(base_dir);
+    while let Some(dir) = current {
+        let package_json_path = dir.join("node_modules").join(package_name).join("package.json");
+        if let Some(pkg) = read_package_json(&package_json_path) {
+            return Some(pkg);
+        }
+        current = dir.parent();
+    }
+    None
+}
+
+fn resolve_tool_version(local: &LocalVitePlus, tool: ToolSpec) -> Option<String> {
+    let pkg = resolve_package_json(&local.package_dir, tool.package_name)?;
+    if let Some(key) = tool.bundled_version_key
+        && let Some(version) = pkg.bundled_versions.get(key)
+    {
+        return Some(version.clone());
     }
-    let mut executor = JsExecutor::new(None);
-    executor.delegate_with_cli_runtime(&cwd, &["--version".to_string()]).await
+    Some(pkg.version)
+}
+
+fn accent(text: &str) -> String {
+    if help::should_style_help() { text.bright_blue().to_string() } else { text.to_string() }
+}
+
+fn print_rows(title: &str, rows: &[(&str, String)]) {
+    println!("{}", help::render_heading(title));
+    let label_width = rows.iter().map(|(label, _)| label.chars().count()).max().unwrap_or(0);
+    for (label, value) in rows {
+        let padding = " ".repeat(label_width.saturating_sub(label.chars().count()));
+        println!("  {}{}  {value}", accent(label), padding);
+    }
+}
+
+fn format_version(version: Option<String>) -> String {
+    match version {
+        Some(v) => format!("v{v}"),
+        None => "Not found".to_string(),
+    }
+}
+
+/// Execute the `--version` command.
+pub async fn execute(cwd: AbsolutePathBuf) -> Result<ExitStatus, Error> {
+    let header = if help::should_style_help() {
+        "VITE+ - The Unified Toolchain for the Web".bold().to_string()
+    } else {
+        "VITE+ - The Unified Toolchain for the Web".to_string()
+    };
+    println!("{header}");
+    println!();
+
+    println!("vp v{}", env!("CARGO_PKG_VERSION"));
+    println!();
+
+    let local = find_local_vite_plus(cwd.as_path());
+    print_rows(
+        "Local vite-plus",
+        &[("vite-plus", format_version(local.as_ref().map(|pkg| pkg.version.clone())))],
+    );
+    println!();
+
+    let tool_rows = TOOL_SPECS
+        .iter()
+        .map(|tool| {
+            let version =
+                local.as_ref().and_then(|local_pkg| resolve_tool_version(local_pkg, *tool));
+            (tool.display_name, format_version(version))
+        })
+        .collect::<Vec<_>>();
+    print_rows("Tools", &tool_rows);
+
+    Ok(ExitStatus::default())
 }
 
 #[cfg(test)]
 mod tests {
+    use super::format_version;
+
     #[test]
-    fn test_version_command_module_exists() {
-        // Basic test to ensure the module compiles
-        assert!(true);
+    fn format_version_values() {
+        assert_eq!(format_version(Some("1.2.3".to_string())), "v1.2.3");
+        assert_eq!(format_version(None), "Not found");
     }
 }