feat(cli): add link and unlink commands for package development (#274)

### TL;DR

Add `vite link` (alias: `vite ln`) and `vite unlink` commands to create and remove symlinks for local package development.

### What changed?

- Added new `link` and `unlink` commands to the CLI that work with all package managers (pnpm, yarn, npm)
- Implemented package manager-specific adaptations for both commands:
  - For pnpm: Supports recursive unlink with `-r` flag
  - For yarn: Translates recursive unlink to `--all` flag
  - For npm: Provides appropriate warnings for unsupported features
- Added support for different link scenarios:
  - Register current package globally (no arguments)
  - Link a global package to current project (`vite link <pkg>`)
  - Link a local directory (`vite link ./path/to/package`)
- Added unlink functionality with package-specific and recursive options
- Created comprehensive test suite and snap tests to verify correct command generation for each package manager

### How to test?

1. Register the current package globally:
```bash
vite link
```

2. Link a global package to your current project:
```bash
vite link react
```

3. Link a package from a local directory:
```bash
vite link ./packages/my-lib
vite link ../other-project
```

4. Unlink a package:
```bash
vite unlink react
```

5. Unlink in all workspace packages (pnpm/yarn only):
```bash
vite unlink --recursive
vite unlink -r
```

### Why make this change?

Local package development currently requires using package manager-specific commands with different syntaxes. This change provides a unified interface that:

1. Automatically detects and uses the correct package manager
2. Simplifies the workflow with a consistent command syntax
3. Handles the differences between package managers (like pnpm's `-r` flag vs yarn's `--all`)
4. Makes it easier to work with local packages during development without publishing
5. Provides a clean way to remove links when they're no longer needed

Author: fengmk2

crates/vite_install/src/commands/link.rs

@@ -0,0 +1,173 @@
+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 link command.
+#[derive(Debug, Default)]
+pub struct LinkCommandOptions<'a> {
+    pub package: Option<&'a str>,
+    pub pass_through_args: Option<&'a [String]>,
+}
+
+impl PackageManager {
+    /// Run the link command with the package manager.
+    /// Return the exit status of the command.
+    #[must_use]
+    pub async fn run_link_command(
+        &self,
+        options: &LinkCommandOptions<'_>,
+        cwd: impl AsRef<AbsolutePath>,
+    ) -> Result<ExitStatus, Error> {
+        let resolve_command = self.resolve_link_command(options);
+        run_command(&resolve_command.bin_path, &resolve_command.args, &resolve_command.envs, cwd)
+            .await
+    }
+
+    /// Resolve the link command.
+    #[must_use]
+    pub fn resolve_link_command(&self, options: &LinkCommandOptions) -> 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("link".into());
+            }
+            PackageManagerType::Yarn => {
+                bin_name = "yarn".into();
+                args.push("link".into());
+            }
+            PackageManagerType::Npm => {
+                bin_name = "npm".into();
+                args.push("link".into());
+            }
+        }
+
+        // Add package/directory if specified
+        if let Some(package) = options.package {
+            args.push(package.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 }
+    }
+}
+
+#[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_link_no_package() {
+        let pm = create_mock_package_manager(PackageManagerType::Pnpm, "10.0.0");
+        let result = pm.resolve_link_command(&LinkCommandOptions { ..Default::default() });
+        assert_eq!(result.bin_path, "pnpm");
+        assert_eq!(result.args, vec!["link"]);
+    }
+
+    #[test]
+    fn test_pnpm_link_package() {
+        let pm = create_mock_package_manager(PackageManagerType::Pnpm, "10.0.0");
+        let result = pm.resolve_link_command(&LinkCommandOptions {
+            package: Some("react"),
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "pnpm");
+        assert_eq!(result.args, vec!["link", "react"]);
+    }
+
+    #[test]
+    fn test_pnpm_link_directory() {
+        let pm = create_mock_package_manager(PackageManagerType::Pnpm, "10.0.0");
+        let result = pm.resolve_link_command(&LinkCommandOptions {
+            package: Some("./packages/utils"),
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "pnpm");
+        assert_eq!(result.args, vec!["link", "./packages/utils"]);
+    }
+
+    #[test]
+    fn test_pnpm_link_absolute_directory() {
+        let pm = create_mock_package_manager(PackageManagerType::Pnpm, "10.0.0");
+        let result = pm.resolve_link_command(&LinkCommandOptions {
+            package: Some("/absolute/path/to/package"),
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "pnpm");
+        assert_eq!(result.args, vec!["link", "/absolute/path/to/package"]);
+    }
+
+    #[test]
+    fn test_yarn_link_basic() {
+        let pm = create_mock_package_manager(PackageManagerType::Yarn, "4.0.0");
+        let result = pm.resolve_link_command(&LinkCommandOptions { ..Default::default() });
+        assert_eq!(result.bin_path, "yarn");
+        assert_eq!(result.args, vec!["link"]);
+    }
+
+    #[test]
+    fn test_yarn_link_package() {
+        let pm = create_mock_package_manager(PackageManagerType::Yarn, "4.0.0");
+        let result = pm.resolve_link_command(&LinkCommandOptions {
+            package: Some("react"),
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "yarn");
+        assert_eq!(result.args, vec!["link", "react"]);
+    }
+
+    #[test]
+    fn test_npm_link_basic() {
+        let pm = create_mock_package_manager(PackageManagerType::Npm, "11.0.0");
+        let result = pm.resolve_link_command(&LinkCommandOptions { ..Default::default() });
+        assert_eq!(result.bin_path, "npm");
+        assert_eq!(result.args, vec!["link"]);
+    }
+
+    #[test]
+    fn test_npm_link_package() {
+        let pm = create_mock_package_manager(PackageManagerType::Npm, "11.0.0");
+        let result = pm.resolve_link_command(&LinkCommandOptions {
+            package: Some("react"),
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "npm");
+        assert_eq!(result.args, vec!["link", "react"]);
+    }
+}

crates/vite_install/src/commands/mod.rs

@@ -1,7 +1,9 @@
 pub mod add;
 pub mod dedupe;
 mod install;
+pub mod link;
 pub mod outdated;
 pub mod remove;
+pub mod unlink;
 pub mod update;
 pub mod why;

crates/vite_install/src/commands/unlink.rs

@@ -0,0 +1,198 @@
+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 unlink command.
+#[derive(Debug, Default)]
+pub struct UnlinkCommandOptions<'a> {
+    pub package: Option<&'a str>,
+    pub recursive: bool,
+    pub pass_through_args: Option<&'a [String]>,
+}
+
+impl PackageManager {
+    /// Run the unlink command with the package manager.
+    /// Return the exit status of the command.
+    #[must_use]
+    pub async fn run_unlink_command(
+        &self,
+        options: &UnlinkCommandOptions<'_>,
+        cwd: impl AsRef<AbsolutePath>,
+    ) -> Result<ExitStatus, Error> {
+        let resolve_command = self.resolve_unlink_command(options);
+        run_command(&resolve_command.bin_path, &resolve_command.args, &resolve_command.envs, cwd)
+            .await
+    }
+
+    /// Resolve the unlink command.
+    #[must_use]
+    pub fn resolve_unlink_command(&self, options: &UnlinkCommandOptions) -> 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("unlink".into());
+
+                if options.recursive {
+                    args.push("--recursive".into());
+                }
+            }
+            PackageManagerType::Yarn => {
+                bin_name = "yarn".into();
+                args.push("unlink".into());
+
+                if options.recursive {
+                    args.push("--all".into());
+                }
+            }
+            PackageManagerType::Npm => {
+                bin_name = "npm".into();
+                args.push("unlink".into());
+
+                if options.recursive {
+                    println!("Warning: npm doesn't support --recursive for unlink command");
+                }
+            }
+        }
+
+        // Add package if specified
+        if let Some(package) = options.package {
+            args.push(package.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 }
+    }
+}
+
+#[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_unlink_no_package() {
+        let pm = create_mock_package_manager(PackageManagerType::Pnpm, "10.0.0");
+        let result = pm.resolve_unlink_command(&UnlinkCommandOptions { ..Default::default() });
+        assert_eq!(result.bin_path, "pnpm");
+        assert_eq!(result.args, vec!["unlink"]);
+    }
+
+    #[test]
+    fn test_pnpm_unlink_package() {
+        let pm = create_mock_package_manager(PackageManagerType::Pnpm, "10.0.0");
+        let result = pm.resolve_unlink_command(&UnlinkCommandOptions {
+            package: Some("react"),
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "pnpm");
+        assert_eq!(result.args, vec!["unlink", "react"]);
+    }
+
+    #[test]
+    fn test_pnpm_unlink_recursive() {
+        let pm = create_mock_package_manager(PackageManagerType::Pnpm, "10.0.0");
+        let result = pm.resolve_unlink_command(&UnlinkCommandOptions {
+            recursive: true,
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "pnpm");
+        assert_eq!(result.args, vec!["unlink", "--recursive"]);
+    }
+
+    #[test]
+    fn test_pnpm_unlink_package_recursive() {
+        let pm = create_mock_package_manager(PackageManagerType::Pnpm, "10.0.0");
+        let result = pm.resolve_unlink_command(&UnlinkCommandOptions {
+            package: Some("react"),
+            recursive: true,
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "pnpm");
+        assert_eq!(result.args, vec!["unlink", "--recursive", "react"]);
+    }
+
+    #[test]
+    fn test_yarn_unlink_basic() {
+        let pm = create_mock_package_manager(PackageManagerType::Yarn, "4.0.0");
+        let result = pm.resolve_unlink_command(&UnlinkCommandOptions { ..Default::default() });
+        assert_eq!(result.bin_path, "yarn");
+        assert_eq!(result.args, vec!["unlink"]);
+    }
+
+    #[test]
+    fn test_yarn_unlink_package() {
+        let pm = create_mock_package_manager(PackageManagerType::Yarn, "4.0.0");
+        let result = pm.resolve_unlink_command(&UnlinkCommandOptions {
+            package: Some("react"),
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "yarn");
+        assert_eq!(result.args, vec!["unlink", "react"]);
+    }
+
+    #[test]
+    fn test_yarn_unlink_recursive() {
+        let pm = create_mock_package_manager(PackageManagerType::Yarn, "4.0.0");
+        let result = pm.resolve_unlink_command(&UnlinkCommandOptions {
+            recursive: true,
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "yarn");
+        assert_eq!(result.args, vec!["unlink", "--all"]);
+    }
+
+    #[test]
+    fn test_npm_unlink_basic() {
+        let pm = create_mock_package_manager(PackageManagerType::Npm, "11.0.0");
+        let result = pm.resolve_unlink_command(&UnlinkCommandOptions { ..Default::default() });
+        assert_eq!(result.bin_path, "npm");
+        assert_eq!(result.args, vec!["unlink"]);
+    }
+
+    #[test]
+    fn test_npm_unlink_package() {
+        let pm = create_mock_package_manager(PackageManagerType::Npm, "11.0.0");
+        let result = pm.resolve_unlink_command(&UnlinkCommandOptions {
+            package: Some("react"),
+            ..Default::default()
+        });
+        assert_eq!(result.bin_path, "npm");
+        assert_eq!(result.args, vec!["unlink", "react"]);
+    }
+}