feat(cli): add package manager utility commands

Author: fengmk2

crates/vite_install/src/commands/cache.rs

@@ -0,0 +1,120 @@
+use std::{collections::HashMap, process::ExitStatus};
+
+use vite_error::Error;
+use vite_path::AbsolutePath;
+
+use crate::package_manager::{
+    PackageManager, PackageManagerType, ResolveCommandResult, format_path_env, run_command,
+};
+
+/// Options for the cache command.
+#[derive(Debug, Default)]
+pub struct CacheCommandOptions<'a> {
+    pub subcommand: Option<&'a str>,
+    pub force: bool,
+    pub pass_through_args: Option<&'a [String]>,
+}
+
+impl PackageManager {
+    /// Run the cache command with the package manager.
+    #[must_use]
+    pub async fn run_cache_command(
+        &self,
+        options: &CacheCommandOptions<'_>,
+        cwd: impl AsRef<AbsolutePath>,
+    ) -> Result<ExitStatus, Error> {
+        let resolve_command = self.resolve_cache_command(options);
+        run_command(&resolve_command.bin_path, &resolve_command.args, &resolve_command.envs, cwd)
+            .await
+    }
+
+    /// Resolve the cache command.
+    #[must_use]
+    pub fn resolve_cache_command(&self, options: &CacheCommandOptions) -> ResolveCommandResult {
+        let bin_name: String;
+        let envs = HashMap::from([("PATH".to_string(), format_path_env(self.get_bin_prefix()))]);
+        let mut args: Vec<String> = Vec::new();
+
+        match self.client {
+            PackageManagerType::Pnpm => {
+                bin_name = "pnpm".into();
+
+                if let Some(subcommand) = options.subcommand {
+                    match subcommand {
+                        "dir" | "path" => {
+                            args.push("store".into());
+                            args.push("path".into());
+                        }
+                        "clean" | "clear" => {
+                            args.push("store".into());
+                            args.push("prune".into());
+                        }
+                        "list" => {
+                            args.push("store".into());
+                            args.push("list".into());
+                        }
+                        "verify" => {
+                            println!("Warning: pnpm does not support 'cache verify'");
+                            return ResolveCommandResult {
+                                bin_path: "echo".into(),
+                                args: vec!["pnpm does not support cache verify".into()],
+                                envs,
+                            };
+                        }
+                        _ => {
+                            args.push("store".into());
+                            args.push(subcommand.to_string());
+                        }
+                    }
+                } else {
+                    // Default: show cache directory
+                    args.push("store".into());
+                    args.push("path".into());
+                }
+            }
+            PackageManagerType::Npm => {
+                bin_name = "npm".into();
+                args.push("cache".into());
+
+                if let Some(subcommand) = options.subcommand {
+                    match subcommand {
+                        "path" => args.push("dir".into()),    // npm uses 'dir' not 'path'
+                        "clear" => args.push("clean".into()), // npm uses 'clean' not 'clear'
+                        _ => args.push(subcommand.to_string()),
+                    }
+                }
+
+                if options.force {
+                    args.push("--force".into());
+                }
+            }
+            PackageManagerType::Yarn => {
+                bin_name = "yarn".into();
+                args.push("cache".into());
+
+                if let Some(subcommand) = options.subcommand {
+                    match subcommand {
+                        "path" => args.push("dir".into()),    // yarn uses 'dir' not 'path'
+                        "clear" => args.push("clean".into()), // yarn uses 'clean' not 'clear'
+                        "verify" => {
+                            println!("Warning: yarn does not support 'cache verify'");
+                            return ResolveCommandResult {
+                                bin_path: "echo".into(),
+                                args: vec!["yarn does not support cache verify".into()],
+                                envs,
+                            };
+                        }
+                        _ => args.push(subcommand.to_string()),
+                    }
+                }
+            }
+        }
+
+        // Add pass-through args
+        if let Some(pass_through_args) = options.pass_through_args {
+            args.extend_from_slice(pass_through_args);
+        }
+
+        ResolveCommandResult { bin_path: bin_name, args, envs }
+    }
+}

crates/vite_install/src/commands/config.rs

@@ -0,0 +1,78 @@
+use std::{collections::HashMap, process::ExitStatus};
+
+use vite_error::Error;
+use vite_path::AbsolutePath;
+
+use crate::package_manager::{
+    PackageManager, PackageManagerType, ResolveCommandResult, format_path_env, run_command,
+};
+
+/// Options for the config command.
+#[derive(Debug, Default)]
+pub struct ConfigCommandOptions<'a> {
+    pub subcommand: Option<&'a str>,
+    pub key: Option<&'a str>,
+    pub value: Option<&'a str>,
+    pub json: bool,
+    pub global: bool,
+    pub pass_through_args: Option<&'a [String]>,
+}
+
+impl PackageManager {
+    /// Run the config command with the package manager.
+    #[must_use]
+    pub async fn run_config_command(
+        &self,
+        options: &ConfigCommandOptions<'_>,
+        cwd: impl AsRef<AbsolutePath>,
+    ) -> Result<ExitStatus, Error> {
+        let resolve_command = self.resolve_config_command(options);
+        run_command(&resolve_command.bin_path, &resolve_command.args, &resolve_command.envs, cwd)
+            .await
+    }
+
+    /// Resolve the config command.
+    #[must_use]
+    pub fn resolve_config_command(&self, options: &ConfigCommandOptions) -> ResolveCommandResult {
+        let bin_name: String = self.client.to_string();
+        let envs = HashMap::from([("PATH".to_string(), format_path_env(self.get_bin_prefix()))]);
+        let mut args: Vec<String> = Vec::new();
+
+        args.push("config".into());
+
+        if let Some(subcommand) = options.subcommand {
+            // yarn@2+ uses 'unset' instead of 'delete'
+            if subcommand == "delete"
+                && self.client == PackageManagerType::Yarn
+                && !self.version.starts_with("1.")
+            {
+                args.push("unset".into());
+            } else {
+                args.push(subcommand.to_string());
+            }
+        }
+
+        if let Some(key) = options.key {
+            args.push(key.to_string());
+        }
+
+        if let Some(value) = options.value {
+            args.push(value.to_string());
+        }
+
+        if options.json && self.client == PackageManagerType::Npm {
+            args.push("--json".into());
+        }
+
+        if options.global {
+            args.push("--global".into());
+        }
+
+        // Add pass-through args
+        if let Some(pass_through_args) = options.pass_through_args {
+            args.extend_from_slice(pass_through_args);
+        }
+
+        ResolveCommandResult { bin_path: bin_name, args, envs }
+    }
+}