fix(task): cwd of builtin commands (#69)

Co-authored-by: branchseer <dk4rest@gmail.com>

Author: Brooooooklyn

Cargo.lock

@@ -17,6 +17,6 @@ rusqlite = { workspace = true }
 serde_json = { workspace = true }
 serde_yml = { workspace = true }
 thiserror = { workspace = true }
-wax = { workspace = true }
-vite_str = { workspace = true }
 vite_path = { workspace = true }
+vite_str = { workspace = true }
+wax = { workspace = true }

crates/vite_error/Cargo.toml

@@ -12,7 +12,7 @@ use vite_str::Str;
 use wax::Glob;
 
 use crate::package_manager::WorkspaceFile;
-pub use package_manager::{find_package_root, find_workspace_root};
+pub use package_manager::{WorkspaceRoot, find_package_root, find_workspace_root};
 
 /// The workspace configuration for pnpm.
 #[derive(Debug, Deserialize)]

crates/vite_package_manager/src/lib.rs

@@ -3,12 +3,13 @@ use std::io::{BufReader, Seek, SeekFrom};
 use std::path::Path;
 
 use vite_error::Error;
-use vite_path::AbsolutePath;
+use vite_path::{AbsolutePath, RelativePathBuf};
 
 /// The package root directory and its package.json file.
 #[derive(Debug)]
 pub struct PackageRoot<'a> {
     pub path: &'a AbsolutePath,
+    pub cwd: RelativePathBuf,
     pub package_json: File,
 }
 
@@ -20,7 +21,11 @@ pub fn find_package_root<'a>(original_cwd: &'a AbsolutePath) -> Result<PackageRo
     loop {
         // Check for package.json
         if let Some(file) = open_exists_file(cwd.join("package.json"))? {
-            return Ok(PackageRoot { path: cwd, package_json: file });
+            return Ok(PackageRoot {
+                path: cwd,
+                cwd: original_cwd.strip_prefix(cwd)?.expect("cwd must be within the package root"),
+                package_json: file,
+            });
         }
 
         if let Some(parent) = cwd.parent() {
@@ -54,6 +59,7 @@ pub enum WorkspaceFile {
 #[derive(Debug)]
 pub struct WorkspaceRoot<'a> {
     pub path: &'a AbsolutePath,
+    pub cwd: RelativePathBuf,
     pub workspace_file: WorkspaceFile,
 }
 
@@ -70,6 +76,9 @@ pub fn find_workspace_root<'a>(original_cwd: &'a AbsolutePath) -> Result<Workspa
         if let Some(file) = open_exists_file(cwd.join("pnpm-workspace.yaml"))? {
             return Ok(WorkspaceRoot {
                 path: cwd,
+                cwd: original_cwd
+                    .strip_prefix(cwd)?
+                    .expect("cwd must be within the pnpm workspace"),
                 workspace_file: WorkspaceFile::PnpmWorkspaceYaml(file),
             });
         }
@@ -83,6 +92,7 @@ pub fn find_workspace_root<'a>(original_cwd: &'a AbsolutePath) -> Result<Workspa
                 file.seek(SeekFrom::Start(0))?;
                 return Ok(WorkspaceRoot {
                     path: cwd,
+                    cwd: original_cwd.strip_prefix(cwd)?.expect("cwd must be within the workspace"),
                     workspace_file: WorkspaceFile::NpmWorkspaceJson(file),
                 });
             }
@@ -97,7 +107,11 @@ pub fn find_workspace_root<'a>(original_cwd: &'a AbsolutePath) -> Result<Workspa
             // We've reached the root, try to find the package root and return the non-workspace package.
             let package_root = find_package_root(original_cwd)?;
             let workspace_file = WorkspaceFile::NonWorkspacePackage(package_root.package_json);
-            return Ok(WorkspaceRoot { path: package_root.path, workspace_file });
+            return Ok(WorkspaceRoot {
+                path: package_root.path,
+                cwd: package_root.cwd,
+                workspace_file,
+            });
         }
     }
 }

