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>

Author: branchseer

Cargo.lock

@@ -40,6 +40,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

@@ -40,11 +40,6 @@ pub enum SpawnFingerprintChange {
     /// Working directory changed
     CwdChanged,
 
-    // Fingerprint ignores changes
-    /// Fingerprint ignore pattern added
-    FingerprintIgnoreAdded { pattern: Str },
-    /// Fingerprint ignore pattern removed
-    FingerprintIgnoreRemoved { pattern: Str },
 }
 
 /// Format a single spawn fingerprint change as human-readable text.
@@ -70,12 +65,6 @@ pub fn format_spawn_change(change: &SpawnFingerprintChange) -> Str {
         SpawnFingerprintChange::ProgramChanged => Str::from("program changed"),
         SpawnFingerprintChange::ArgsChanged => Str::from("args changed"),
         SpawnFingerprintChange::CwdChanged => Str::from("working directory changed"),
-        SpawnFingerprintChange::FingerprintIgnoreAdded { pattern } => {
-            vite_str::format!("fingerprint ignore '{pattern}' added")
-        }
-        SpawnFingerprintChange::FingerprintIgnoreRemoved { pattern } => {
-            vite_str::format!("fingerprint ignore '{pattern}' removed")
-        }
     }
 }
 
@@ -141,20 +130,6 @@ pub fn detect_spawn_fingerprint_changes(
         changes.push(SpawnFingerprintChange::CwdChanged);
     }
 
-    // Check fingerprint ignores changes
-    let old_ignores: FxHashSet<_> =
-        old.fingerprint_ignores().map(|v| v.iter().collect()).unwrap_or_default();
-    let new_ignores: FxHashSet<_> =
-        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).clone() });
-    }
-    for pattern in new_ignores.difference(&old_ignores) {
-        changes
-            .push(SpawnFingerprintChange::FingerprintIgnoreAdded { pattern: (*pattern).clone() });
-    }
-
     changes
 }
 
@@ -196,10 +171,6 @@ pub fn format_cache_status_inline(cache_status: &CacheStatus) -> Option<Str> {
                         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",
                     }
                 }

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

@@ -2,7 +2,7 @@
 
 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
@@ -11,14 +11,32 @@ pub use display::{SpawnFingerprintChange, detect_spawn_fingerprint_changes, form
 use rusqlite::{Connection, OptionalExtension as _, config::DbConfig};
 use serde::{Deserialize, Serialize};
 use tokio::sync::Mutex;
-use vite_path::AbsolutePath;
+use vite_path::{AbsolutePath, 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)]
@@ -98,7 +116,7 @@ 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(
@@ -129,27 +147,59 @@ 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
     #[tracing::instrument(level = "debug", skip_all)]
     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
+                )
+            })?;
 
-        // 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),
-                )));
+        // 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 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
@@ -158,8 +208,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?
         {
@@ -177,16 +227,46 @@ 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)
     #[tracing::instrument(level = "debug", skip_all)]
     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
+                )
+            })?;
+
+        // 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_spawn_fingerprint_cache(spawn_fingerprint, &cache_value).await?;
+        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(())
     }
