feat(cache): add explicit inputs config for cache fingerprinting

Add `inputs` field to task configuration supporting:
- Explicit glob patterns: `inputs: ["src/**/*.ts"]`
- Auto-inference from fspy: `inputs: [{ auto: true }]`
- Negative patterns: `inputs: ["src/**", "!**/*.test.ts"]`
- Mixed mode: `inputs: ["package.json", { auto: true }, "!dist/**"]`
- Empty array to disable file tracking: `inputs: []`

Key changes:
- Add `ResolvedInputConfig` to parse and normalize user input config
- Add `glob_inputs.rs` for walking glob patterns and hashing files
- Update `PreRunFingerprint` to include `input_config` and `glob_base`
- Bump cache DB version to 6 for new fingerprint structure
- Add comprehensive e2e tests for all input combinations

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

# Conflicts:
#	crates/vite_task_plan/src/plan.rs

Author: branchseer

Cargo.lock

@@ -38,6 +38,10 @@ vite_str = { workspace = true }
 vite_task_graph = { workspace = true }
 vite_task_plan = { workspace = true }
 vite_workspace = { workspace = true }
+wax = { workspace = true }
+
+[dev-dependencies]
+tempfile = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 nix = { workspace = true }

crates/vite_task/Cargo.toml

@@ -35,12 +35,6 @@ enum SpawnFingerprintChange {
     // Working directory change
     /// Working directory changed
     CwdChanged,
-
-    // Fingerprint ignores changes
-    /// Fingerprint ignore pattern added
-    FingerprintIgnoreAdded { pattern: String },
-    /// Fingerprint ignore pattern removed
-    FingerprintIgnoreRemoved { pattern: String },
 }
 
 /// Compare two spawn fingerprints and return all changes
@@ -105,21 +99,6 @@ fn detect_spawn_fingerprint_changes(
         changes.push(SpawnFingerprintChange::CwdChanged);
     }
 
-    // Check fingerprint ignores changes
-    let old_ignores: HashSet<_> =
-        old.fingerprint_ignores().map(|v| v.iter().collect()).unwrap_or_default();
-    let new_ignores: HashSet<_> =
-        new.fingerprint_ignores().map(|v| v.iter().collect()).unwrap_or_default();
-    for pattern in old_ignores.difference(&new_ignores) {
-        changes.push(SpawnFingerprintChange::FingerprintIgnoreRemoved {
-            pattern: pattern.to_string(),
-        });
-    }
-    for pattern in new_ignores.difference(&old_ignores) {
-        changes
-            .push(SpawnFingerprintChange::FingerprintIgnoreAdded { pattern: pattern.to_string() });
-    }
-
     changes
 }
 
@@ -161,10 +140,6 @@ pub fn format_cache_status_inline(cache_status: &CacheStatus) -> Option<String>
                         Some(SpawnFingerprintChange::ProgramChanged) => "program changed",
                         Some(SpawnFingerprintChange::ArgsChanged) => "args changed",
                         Some(SpawnFingerprintChange::CwdChanged) => "working directory changed",
-                        Some(
-                            SpawnFingerprintChange::FingerprintIgnoreAdded { .. }
-                            | SpawnFingerprintChange::FingerprintIgnoreRemoved { .. },
-                        ) => "fingerprint ignores changed",
                         None => "configuration changed",
                     }
                 }
@@ -246,12 +221,6 @@ pub fn format_cache_status_summary(cache_status: &CacheStatus) -> String {
                             SpawnFingerprintChange::CwdChanged => {
                                 "working directory changed".to_string()
                             }
-                            SpawnFingerprintChange::FingerprintIgnoreAdded { pattern } => {
-                                format!("fingerprint ignore '{pattern}' added")
-                            }
-                            SpawnFingerprintChange::FingerprintIgnoreRemoved { pattern } => {
-                                format!("fingerprint ignore '{pattern}' removed")
-                            }
                         })
                         .collect();
 

crates/vite_task/src/session/cache/display.rs

@@ -2,22 +2,40 @@
 
 pub mod display;
 
-use std::{fmt::Display, fs::File, io::Write, sync::Arc, time::Duration};
+use std::{collections::BTreeMap, fmt::Display, fs::File, io::Write, sync::Arc, time::Duration};
 
 use bincode::{Decode, Encode, decode_from_slice, encode_to_vec};
 // Re-export display functions for convenience
 pub use display::{format_cache_status_inline, format_cache_status_summary};
 use rusqlite::{Connection, OptionalExtension as _, config::DbConfig};
 use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex;
-use vite_path::{AbsolutePath, AbsolutePathBuf};
+use vite_path::{AbsolutePath, AbsolutePathBuf, RelativePathBuf};
+use vite_task_graph::config::ResolvedInputConfig;
 use vite_task_plan::cache_metadata::{CacheMetadata, ExecutionCacheKey, SpawnFingerprint};
 
 use super::execute::{
     fingerprint::{PostRunFingerprint, PostRunFingerprintMismatch},
     spawn::StdOutput,
 };
 
