feat: intergrate vite_task_plan and vite_task_graph in vite_task::session (#64)

# feat: integrate vite_task_plan and vite_task_graph

This PR integrates the task planning and execution functionality from `vite_task_plan` and `vite_task_graph` into the main `vite_task` crate. Key changes include:

- Added a new `Session` type in `vite_task` that manages task graph loading and provides methods to plan and execute tasks
- Implemented CLI argument parsing with `clap` for task commands
- Added `async-trait` for better async interface design
- Created a path redaction feature in `vite_path` for stable serialization of absolute paths
- Moved snapshot tests from `vite_task_graph` to `vite_task`
- Removed the standalone `vite_task_bin` crate in favor of a binary in `vite_task`
- Added proper workspace node_modules/.bin path handling for task execution

The PR establishes a cleaner architecture where `vite_task` serves as the main entry point for task planning and execution, while `vite_task_graph` and `vite_task_plan` provide the underlying functionality.

Author: branchseer

Cargo.lock

@@ -36,6 +36,7 @@ allocator-api2 = { version = "0.2.21", default-features = false, features = ["al
 anyhow = "1.0.98"
 assert2 = "0.3.16"
 assertables = "9.8.1"
+async-trait = "0.1.89"
 base64 = "0.22.1"
 bincode = "2.0.1"
 bindgen = "0.72.1"
@@ -122,6 +123,7 @@ vite_path = { path = "crates/vite_path" }
 vite_shell = { path = "crates/vite_shell" }
 vite_str = { path = "crates/vite_str" }
 vite_task_graph = { path = "crates/vite_task_graph" }
+vite_task_plan = { path = "crates/vite_task_plan" }
 vite_workspace = { path = "crates/vite_workspace" }
 wax = "0.6.0"
 which = "8.0.0"

Cargo.toml

@@ -14,6 +14,9 @@ serde = { workspace = true, features = ["derive", "rc"] }
 thiserror = { workspace = true }
 vite_str = { workspace = true }
 
+[features]
+absolute-redaction = []
+
 [lints]
 workspace = true
 

crates/vite_path/Cargo.toml

@@ -1,3 +1,6 @@
+#[cfg(feature = "absolute-redaction")]
+pub mod redaction;
+
 use std::{
     ffi::OsStr,
     fmt::Display,
@@ -8,6 +11,7 @@ use std::{
 };
 
 use ref_cast::{RefCastCustom, ref_cast_custom};
+use serde::Serialize;
 
 use crate::relative::{FromPathError, InvalidPathDataError, RelativePathBuf};
 
@@ -21,6 +25,35 @@ impl AsRef<Self> for AbsolutePath {
     }
 }
 
+impl Serialize for AbsolutePath {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        #[cfg(feature = "absolute-redaction")]
+        {
+            use redaction::REDACTION_PREFIX;
+
+            if let Some(redaction_prefix) = REDACTION_PREFIX
+                .with(|redaction_prefix| redaction_prefix.borrow().as_ref().map(Arc::clone))
+            {
+                match self.strip_prefix(redaction_prefix) {
+                    Ok(Some(stripped_path)) => return stripped_path.serialize(serializer),
+                    Err(strip_error) => {
+                        return Err(serde::ser::Error::custom(format!(
+                            "Failed to redact absolute path '{}': {}",
+                            self.as_path().display(),
+                            strip_error
+                        )));
+                    }
+                    Ok(None) => { /* continue to serialize full path */ }
+                }
+            }
+        }
+        self.as_path().serialize(serializer)
+    }
+}
+
 impl PartialEq<AbsolutePathBuf> for AbsolutePath {
     fn eq(&self, other: &AbsolutePathBuf) -> bool {
         self.0 == other.0
@@ -46,6 +79,14 @@ impl From<&AbsolutePath> for Arc<AbsolutePath> {
     }
 }
 
+impl From<&AbsolutePath> for Box<AbsolutePath> {
+    fn from(path: &AbsolutePath) -> Self {
+        let path_box: Box<Path> = path.0.into();
+        let path_box_raw = Box::into_raw(path_box) as *mut AbsolutePath;
+        unsafe { Self::from_raw(path_box_raw) }
+    }
+}
+
 impl AbsolutePath {
     /// Creates a [`AbsolutePath`] if the give path is absolute.
     pub fn new<P: AsRef<Path> + ?Sized>(path: &P) -> Option<&Self> {

crates/vite_path/src/absolute.rs crates/vite_path/src/absolute/mod.rscrates/vite_path/src/absolute.rs renamed to crates/vite_path/src/absolute/mod.rs

@@ -0,0 +1,25 @@
+use std::sync::Arc;
+
+use super::AbsolutePath;
+
+thread_local! {
+    pub(crate) static REDACTION_PREFIX: std::cell::RefCell<Option<Arc<AbsolutePath>>> = std::cell::RefCell::new(None);
+}
+
+#[derive(Debug)]
+pub struct RedactionGuard(());
+
+impl Drop for RedactionGuard {
+    fn drop(&mut self) {
+        REDACTION_PREFIX.set(None);
+    }
+}
+
+pub fn redact_absolute_paths(prefix: &Arc<AbsolutePath>) -> RedactionGuard {
+    REDACTION_PREFIX.with(|redaction_prefix| {
+        let mut redaction_prefix = redaction_prefix.borrow_mut();
+        assert!(redaction_prefix.is_none(), "RedactionGuard already active");
+        *redaction_prefix = Some(Arc::clone(&prefix));
+    });
+    RedactionGuard(())
+}

crates/vite_path/src/absolute/redaction.rs

@@ -3,6 +3,8 @@ pub mod relative;
 
 use std::io;
 
+#[cfg(feature = "absolute-redaction")]
+pub use absolute::redaction;
 pub use absolute::{AbsolutePath, AbsolutePathBuf};
 pub use relative::{RelativePath, RelativePathBuf};
 

crates/vite_path/src/lib.rs

@@ -13,10 +13,13 @@ workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
+async-trait = { workspace = true }
 bincode = { workspace = true, features = ["derive"] }
 bstr = { workspace = true }
+clap = { workspace = true, features = ["derive"] }
 compact_str = { workspace = true, features = ["serde"] }
 dashmap = { workspace = true }
+derive_more = { workspace = true }
 diff-struct = { workspace = true }
 fspy = { workspace = true }
 futures-core = { workspace = true }
@@ -41,11 +44,17 @@ vite_glob = { workspace = true }
 vite_path = { workspace = true }
 vite_shell = { workspace = true }
 vite_str = { workspace = true }
+vite_task_graph = { workspace = true }
+vite_task_plan = { workspace = true }
 vite_workspace = { workspace = true }
 wax = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 nix = { workspace = true }
 
 [dev-dependencies]
+copy_dir = { workspace = true }
+insta = { workspace = true, features = ["glob", "json", "redactions"] }
 tempfile = { workspace = true }
+toml = { workspace = true }
+vite_path = { workspace = true, features = ["absolute-redaction"] }

crates/vite_task/Cargo.toml

@@ -0,0 +1,13 @@
+use clap::Parser;
+use vite_str::Str;
+use vite_task::CLIArgs;
+
+#[derive(Debug, Parser)]
+enum CustomTaskSubCommand {
+    /// oxlint
+    Lint { args: Vec<Str> },
+}
+
+fn main() {
+    let _subcommand = CLIArgs::<CustomTaskSubCommand>::parse();
+}