@@ -227,11 +307,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(
@@ -266,12 +346,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(
@@ -320,8 +400,8 @@ impl ExecutionCache {
             &mut out,
         )
         .await?;
-        out.write_all(b"------- spawn_fingerprint_cache -------\n")?;
-        self.list_table::<SpawnFingerprint, CommandCacheValue>("spawn_fingerprint_cache", &mut out)
+        out.write_all(b"------- pre_run_fingerprint_cache -------\n")?;
+        self.list_table::<PreRunFingerprint, CommandCacheValue>("pre_run_fingerprint_cache", &mut out)
             .await?;
         Ok(())
     }

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

@@ -16,6 +16,7 @@ use serde::{Deserialize, Serialize};
 use vite_glob::GlobPatternSet;
 use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_str::Str;
+use vite_task_graph::config::ResolvedInputConfig;
 
 use super::spawn::PathRead;
 use crate::collections::HashMap;
@@ -24,8 +25,9 @@ use crate::collections::HashMap;
 /// Used to validate whether cached outputs are still valid.
 #[derive(Encode, Decode, Debug, Serialize)]
 pub struct PostRunFingerprint {
-    /// Paths accessed during execution with their content fingerprints
-    pub inputs: HashMap<RelativePathBuf, PathFingerprint>,
+    /// Paths inferred from fspy during execution with their content fingerprints.
+    /// Only populated when `input_config.includes_auto` is true.
+    pub inferred_inputs: HashMap<RelativePathBuf, PathFingerprint>,
 }
 
 /// Fingerprint for a single path (file or directory)
@@ -70,26 +72,30 @@ impl PostRunFingerprint {
     /// Creates a new fingerprint from path accesses after task execution.
     ///
     /// # Arguments
-    /// * `path_reads` - Map of paths that were read during execution
+    /// * `path_reads` - Map of paths that were read during execution (from fspy)
     /// * `base_dir` - Workspace root for resolving relative paths
-    /// * `fingerprint_ignores` - Optional glob patterns to exclude from fingerprinting
+    /// * `input_config` - Resolved input configuration controlling what to fingerprint
     #[tracing::instrument(level = "debug", skip_all, name = "create_post_run_fingerprint")]
     pub fn create(
         path_reads: &HashMap<RelativePathBuf, PathRead>,
         base_dir: &AbsolutePath,
-        fingerprint_ignores: Option<&[Str]>,
+        input_config: &ResolvedInputConfig,
     ) -> anyhow::Result<Self> {
-        // Build ignore matcher from patterns if provided
-        let ignore_matcher = fingerprint_ignores
-            .filter(|patterns| !patterns.is_empty())
-            .map(GlobPatternSet::new)
-            .transpose()?;
+        // If inference is disabled, return empty inferred_inputs
+        if input_config.inference_disabled() {
+            return Ok(Self { inferred_inputs: HashMap::default() });
+        }
+
+        // Build negative pattern matcher for filtering inferred inputs
+        let patterns: Vec<Str> = input_config.negative_globs.iter().cloned().collect();
+        let negative_matcher =
+            if patterns.is_empty() { None } else { Some(GlobPatternSet::new(&patterns)?) };
 
-        let inputs = path_reads
+        let inferred_inputs = path_reads
             .par_iter()
             .filter(|(path, _)| {
-                // Apply ignore patterns if present
-                ignore_matcher.as_ref().is_none_or(|matcher| !matcher.is_match(path.as_str()))
+                // Apply negative patterns to exclude from inferred inputs
+                negative_matcher.as_ref().is_none_or(|matcher| !matcher.is_match(path.as_str()))
             })
             .map(|(relative_path, path_read)| {
                 let full_path = Arc::<AbsolutePath>::from(base_dir.join(relative_path));
@@ -98,7 +104,7 @@ impl PostRunFingerprint {
             })
             .collect::<anyhow::Result<HashMap<_, _>>>()?;
 
-        Ok(Self { inputs })
+        Ok(Self { inferred_inputs })
     }
 
     /// Validates the fingerprint against current filesystem state.
@@ -108,8 +114,10 @@ impl PostRunFingerprint {
         &self,
         base_dir: &AbsolutePath,
     ) -> anyhow::Result<Option<PostRunFingerprintMismatch>> {
-        let input_mismatch =
-            self.inputs.par_iter().find_map_any(|(input_relative_path, path_fingerprint)| {
+        let input_mismatch = self
+            .inferred_inputs
+            .par_iter()
+            .find_map_any(|(input_relative_path, path_fingerprint)| {
                 let input_full_path = Arc::<AbsolutePath>::from(base_dir.join(input_relative_path));
                 let path_read = PathRead {
                     read_dir_entries: matches!(path_fingerprint, PathFingerprint::Folder(Some(_))),