crates/vite_package_manager/src/package_manager.rs

@@ -8,11 +8,11 @@ rust-version.workspace = true
 
 [dependencies]
 bincode = { workspace = true }
+diff-struct = { workspace = true }
 ref-cast = { workspace = true }
+serde = { workspace = true, features = ["derive", "rc"] }
 thiserror = { workspace = true }
 vite_str = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-diff-struct = { workspace = true }
 
 [lints]
 workspace = true

crates/vite_path/Cargo.toml

@@ -6,7 +6,7 @@ use std::{
     sync::Arc,
 };
 
-use crate::relative::{FromPathError, InvalidPathDataError, RelativePath, RelativePathBuf};
+use crate::relative::{FromPathError, InvalidPathDataError, RelativePathBuf};
 
 /// A path that is guaranteed to be absolute
 #[derive(RefCastCustom, Debug, PartialEq, Eq)]
@@ -53,7 +53,7 @@ impl AbsolutePath {
     ///
     /// If `base` is not a prefix of `self`, returns [`None`].
     ///
-    /// If the stripped path is not a valid [`RelativePath`]. Returns an error with the reason and the stripped path.
+    /// If the stripped path is not a valid `RelativePath`. Returns an error with the reason and the stripped path.
     pub fn strip_prefix<P: AsRef<AbsolutePath>>(
         &self,
         base: P,

crates/vite_path/src/absolute.rs

@@ -13,8 +13,7 @@ use std::{
 };
 use vite_str::Str;
 
-use bincode::{Decode, Encode, de::Decoder, error::DecodeError, impl_borrow_decode};
-
+use bincode::{Decode, Encode, de::Decoder, error::DecodeError};
 use ref_cast::{RefCastCustom, ref_cast_custom};
 
 /// A relative path with additional guarantees to make it portable:
@@ -67,20 +66,8 @@ impl RelativePath {
 
 /// A owned relative path buf with the same guarantees as `RelativePath`
 #[derive(
-    Debug,
-    Encode,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Hash,
-    Clone,
-    Serialize,
-    Deserialize,
-    Default,
-    Diff,
+    Debug, Encode, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Serialize, Deserialize, Default,
 )]
-#[diff(attr(#[derive(Debug)]))]
 pub struct RelativePathBuf(Str);
 
 impl AsRef<Path> for RelativePathBuf {
@@ -106,7 +93,24 @@ impl PartialEq<&RelativePath> for RelativePathBuf {
     }
 }
 
+impl Diff for RelativePathBuf {
+    type Repr = Option<Str>;
+    fn diff(&self, other: &Self) -> Self::Repr {
+        self.0.diff(&other.0)
+    }
+    fn apply(&mut self, diff: &Self::Repr) {
+        self.0.apply(diff);
+    }
+    fn identity() -> Self {
+        Self(Str::identity())
+    }
+}
+
 impl RelativePathBuf {
+    pub fn empty() -> Self {
+        Self("".into())
+    }
+
     /// Extends `self` with `path`.
     ///
     /// Unlike [`std::path::PathBuf::push`], `self` and `path` are both always relative,
@@ -171,7 +175,23 @@ impl<'a, Context> Decode<Context> for RelativePathBuf {
             .map_err(|err| DecodeError::OtherString(format!("{}: {}", err, path_str)))
     }
 }
-impl_borrow_decode!(RelativePathBuf);
+
+bincode::impl_borrow_decode!(RelativePathBuf);
+
+impl TryFrom<&Path> for RelativePathBuf {
+    type Error = FromPathError;
+    fn try_from(path: &Path) -> Result<Self, Self::Error> {
+        Self::new(path)
+    }
+}
+
+impl TryFrom<&str> for RelativePathBuf {
+    type Error = FromPathError;
+    fn try_from(path: &str) -> Result<Self, Self::Error> {
+        let path = Path::new(path);
+        Self::try_from(path)
+    }
+}
 
 impl AsRef<RelativePath> for RelativePathBuf {
     fn as_ref(&self) -> &RelativePath {