feat(task): add subcommand "cache clean" & "cache view"

 (#105)

This PR changes the task cache to use a directory structure instead of a single database file:

- Changes cache path from `node_modules/.vite/task-cache.db` to `node_modules/.vite/task-cache` for easier clean
- The SQLite database is now stored as `cache.db` inside this directory
- Updates documentation to reflect the new cache location

Adds new cache management commands:
- `vite-plus cache clean` - Removes the cache directory
- `vite-plus cache view` - Displays cache contents in JSON format for debugging

Adds test cases to verify cache cleaning works correctly, including from subfolders.

Author: branchseer

bench/benches/workspace_load.rs

@@ -34,7 +34,7 @@ fn bench_workspace_load(c: &mut Criterion) {
 
     // Benchmark load with cache verification
     group.bench_function("load_with_cache_path", |b| {
-        let cache_path = fixture_path.join("node_modules/.vite/task-cache.db");
+        let cache_path = fixture_path.join("node_modules/.vite/task-cache");
         b.iter(|| {
             let workspace = black_box(
                 Workspace::load_with_cache_path(

crates/vite_task/docs/task-cache.md

@@ -492,15 +492,15 @@ stmt.execute(params![key_bytes, value_bytes])?;
 
 ## Configuration
 
-### Cache File Location
+### Cache Location
 
-The cache database location can be configured via environment variable:
+The cache location can be configured via environment variable:
 
 ```bash
 # Custom cache location
-VITE_CACHE_PATH=/tmp/vite-cache.db vite-plus run build
+VITE_CACHE_PATH=/tmp/vite-cache vite-plus run build
 
-# Default: .vite/cache.db in workspace root
+# Default: node_modules/.vite/task-cache in workspace root
 vite-plus run build
 ```
 

crates/vite_task/src/cache.rs

@@ -1,6 +1,7 @@
 use diff::Diff;
 use rusqlite::config::DbConfig;
 use std::fmt::Display;
+use std::io::Write;
 use std::sync::Arc;
 use vite_path::AbsolutePath;
 
@@ -79,9 +80,13 @@ impl Display for FingerprintMismatch {
 }
 
 impl TaskCache {
-    pub fn load_from_file(path: impl AsRef<AbsolutePath>) -> Result<Self, Error> {
+    pub fn load_from_path(path: impl AsRef<AbsolutePath>) -> Result<Self, Error> {
         let path = path.as_ref();
-        let conn = Connection::open(path.as_path())?;
+        tracing::info!("Creating task cache directory at {:?}", path);
+        std::fs::create_dir_all(path)?;
+
+        let db_path = path.join("cache.db");
+        let conn = Connection::open(db_path.as_path())?;
         conn.execute_batch("PRAGMA journal_mode=WAL; BEGIN EXCLUSIVE;")?;
         loop {
             let user_version: u32 = conn.query_one("PRAGMA user_version", (), |row| row.get(0))?;
@@ -96,16 +101,10 @@ impl TaskCache {
                         "CREATE TABLE taskrun_to_command (key BLOB PRIMARY KEY, value BLOB);",
                         (),
                     )?;
-                    conn.execute("PRAGMA user_version = 2", ())?;
-                }
-                1 => {
-                    // internal versions during dev, we just rebuild the whole cache
-                    conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, true)?;
-                    conn.execute("VACUUM", ())?;
-                    conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, false)?;
+                    conn.execute("PRAGMA user_version = 1", ())?;
                 }
-                2 => break, // current version
-                3.. => return Err(Error::UnrecognizedDbVersion(user_version)),
+                1 => break, // current version
+                2.. => return Err(Error::UnrecognizedDbVersion(user_version)),
             }
         }
         conn.execute_batch("COMMIT")?;
@@ -240,4 +239,34 @@ impl TaskCache {
     ) -> Result<(), Error> {
         self.upsert("taskrun_to_command", task_run_key, command_fingerprint).await
     }
+
+    async fn list_table<K: Decode<()> + Serialize, V: Decode<()> + Serialize>(
+        &self,
+        table: &str,
+        out: &mut impl Write,
+    ) -> Result<(), Error> {
+        let conn = self.conn.lock().await;
+        let mut select_stmt = conn.prepare_cached(&format!("SELECT key, value FROM {}", table))?;
+        let mut rows = select_stmt.query([])?;
+        while let Some(row) = rows.next()? {
+            let key_blob: Vec<u8> = row.get(0)?;
+            let value_blob: Vec<u8> = row.get(1)?;
+            let (key, _) = decode_from_slice::<K, _>(&key_blob, BINCODE_CONFIG)?;
+            let (value, _) = decode_from_slice::<V, _>(&value_blob, BINCODE_CONFIG)?;
+            writeln!(
+                out,
+                "{} => {}",
+                serde_json::to_string_pretty(&key)?,
+                serde_json::to_string_pretty(&value)?
+            )?;
+        }
+        Ok(())
+    }
+    pub async fn list(&self, mut out: impl Write) -> Result<(), Error> {
+        out.write_all(b"------- taskrun_to_command -------\n")?;
+        self.list_table::<TaskRunKey, CommandFingerprint>("taskrun_to_command", &mut out).await?;
+        out.write_all(b"------- command_cache -------\n")?;
+        self.list_table::<CommandFingerprint, CommandCacheValue>("command_cache", &mut out).await?;
+        Ok(())
+    }
 }

crates/vite_task/src/config/workspace.rs

@@ -69,6 +69,19 @@ impl Workspace {
         Self::partial_load_with_cache_path(cwd, None)
     }
 
+    fn get_cache_path_of_workspace(workspace_root: &AbsolutePath) -> AbsolutePathBuf {
+        if let Ok(env_cache_path) = std::env::var("VITE_CACHE_PATH") {
+            AbsolutePathBuf::new(env_cache_path.into()).expect("Cache path should be absolute")
+        } else {
+            workspace_root.join("node_modules/.vite/task-cache")
+        }
+    }
+
+    pub fn get_cache_path(cwd: &AbsolutePath) -> Result<AbsolutePathBuf, Error> {
+        let (workspace_root, _, _) = Self::determine_current_package_path(cwd)?;
+        Ok(Self::get_cache_path_of_workspace(workspace_root))
+    }
+
     pub fn partial_load_with_cache_path(
         cwd: AbsolutePathBuf,
         cache_path: Option<AbsolutePathBuf>,
@@ -77,21 +90,16 @@ impl Workspace {
         let (workspace_root, cwd, current_package_path) =
             Self::determine_current_package_path(&cwd)?;
 
-        let cache_path = cache_path.unwrap_or_else(|| {
-            if let Ok(env_cache_path) = std::env::var("VITE_CACHE_PATH") {
-                AbsolutePathBuf::new(env_cache_path.into()).expect("Cache path should be absolute")
-            } else {
-                workspace_root.join("node_modules/.vite/task-cache.db")
-            }
-        });
+        let cache_path =
+            cache_path.unwrap_or_else(|| Self::get_cache_path_of_workspace(&workspace_root));
 
         if !cache_path.as_path().exists()
             && let Some(cache_dir) = cache_path.as_path().parent()
         {
             tracing::info!("Creating task cache directory at {}", cache_dir.display());
             std::fs::create_dir_all(cache_dir)?;
         }
-        let task_cache = TaskCache::load_from_file(&cache_path)?;
+        let task_cache = TaskCache::load_from_path(&cache_path)?;
 
         let package_json_path = workspace_root.join("package.json");
         let package_json = if package_json_path.as_path().exists() {
@@ -137,21 +145,16 @@ impl Workspace {
             }
         }
 
-        let cache_path = cache_path.unwrap_or_else(|| {
-            if let Ok(env_cache_path) = std::env::var("VITE_CACHE_PATH") {
-                AbsolutePathBuf::new(env_cache_path.into()).expect("Cache path should be absolute")
-            } else {
-                workspace_root.join("node_modules/.vite/task-cache.db")
-            }
-        });
+        let cache_path =
+            cache_path.unwrap_or_else(|| Self::get_cache_path_of_workspace(workspace_root));
 
         if !cache_path.as_path().exists()
             && let Some(cache_dir) = cache_path.as_path().parent()
         {
             tracing::info!("Creating task cache directory at {}", cache_dir.display());
             std::fs::create_dir_all(cache_dir)?;
         }
-        let task_cache = TaskCache::load_from_file(&cache_path)?;
+        let task_cache = TaskCache::load_from_path(&cache_path)?;
 
         // Build the complete task graph
         let mut task_graph_builder = TaskGraphBuilder::default();

crates/vite_task/src/lib.rs

@@ -26,7 +26,7 @@ use clap::{Parser, Subcommand};
 
 use vite_str::Str;
 
-use crate::schedule::ExecutionPlan;
+use crate::{cache::TaskCache, schedule::ExecutionPlan};
 
 pub(crate) use vite_error::Error;
 
@@ -100,6 +100,19 @@ pub enum Commands {
         /// Arguments to pass to vite install
         args: Vec<String>,
     },
+    /// Manage the task cache
+    Cache {
+        #[clap(subcommand)]
+        subcmd: CacheSubcommand,
+    },
+}
+
+#[derive(Subcommand, Debug)]
+pub enum CacheSubcommand {
+    /// Clean up all the cache
+    Clean,
+    /// View the cache entries in json for debugging purpose
+    View,
 }
 
 /// Resolve boolean flag value considering both positive and negative forms.
@@ -270,6 +283,19 @@ pub async fn main<
             install::InstallCommand::builder(cwd).build().execute(&args).await?;
             return Ok(());
         }
+        Some(Commands::Cache { subcmd }) => {
+            let cache_path = Workspace::get_cache_path(&cwd)?;
+            match subcmd {
+                CacheSubcommand::Clean => {
+                    std::fs::remove_dir_all(&cache_path)?;
+                }
+                CacheSubcommand::View => {
+                    let cache = TaskCache::load_from_path(&cache_path)?;
+                    cache.list(std::io::stdout()).await?;
+                }
+            }
+            return Ok(());
+        }
         None => {
             let workspace = Workspace::load(cwd, false)?;
             // in implicit mode, vite-plus will run the task in the current package, replace the `pnpm/yarn/npm run` command.

crates/vite_task/src/test_utils.rs

@@ -7,7 +7,7 @@ where
 {
     let temp_dir = tempfile::tempdir().expect("Failed to create temp directory");
     let cache_path =
-        AbsolutePath::new(temp_dir.path()).unwrap().join(&format!("vite-test-{}.db", test_name));
+        AbsolutePath::new(temp_dir.path()).unwrap().join(&format!("vite-test-{}", test_name));
 
     let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| f(cache_path)));
 

packages/cli/tests/cases/cache-clean/package.json

@@ -0,0 +1,5 @@
+{
+    "scripts": {
+        "hello": "echo hello"
+    }
+}

packages/cli/tests/cases/cache-clean/snap.txt

@@ -0,0 +1,19 @@
+> vite-plus run hello # create the cache for 'echo hello'
+Cache not found
+hello
+
+> vite-plus run hello # hit the cache
+Cache hit, replaying
+hello
+
+> vite-plus cache clean # clean the cache
+
+> vite-plus run hello # cache miss after clean
+Cache not found
+hello
+
+> cd subfolder && vite-plus cache clean # cache can be located and cleaned from subfolder
+
+> vite-plus run hello # cache miss after clean
+Cache not found
+hello

packages/cli/tests/cases/cache-clean/steps.json

@@ -0,0 +1,13 @@
+{
+  "env": {
+    "VITE_DISABLE_AUTO_INSTALL": "1"
+  },
+  "commands": [
+    "vite-plus run hello # create the cache for 'echo hello'",
+    "vite-plus run hello # hit the cache",
+    "vite-plus cache clean # clean the cache",
+    "vite-plus run hello # cache miss after clean",
+    "cd subfolder && vite-plus cache clean # cache can be located and cleaned from subfolder",
+    "vite-plus run hello # cache miss after clean"
+  ]
+}