feat(pm): support add package

Author: fengmk2

crates/vite_error/src/lib.rs

@@ -133,6 +133,12 @@ pub enum Error {
     #[error("Unrecognized any package manager, please specify the package manager")]
     UnrecognizedPackageManager,
 
+    #[error("No package manager detected. Run 'vite install' to set up a package manager.")]
+    NoPackageManagerDetected,
+
+    #[error("No packages specified. Usage: vite add <packages>...")]
+    NoPackagesSpecified,
+
     #[error(
         "Package manager {name}@{version} in {package_json_path:?} is invalid, expected format: 'package-manager-name@major.minor.patch'"
     )]

crates/vite_package_manager/src/package_manager.rs

@@ -153,6 +153,68 @@ impl PackageManager {
             envs: HashMap::from([("PATH".to_string(), format_path_env(self.get_bin_prefix()))]),
         }
     }
+
+    /// Build command arguments for adding packages with workspace support
+    #[must_use]
+    pub fn build_add_args(
+        &self,
+        packages: &[String],
+        filters: &[String],
+        workspace_root: bool,
+        workspace_only: bool,
+        extra_args: &[String],
+    ) -> Vec<String> {
+        let mut args = Vec::new();
+
+        match self.client {
+            PackageManagerType::Pnpm => {
+                // pnpm: --filter must come before command
+                for filter in filters {
+                    args.push("--filter".to_string());
+                    args.push(filter.clone());
+                }
+                args.push("add".to_string());
+                args.extend_from_slice(packages);
+                if workspace_root {
+                    args.push("-w".to_string());
+                }
+                if workspace_only {
+                    args.push("--workspace".to_string());
+                }
+                args.extend_from_slice(extra_args);
+            }
+            PackageManagerType::Yarn => {
+                // yarn: workspace <pkg> add
+                if !filters.is_empty() {
+                    args.push("workspace".to_string());
+                    args.push(filters[0].clone());
+                }
+                args.push("add".to_string());
+                args.extend_from_slice(packages);
+                if workspace_root {
+                    args.push("-W".to_string());
+                }
+                args.extend_from_slice(extra_args);
+            }
+            PackageManagerType::Npm => {
+                // npm: install --workspace <pkg>
+                args.push("install".to_string());
+                args.extend_from_slice(packages);
+                if !filters.is_empty() {
+                    for filter in filters {
+                        args.push("--workspace".to_string());
+                        args.push(filter.clone());
+                    }
+                }
+                if workspace_root {
+                    args.push("-w".to_string());
+                }
+                args.extend_from_slice(extra_args);
+            }
+        }
+
+        args
+    }
 }
 
 /// The package root directory and its package.json file.
@@ -1611,4 +1673,122 @@ mod tests {
             "pnpmfile.cjs should be detected before yarn.config.cjs"
         );
     }
+
+    // Tests for build_add_args method
+    mod build_add_args_tests {
+        use super::*;
+
+        fn create_mock_pm(pm_type: PackageManagerType) -> 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: "1.0.0".into(),
+                hash: None,
+                bin_name: pm_type.to_string().into(),
+                workspace_root: temp_dir_path.clone(),
+                install_dir,
+            }
+        }
+
+        #[test]
+        fn test_pnpm_basic_add() {
+            let pm = create_mock_pm(PackageManagerType::Pnpm);
+            let args = pm.build_add_args(&["react".to_string()], &[], false, false, &[]);
+            assert_eq!(args, vec!["add", "react"]);
+        }
+
+        #[test]
+        fn test_pnpm_add_with_filter() {
+            let pm = create_mock_pm(PackageManagerType::Pnpm);
+            let args =
+                pm.build_add_args(&["react".to_string()], &["app".to_string()], false, false, &[]);
+            assert_eq!(args, vec!["--filter", "app", "add", "react"]);
+        }
+
+        #[test]
+        fn test_pnpm_add_workspace_root() {
+            let pm = create_mock_pm(PackageManagerType::Pnpm);
+            let args = pm.build_add_args(
+                &["typescript".to_string()],
+                &[],
+                true,
+                false,
+                &["-D".to_string()],
+            );
+            assert_eq!(args, vec!["add", "typescript", "-w", "-D"]);
+        }
+
+        #[test]
+        fn test_pnpm_add_workspace_only() {
+            let pm = create_mock_pm(PackageManagerType::Pnpm);
+            let args = pm.build_add_args(
+                &["@myorg/utils".to_string()],
+                &["app".to_string()],
+                false,
+                true,
+                &[],
+            );
+            assert_eq!(args, vec!["--filter", "app", "add", "@myorg/utils", "--workspace"]);
+        }
+
+        #[test]
+        fn test_yarn_basic_add() {
+            let pm = create_mock_pm(PackageManagerType::Yarn);
+            let args = pm.build_add_args(&["react".to_string()], &[], false, false, &[]);
+            assert_eq!(args, vec!["add", "react"]);
+        }
+
+        #[test]
+        fn test_yarn_add_with_workspace() {
+            let pm = create_mock_pm(PackageManagerType::Yarn);
+            let args =
+                pm.build_add_args(&["react".to_string()], &["app".to_string()], false, false, &[]);
+            assert_eq!(args, vec!["workspace", "app", "add", "react"]);
+        }
+
+        #[test]
+        fn test_yarn_add_workspace_root() {
+            let pm = create_mock_pm(PackageManagerType::Yarn);
+            let args = pm.build_add_args(
+                &["typescript".to_string()],
+                &[],
+                true,
+                false,
+                &["-D".to_string()],
+            );
+            assert_eq!(args, vec!["add", "typescript", "-W", "-D"]);
+        }
+
+        #[test]
+        fn test_npm_basic_add() {
+            let pm = create_mock_pm(PackageManagerType::Npm);
+            let args = pm.build_add_args(&["react".to_string()], &[], false, false, &[]);
+            assert_eq!(args, vec!["install", "react"]);
+        }
+
+        #[test]
+        fn test_npm_add_with_workspace() {
+            let pm = create_mock_pm(PackageManagerType::Npm);
+            let args =
+                pm.build_add_args(&["react".to_string()], &["app".to_string()], false, false, &[]);
+            assert_eq!(args, vec!["install", "react", "--workspace", "app"]);
+        }
+
+        #[test]
+        fn test_npm_add_multiple_workspaces() {
+            let pm = create_mock_pm(PackageManagerType::Npm);
+            let args = pm.build_add_args(
+                &["lodash".to_string()],
+                &["app".to_string(), "web".to_string()],
+                false,
+                false,
+                &[],
+            );
+            assert_eq!(args, vec!["install", "lodash", "--workspace", "app", "--workspace", "web"]);
+        }
+    }
 }