+/// Pre-run fingerprint computed at execution time.
+/// Contains spawn fingerprint, input configuration, and explicit input file hashes.
+#[derive(Debug, Encode, Decode, Serialize, PartialEq, Eq, Clone)]
+pub struct PreRunFingerprint {
+    /// The spawn fingerprint (command, args, cwd, envs)
+    pub spawn_fingerprint: SpawnFingerprint,
+    /// Resolved input configuration that affects cache behavior.
+    pub input_config: ResolvedInputConfig,
+    /// Base directory for glob patterns, relative to workspace root.
+    /// This is where the task is defined (package path).
+    pub glob_base: RelativePathBuf,
+    /// Hashes of explicit input files computed from positive globs.
+    /// Files matching negative globs are already filtered out.
+    /// Path is relative to workspace root, value is xxHash3_64 of file content.
+    pub globbed_inputs: BTreeMap<RelativePathBuf, u64>,
+}
+
 /// Command cache value, for validating post-run fingerprint after the spawn fingerprint is matched,
 /// and replaying the std outputs if validated.
 #[derive(Debug, Encode, Decode, Serialize)]
@@ -85,23 +103,23 @@ impl ExecutionCache {
                 0 => {
                     // fresh new db
                     conn.execute(
-                        "CREATE TABLE spawn_fingerprint_cache (key BLOB PRIMARY KEY, value BLOB);",
+                        "CREATE TABLE pre_run_fingerprint_cache (key BLOB PRIMARY KEY, value BLOB);",
                         (),
                     )?;
                     conn.execute(
                         "CREATE TABLE execution_key_to_fingerprint (key BLOB PRIMARY KEY, value BLOB);",
                         (),
                     )?;
-                    conn.execute("PRAGMA user_version = 4", ())?;
+                    conn.execute("PRAGMA user_version = 6", ())?;
                 }
-                1..=3 => {
+                1..=5 => {
                     // old internal db version. reset
                     conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, true)?;
                     conn.execute("VACUUM", ())?;
                     conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, false)?;
                 }
-                4 => break, // current version
-                5.. => {
+                6 => break, // current version
+                7.. => {
                     return Err(anyhow::anyhow!("Unrecognized database version: {}", user_version));
                 }
             }
@@ -116,26 +134,58 @@ impl ExecutionCache {
         Ok(())
     }
 
-    /// Try to hit cache with spawn fingerprint.
+    /// Try to hit cache with pre-run fingerprint (spawn + globbed inputs).
     /// Returns `Ok(Ok(cache_value))` on cache hit, `Ok(Err(cache_miss))` on miss.
+    ///
+    /// # Arguments
+    /// * `cache_metadata` - Cache metadata from plan stage
+    /// * `globbed_inputs` - Hashes of explicit input files computed from positive globs
+    /// * `base_dir` - Workspace root for validating post-run fingerprint
     pub async fn try_hit(
         &self,
         cache_metadata: &CacheMetadata,
+        globbed_inputs: BTreeMap<RelativePathBuf, u64>,
         base_dir: &AbsolutePath,
     ) -> anyhow::Result<Result<CommandCacheValue, CacheMiss>> {
         let spawn_fingerprint = &cache_metadata.spawn_fingerprint;
         let execution_cache_key = &cache_metadata.execution_cache_key;
+        let input_config = &cache_metadata.input_config;
+
+        // Convert absolute glob_base to relative for cache key
+        let glob_base = cache_metadata
+            .glob_base
+            .strip_prefix(base_dir)
+            .map_err(|e| anyhow::anyhow!("failed to strip prefix from glob_base: {e}"))?
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "glob_base {:?} is not inside workspace {:?}",
+                    cache_metadata.glob_base,
+                    base_dir
+                )
+            })?;
+
+        // Build pre-run fingerprint combining spawn fingerprint, input config, and globbed inputs
+        let pre_run_fingerprint = PreRunFingerprint {
+            spawn_fingerprint: spawn_fingerprint.clone(),
+            input_config: input_config.clone(),
+            glob_base,
+            globbed_inputs,
+        };
 
