feat(task): vite subtask support (#83)

This pr is just a workaround. We are going to design a RPC style
architecture and make the sqlite connection singleton in the future.

Author: Brooooooklyn

crates/vite_task/src/cache.rs

@@ -55,8 +55,7 @@ impl TaskCache {
     pub fn load_from_file(path: impl AsRef<AbsolutePath>) -> Result<Self, Error> {
         let path = path.as_ref();
         let conn = Connection::open(path.as_path())?;
-        conn.execute_batch("PRAGMA journal_mode=WAL")?;
-        conn.execute("BEGIN EXCLUSIVE", ())?;
+        conn.execute_batch("PRAGMA journal_mode=WAL; BEGIN EXCLUSIVE;")?;
         loop {
             let user_version: u32 = conn.query_one("PRAGMA user_version", (), |row| row.get(0))?;
             match user_version {
@@ -70,13 +69,13 @@ impl TaskCache {
                 2.. => return Err(Error::UnrecognizedDbVersion(user_version)),
             }
         }
+        conn.execute_batch("COMMIT")?;
         Ok(Self { conn: Mutex::new(conn) })
     }
 
     #[tracing::instrument]
     pub async fn save(self) -> Result<(), Error> {
-        let conn = self.conn.lock().await;
-        conn.execute("COMMIT", ())?;
+        // do some cleanup in the future
         Ok(())
     }
 

crates/vite_task/src/config/task_command.rs

@@ -41,6 +41,12 @@ impl From<TaskCommand> for TaskConfig {
     }
 }
 
+impl TaskCommand {
+    pub fn is_vite(&self) -> bool {
+        matches!(self, Self::Parsed(parsed_command) if parsed_command.program == "vite")
+    }
+}
+
 #[derive(Encode, Decode, Debug, Serialize, PartialEq, Eq, Diff, Clone)]
 #[diff(attr(#[derive(Debug)]))]
 pub struct ResolvedTaskConfig {

crates/vite_task/src/execute.rs

@@ -10,7 +10,7 @@ use bincode::{Decode, Encode};
 use fspy::{AccessMode, Spy, TrackedChild};
 use supports_color::{Stream, on};
 
-use futures_util::future::try_join4;
+use futures_util::future::{try_join3, try_join4};
 use serde::{Deserialize, Serialize};
 use tokio::io::{AsyncRead, AsyncReadExt as _, AsyncWrite, AsyncWriteExt as _};
 use vite_path::{AbsolutePath, RelativePathBuf};
@@ -292,6 +292,31 @@ pub async fn execute_task(
             cmd
         }
         TaskCommand::Parsed(task_parsed_command) => {
+            if resolved_command.fingerprint.command.is_vite() {
+                let mut child = tokio::process::Command::new("vite")
+                    .args(&task_parsed_command.args)
+                    .envs(&resolved_command.all_envs)
+                    .envs(&task_parsed_command.envs)
+                    .stdout(Stdio::piped())
+                    .stderr(Stdio::piped())
+                    .spawn()?;
+                let child_stdout = child.stdout.take().unwrap();
+                let child_stderr = child.stderr.take().unwrap();
+
+                let outputs = Mutex::new(Vec::<StdOutput>::new());
+                let ((), (), exit_status) = try_join3(
+                    collect_std_outputs(&outputs, child_stdout, OutputKind::StdOut),
+                    collect_std_outputs(&outputs, child_stderr, OutputKind::StdErr),
+                    async move { Ok(child.wait().await?) },
+                )
+                .await?;
+                return Ok(ExecutedTask {
+                    std_outputs: outputs.into_inner().unwrap().into(),
+                    exit_status,
+                    path_reads: HashMap::new(),
+                    path_writes: HashMap::new(),
+                });
+            }
             let mut cmd = spy.new_command(&task_parsed_command.program);
             cmd.args(&task_parsed_command.args);
             cmd.envs(&resolved_command.all_envs);

crates/vite_task/src/schedule.rs

@@ -158,9 +158,13 @@ async fn get_cached_or_execute<'a>(
         Err(cache_miss) => (
             Some(cache_miss),
             async move {
+                let is_vite = task.resolved_command.fingerprint.command.is_vite();
                 let executed_task = execute_task(&task.resolved_command, base_dir).await?;
-                let cached_task = CachedTask::create(task.clone(), executed_task, fs, base_dir)?;
-                cache.update(&task, cached_task).await?;
+                if !is_vite {
+                    let cached_task =
+                        CachedTask::create(task.clone(), executed_task, fs, base_dir)?;
+                    cache.update(&task, cached_task).await?;
+                }
                 Ok(())
             }
             .boxed(),

package.json

@@ -1,26 +1,26 @@
 {
   "name": "vite-plus-monorepo",
   "private": true,
-  "packageManager": "pnpm@10.14.0",
+  "packageManager": "pnpm@10.15.1",
   "volta": {
     "node": "22.17.0"
   },
   "scripts": {
     "bootstrap-cli": "pnpm --filter=@voidzero-dev/vite-plus build && cp -r ./packages/cli/binding/*.node ./packages/global/dist && pnpm --filter=@voidzero-dev/global build && npm install -g ./packages/global",
     "bootstrap-cli:ci": "pnpm --filter=@voidzero-dev/vite-plus build:ts && pnpm --filter=@voidzero-dev/global build && npm install -g ./packages/global",
     "typecheck": "tsc -b tsconfig.json",
+    "lint": "vite lint",
     "prepare": "husky"
   },
   "devDependencies": {
     "@oxc-node/cli": "catalog:",
     "@oxc-node/core": "catalog:",
     "@types/node": "catalog:",
+    "@voidzero-dev/vite-plus": "workspace:*",
     "husky": "^9.1.7",
-    "lint-staged": "^16.1.2",
+    "lint-staged": "^16.1.6",
     "oxlint": "catalog:",
-    "typescript": "catalog:",
-    "rolldown-vite": "catalog:",
-    "@voidzero-dev/vite-plus": "workspace:*"
+    "typescript": "catalog:"
   },
   "lint-staged": {
     "*.@(js|ts|tsx|yml|yaml|md|json|html|toml)": [