crates/vite_task/src/add.rs

@@ -0,0 +1,124 @@
+use petgraph::stable_graph::StableGraph;
+use vite_package_manager::package_manager::PackageManager;
+use vite_path::AbsolutePathBuf;
+
+use crate::{
+    Error, ResolveCommandResult, Workspace,
+    config::ResolvedTask,
+    schedule::{ExecutionPlan, ExecutionSummary},
+};
+
+/// Add command for adding packages to dependencies.
+///
+/// This command automatically detects the package manager and translates
+/// the add command to the appropriate package manager-specific syntax.
+pub struct AddCommand {
+    workspace_root: AbsolutePathBuf,
+}
+
+impl AddCommand {
+    pub fn new(workspace_root: AbsolutePathBuf) -> Self {
+        Self { workspace_root }
+    }
+
+    pub async fn execute(
+        self,
+        filters: Vec<String>,
+        workspace_root: bool,
+        workspace_only: bool,
+        args: Vec<String>,
+    ) -> Result<ExecutionSummary, Error> {
+        if args.is_empty() {
+            return Err(Error::NoPackagesSpecified);
+        }
+
+        // Detect package manager
+        let package_manager = match PackageManager::builder(&self.workspace_root).build().await {
+            Ok(pm) => pm,
+            Err(Error::UnrecognizedPackageManager) => {
+                return Err(Error::NoPackageManagerDetected);
+            }
+            Err(e) => return Err(e),
+        };
+
+        let workspace = Workspace::partial_load(self.workspace_root)?;
+        let resolve_command = package_manager.resolve_command();
+
+        // Separate packages from extra args (everything after first -- or flag)
+        let (packages, extra_args) = Self::split_packages_and_args(&args);
+
+        // Build command arguments with workspace support
+        let full_args = package_manager.build_add_args(
+            &packages,
+            &filters,
+            workspace_root,
+            workspace_only,
+            &extra_args,
+        );
+
+        let resolved_task = ResolvedTask::resolve_from_builtin_with_command_result(
+            &workspace,
+            "add",
+            full_args.iter().map(String::as_str),
+            ResolveCommandResult { bin_path: resolve_command.bin_path, envs: resolve_command.envs },
+            false,
+        )?;
+
+        let mut task_graph: StableGraph<ResolvedTask, ()> = Default::default();
+        task_graph.add_node(resolved_task);
+        let summary = ExecutionPlan::plan(task_graph, false)?.execute(&workspace).await?;
+        workspace.unload().await?;
+
+        Ok(summary)
+    }
+
+    /// Split args into packages and extra arguments
+    fn split_packages_and_args(args: &[String]) -> (Vec<String>, Vec<String>) {
+        // Everything is treated as packages/args - no special separator needed
+        // Flags like -D, -E etc. are package manager-specific and passed through
+        (args.to_vec(), vec![])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_add_command_new() {
+        let workspace_root = if cfg!(windows) {
+            AbsolutePathBuf::new("C:\\test".into()).unwrap()
+        } else {
+            AbsolutePathBuf::new("/test".into()).unwrap()
+        };
+
+        let cmd = AddCommand::new(workspace_root.clone());
+        assert_eq!(cmd.workspace_root, workspace_root);
+    }
+
+    #[tokio::test]
+    async fn test_add_command_no_packages() {
+        let workspace_root = if cfg!(windows) {
+            AbsolutePathBuf::new("C:\\test".into()).unwrap()
+        } else {
+            AbsolutePathBuf::new("/test".into()).unwrap()
+        };
+
+        let cmd = AddCommand::new(workspace_root);
+        let result = cmd.execute(vec![], false, false, vec![]).await;
+
+        assert!(result.is_err());
+        assert!(matches!(result.unwrap_err(), Error::NoPackagesSpecified));
+    }
+
+    #[test]
+    fn test_split_packages_and_args() {
+        let (packages, extra) = AddCommand::split_packages_and_args(&[
+            "react".to_string(),
+            "react-dom".to_string(),
+            "-D".to_string(),
+        ]);
+        assert_eq!(packages, vec!["react", "react-dom", "-D"]);
+        assert!(extra.is_empty());
+    }
+}