feat(pm): add dedupe command for dependency optimization (#256)

### TL;DR

Added a new `vite dedupe` command (with `ddp` alias) that automatically adapts to the detected package manager to optimize dependency trees by removing duplicate packages.

### What changed?

- Added a new `dedupe` command to the CLI that works with pnpm, npm, and yarn@2+
- Implemented package manager-specific adaptations for the dedupe command:
  - Maps to `pnpm dedupe`, `npm dedupe`, or `yarn dedupe` based on detected package manager
  - Supports `--check` flag that maps to the appropriate dry-run flag for each package manager
  - Handles pass-through arguments for advanced use cases
- Created new modules:
  - `crates/vite_package_manager/src/commands/dedupe.rs`
  - `packages/cli/binding/src/commands/dedupe.rs`
- Added comprehensive test coverage for the new command
- Included RFC documentation explaining the design decisions and implementation details

### How to test?

1. Basic deduplication:
```bash
vite dedupe
vite ddp  # alias
```

2. Check mode (preview changes without modifying):
```bash
vite dedupe --check
```

3. With pass-through arguments:
```bash
vite dedupe -- --some-flag --another-flag
```

### Why make this change?

This change simplifies dependency optimization by providing a unified interface across all supported package managers. Previously, developers had to manually use package manager-specific commands with different syntaxes:

- `pnpm dedupe --check`
- `npm dedupe --dry-run`
- `yarn dedupe --check` (yarn@2+ only)

The new command automatically detects the package manager and uses the appropriate syntax, reducing friction in dependency management workflows and improving project efficiency by making it easier to remove redundant packages.

Author: fengmk2

crates/vite_install/src/commands/dedupe.rs

@@ -0,0 +1,154 @@
+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 dedupe command.
+#[derive(Debug, Default)]
+pub struct DedupeCommandOptions<'a> {
+    pub check: bool,
+    pub pass_through_args: Option<&'a [String]>,
+}
+
+impl PackageManager {
+    /// Run the dedupe command with the package manager.
+    /// Return the exit status of the command.
+    #[must_use]
+    pub async fn run_dedupe_command(
+        &self,
+        options: &DedupeCommandOptions<'_>,
+        cwd: impl AsRef<AbsolutePath>,
+    ) -> Result<ExitStatus, Error> {
+        let resolve_command = self.resolve_dedupe_command(options);
+        run_command(&resolve_command.bin_path, &resolve_command.args, &resolve_command.envs, cwd)
+            .await
+    }
+
+    /// Resolve the dedupe command.
+    #[must_use]
+    pub fn resolve_dedupe_command(&self, options: &DedupeCommandOptions) -> 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();
+                args.push("dedupe".into());
+
+                // pnpm uses --check for dry-run
+                if options.check {
+                    args.push("--check".into());
+                }
+            }
+            PackageManagerType::Yarn => {
+                bin_name = "yarn".into();
+                args.push("dedupe".into());
+
+                // yarn@2+ supports --check
+                if options.check {
+                    args.push("--check".into());
+                }
+            }
+            PackageManagerType::Npm => {
+                bin_name = "npm".into();
+                args.push("dedupe".into());
+
+                if options.check {
+                    args.push("--dry-run".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 }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::{TempDir, tempdir};
+    use vite_path::AbsolutePathBuf;
+    use vite_str::Str;
+
+    use super::*;
+
+    fn create_temp_dir() -> TempDir {
+        tempdir().expect("Failed to create temp directory")
+    }
+
+    fn create_mock_package_manager(pm_type: PackageManagerType, version: &str) -> PackageManager {
+        let temp_dir = create_temp_dir();
+        let temp_dir_path = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
+        let install_dir = temp_dir_path.join("install");
+
+        PackageManager {
+            client: pm_type,
+            package_name: pm_type.to_string().into(),
+            version: Str::from(version),
+            hash: None,
+            bin_name: pm_type.to_string().into(),
+            workspace_root: temp_dir_path.clone(),
+            install_dir,
+        }
+    }
+
+    #[test]
+    fn test_pnpm_dedupe_basic() {
+        let pm = create_mock_package_manager(PackageManagerType::Pnpm, "10.0.0");
+        let result = pm.resolve_dedupe_command(&DedupeCommandOptions { ..Default::default() });
+        assert_eq!(result.bin_path, "pnpm");
+        assert_eq!(result.args, vec!["dedupe"]);
+    }
+
+    #[test]
+    fn test_pnpm_dedupe_check() {
+        let pm = create_mock_package_manager(PackageManagerType::Pnpm, "10.0.0");
+        let result =
+            pm.resolve_dedupe_command(&DedupeCommandOptions { check: true, ..Default::default() });
+        assert_eq!(result.bin_path, "pnpm");
+        assert_eq!(result.args, vec!["dedupe", "--check"]);
+    }
+
+    #[test]
+    fn test_npm_dedupe_basic() {
+        let pm = create_mock_package_manager(PackageManagerType::Npm, "11.0.0");
+        let result = pm.resolve_dedupe_command(&DedupeCommandOptions { ..Default::default() });
+        assert_eq!(result.args, vec!["dedupe"]);
+        assert_eq!(result.bin_path, "npm");
+    }
+
+    #[test]
+    fn test_npm_dedupe_check() {
+        let pm = create_mock_package_manager(PackageManagerType::Npm, "11.0.0");
+        let result =
+            pm.resolve_dedupe_command(&DedupeCommandOptions { check: true, ..Default::default() });
+        assert_eq!(result.args, vec!["dedupe", "--dry-run"]);
+        assert_eq!(result.bin_path, "npm");
+    }
+
+    #[test]
+    fn test_yarn_dedupe_basic() {
+        let pm = create_mock_package_manager(PackageManagerType::Yarn, "4.0.0");
+        let result = pm.resolve_dedupe_command(&DedupeCommandOptions { ..Default::default() });
+        assert_eq!(result.args, vec!["dedupe"]);
+        assert_eq!(result.bin_path, "yarn");
+    }
+
+    #[test]
+    fn test_yarn_dedupe_check() {
+        let pm = create_mock_package_manager(PackageManagerType::Yarn, "4.0.0");
+        let result =
+            pm.resolve_dedupe_command(&DedupeCommandOptions { check: true, ..Default::default() });
+        assert_eq!(result.args, vec!["dedupe", "--check"]);
+        assert_eq!(result.bin_path, "yarn");
+    }
+}

crates/vite_install/src/commands/mod.rs

@@ -1,4 +1,5 @@
 pub mod add;
+pub mod dedupe;
 mod install;
 pub mod remove;
 pub mod update;

packages/cli/binding/src/cli.rs

@@ -19,6 +19,7 @@ use vite_task::{
 
 use crate::commands::{
     add::AddCommand,
+    dedupe::DedupeCommand,
     doc::doc as doc_cmd,
     fmt::{FmtConfig, fmt},
     install::InstallCommand,
@@ -272,6 +273,17 @@ pub enum Commands {
         /// Packages to update (optional - updates all if omitted)
         packages: Vec<String>,
 
+        /// Additional arguments to pass through to the package manager
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+    /// Deduplicate dependencies by removing older versions
+    #[command(alias = "ddp")]
+    Dedupe {
+        /// Check if deduplication would make changes
+        #[arg(long)]
+        check: bool,
+
         /// Additional arguments to pass through to the package manager
         #[arg(last = true, allow_hyphen_values = true)]
         pass_through_args: Option<Vec<String>>,
@@ -281,7 +293,13 @@ pub enum Commands {
 impl Commands {
     /// Check if this command is a package manager command that should skip auto-install
     pub fn is_package_manager_command(&self) -> bool {
-        matches!(self, Commands::Install { .. } | Commands::Add { .. } | Commands::Remove { .. })
+        matches!(
+            self,
+            Commands::Install { .. }
+                | Commands::Add { .. }
+                | Commands::Remove { .. }
+                | Commands::Dedupe { .. }
+        )
     }
 }
 
@@ -703,6 +721,11 @@ pub async fn main<
                 .await?;
             return Ok(exit_status);
         }
+        Commands::Dedupe { check, pass_through_args } => {
+            let exit_status =
+                DedupeCommand::new(cwd).execute(*check, pass_through_args.as_deref()).await?;
+            return Ok(exit_status);
+        }
     };
 
     let execution_summary_dir = EXECUTION_SUMMARY_DIR.as_path();
@@ -2320,4 +2343,67 @@ mod tests {
             }
         }
     }
+
+    mod dedupe_command_tests {
+        use super::*;
+
+        #[test]
+        fn test_args_dedupe_command_basic() {
+            let args = Args::try_parse_from(&["vite-plus", "dedupe"]).unwrap();
+            if let Commands::Dedupe { check, .. } = &args.commands {
+                assert!(!check);
+            } else {
+                panic!("Expected Dedupe command");
+            }
+        }
+
+        #[test]
+        fn test_args_dedupe_command_with_alias() {
+            let args = Args::try_parse_from(&["vite-plus", "ddp"]).unwrap();
+            assert!(matches!(args.commands, Commands::Dedupe { .. }));
+        }
+
+        #[test]
+        fn test_args_dedupe_command_with_check() {
+            let args = Args::try_parse_from(&["vite-plus", "dedupe", "--check"]).unwrap();
+            if let Commands::Dedupe { check, .. } = &args.commands {
+                assert!(check);
+            } else {
+                panic!("Expected Dedupe command");
+            }
+        }
+
+        #[test]
+        fn test_args_dedupe_command_with_pass_through_args() {
+            let args = Args::try_parse_from(&[
+                "vite-plus",
+                "dedupe",
+                "--",
+                "--some-flag",
+                "--another-flag",
+            ])
+            .unwrap();
+            if let Commands::Dedupe { pass_through_args, .. } = &args.commands {
+                assert_eq!(
+                    pass_through_args,
+                    &Some(vec!["--some-flag".to_string(), "--another-flag".to_string()])
+                );
+            } else {
+                panic!("Expected Dedupe command");
+            }
+        }
+
+        #[test]
+        fn test_args_dedupe_command_with_check_and_pass_through() {
+            let args =
+                Args::try_parse_from(&["vite-plus", "dedupe", "--check", "--", "--custom-flag"])
+                    .unwrap();
+            if let Commands::Dedupe { check, pass_through_args, .. } = &args.commands {
+                assert!(check);
+                assert_eq!(pass_through_args, &Some(vec!["--custom-flag".to_string()]));
+            } else {
+                panic!("Expected Dedupe command");
+            }
+        }
+    }
 }

packages/cli/binding/src/commands/dedupe.rs

@@ -0,0 +1,49 @@
+use std::process::ExitStatus;
+
+use vite_install::{commands::dedupe::DedupeCommandOptions, package_manager::PackageManager};
+use vite_path::AbsolutePathBuf;
+
+use crate::Error;
+
+/// Dedupe command for deduplicating dependencies by removing older versions.
+///
+/// This command automatically detects the package manager and translates
+/// the dedupe command to the appropriate package manager-specific syntax.
+pub struct DedupeCommand {
+    cwd: AbsolutePathBuf,
+}
+
+impl DedupeCommand {
+    pub fn new(cwd: AbsolutePathBuf) -> Self {
+        Self { cwd }
+    }
+
+    pub async fn execute(
+        self,
+        check: bool,
+        pass_through_args: Option<&[String]>,
+    ) -> Result<ExitStatus, Error> {
+        // Detect package manager
+        let package_manager = PackageManager::builder(&self.cwd).build().await?;
+
+        let dedupe_command_options = DedupeCommandOptions { check, pass_through_args };
+        package_manager.run_dedupe_command(&dedupe_command_options, &self.cwd).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_dedupe_command_new() {
+        let workspace_root = if cfg!(windows) {
+            AbsolutePathBuf::new("C:\\test".into()).unwrap()
+        } else {
+            AbsolutePathBuf::new("/test".into()).unwrap()
+        };
+
+        let cmd = DedupeCommand::new(workspace_root.clone());
+        assert_eq!(cmd.cwd, workspace_root);
+    }
+}

packages/cli/binding/src/commands/mod.rs

@@ -1,4 +1,5 @@
 pub(crate) mod add;
+pub(crate) mod dedupe;
 pub(crate) mod doc;
 pub(crate) mod fmt;
 pub(crate) mod install;

packages/cli/snap-tests/exit-non-zero-on-cmd-not-exists/snap.txt

@@ -1,6 +1,6 @@
 [2]> vite command-not-exists # should exit with non-zero code
 error: 'vite' requires a subcommand but one was not provided
-  [subcommands: run, lint, fmt, build, test, lib, dev, doc, cache, install, i, add, remove, rm, un, uninstall, update, up, help]
+  [subcommands: run, lint, fmt, build, test, lib, dev, doc, cache, install, i, add, remove, rm, un, uninstall, update, up, dedupe, ddp, help]
 
 Usage: vite [OPTIONS] [TASK] [-- <TASK_ARGS>...] <COMMAND>
 

packages/global/snap-tests/cli-helper-message/snap.txt

@@ -15,6 +15,7 @@ Commands:
   add      Add packages to dependencies
   remove   Remove packages from dependencies
   update   Update packages to their latest versions
+  dedupe   Deduplicate dependencies by removing older versions
   help     Print this message or the help of the given subcommand(s)
 
 Arguments:

packages/global/snap-tests/command-dedupe-npm10/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "command-dedupe-npm10",
+  "version": "1.0.0",
+  "packageManager": "npm@10.9.4",
+  "dependencies": {
+    "testnpm2": "1.0.1"
+  },
+  "devDependencies": {
+    "test-vite-plus-package": "1.0.0"
+  },
+  "optionalDependencies": {
+    "test-vite-plus-package-optional": "1.0.0"
+  }
+}