-        // Try to directly find the cache by spawn fingerprint first
-        if let Some(cache_value) = self.get_by_spawn_fingerprint(spawn_fingerprint).await? {
-            // Validate post-run fingerprint
-            if let Some(post_run_fingerprint_mismatch) =
-                cache_value.post_run_fingerprint.validate(base_dir)?
-            {
-                // Found the cache with the same spawn fingerprint, but the post-run fingerprint mismatches
-                return Ok(Err(CacheMiss::FingerprintMismatch(
-                    FingerprintMismatch::PostRunFingerprintMismatch(post_run_fingerprint_mismatch),
-                )));
+        // Try to directly find the cache by pre-run fingerprint first
+        if let Some(cache_value) = self.get_by_pre_run_fingerprint(&pre_run_fingerprint).await? {
+            // Validate post-run fingerprint (inferred inputs) only if auto inference is enabled
+            if input_config.includes_auto {
+                if let Some(post_run_fingerprint_mismatch) =
+                    cache_value.post_run_fingerprint.validate(base_dir)?
+                {
+                    // Found the cache with the same pre-run fingerprint, but the post-run fingerprint mismatches
+                    return Ok(Err(CacheMiss::FingerprintMismatch(
+                        FingerprintMismatch::PostRunFingerprintMismatch(
+                            post_run_fingerprint_mismatch,
+                        ),
+                    )));
+                }
             }
             // Associate the execution key to the spawn fingerprint if not already,
             // so that next time we can find it and report spawn fingerprint mismatch
@@ -144,8 +194,8 @@ impl ExecutionCache {
             return Ok(Ok(cache_value));
         }
 
-        // No cache found with the current spawn fingerprint,
-        // check if execution key maps to different fingerprint
+        // No cache found with the current pre-run fingerprint,
+        // check if execution key maps to different spawn fingerprint
         if let Some(old_spawn_fingerprint) =
             self.get_fingerprint_by_execution_key(execution_cache_key).await?
         {
@@ -163,15 +213,45 @@ impl ExecutionCache {
     }
 
     /// Update cache after successful execution.
+    ///
+    /// # Arguments
+    /// * `cache_metadata` - Cache metadata from plan stage
+    /// * `globbed_inputs` - Hashes of explicit input files computed from positive globs
+    /// * `base_dir` - Workspace root for converting absolute paths to relative
+    /// * `cache_value` - The cache value to store (outputs and post-run fingerprint)
     pub async fn update(
         &self,
         cache_metadata: &CacheMetadata,
+        globbed_inputs: BTreeMap<RelativePathBuf, u64>,
+        base_dir: &AbsolutePath,
         cache_value: CommandCacheValue,
     ) -> anyhow::Result<()> {
         let spawn_fingerprint = &cache_metadata.spawn_fingerprint;
         let execution_cache_key = &cache_metadata.execution_cache_key;
+        let input_config = &cache_metadata.input_config;
+
+        // Convert absolute glob_base to relative for cache key
+        let glob_base = cache_metadata
+            .glob_base
+            .strip_prefix(base_dir)
+            .map_err(|e| anyhow::anyhow!("failed to strip prefix from glob_base: {e}"))?
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "glob_base {:?} is not inside workspace {:?}",
+                    cache_metadata.glob_base,
+                    base_dir
+                )
+            })?;
 
-        self.upsert_spawn_fingerprint_cache(spawn_fingerprint, &cache_value).await?;
+        // Build pre-run fingerprint combining spawn fingerprint, input config, and globbed inputs
+        let pre_run_fingerprint = PreRunFingerprint {
+            spawn_fingerprint: spawn_fingerprint.clone(),
+            input_config: input_config.clone(),
+            glob_base,
+            globbed_inputs,
+        };
+
+        self.upsert_pre_run_fingerprint_cache(&pre_run_fingerprint, &cache_value).await?;
         self.upsert_execution_key_to_fingerprint(execution_cache_key, spawn_fingerprint).await?;
         Ok(())
     }
@@ -197,11 +277,11 @@ impl ExecutionCache {
         Ok(Some(value))
     }
 
-    async fn get_by_spawn_fingerprint(
+    async fn get_by_pre_run_fingerprint(
         &self,
-        spawn_fingerprint: &SpawnFingerprint,
+        pre_run_fingerprint: &PreRunFingerprint,
     ) -> anyhow::Result<Option<CommandCacheValue>> {
-        self.get_key_by_value("spawn_fingerprint_cache", spawn_fingerprint).await
+        self.get_key_by_value("pre_run_fingerprint_cache", pre_run_fingerprint).await
     }
 
     async fn get_fingerprint_by_execution_key(
@@ -227,12 +307,12 @@ impl ExecutionCache {
         Ok(())
     }
 
-    async fn upsert_spawn_fingerprint_cache(
+    async fn upsert_pre_run_fingerprint_cache(
         &self,
-        spawn_fingerprint: &SpawnFingerprint,
+        pre_run_fingerprint: &PreRunFingerprint,
         cache_value: &CommandCacheValue,
     ) -> anyhow::Result<()> {
-        self.upsert("spawn_fingerprint_cache", spawn_fingerprint, cache_value).await
+        self.upsert("pre_run_fingerprint_cache", pre_run_fingerprint, cache_value).await
     }
 
     async fn upsert_execution_key_to_fingerprint(
@@ -273,9 +353,12 @@ impl ExecutionCache {
             &mut out,
         )
         .await?;
-        out.write_all(b"------- spawn_fingerprint_cache -------\n")?;
-        self.list_table::<SpawnFingerprint, CommandCacheValue>("spawn_fingerprint_cache", &mut out)
-            .await?;
+        out.write_all(b"------- pre_run_fingerprint_cache -------\n")?;
+        self.list_table::<PreRunFingerprint, CommandCacheValue>(
+            "pre_run_fingerprint_cache",
+            &mut out,
+        )
+        .await?;
         Ok(())
     }
 }