refactor(cache): deduplicate PreRunFingerprint creation and add glob base tests

- Extract PreRunFingerprint::from_cache_metadata() to avoid code duplication
  in try_hit() and update() methods
- Rename base_dir parameter to workspace_root for clarity
- Replace expect() calls with proper anyhow errors in spawn.rs
- Add e2e tests for glob base directory behavior:
  - Verify globs are relative to package directory, not task cwd
  - Test root package and subpackage glob resolution
  - Test that custom cwd doesn't affect glob base

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

Author: branchseer

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

@@ -36,6 +36,40 @@ pub struct PreRunFingerprint {
     pub globbed_inputs: BTreeMap<RelativePathBuf, u64>,
 }
 
+impl PreRunFingerprint {
+    /// Build a pre-run fingerprint from cache metadata and globbed inputs.
+    ///
+    /// # Arguments
+    /// * `cache_metadata` - Cache metadata from plan stage (contains absolute glob_base)
+    /// * `globbed_inputs` - Hashes of explicit input files computed from positive globs
+    /// * `workspace_root` - Workspace root for converting absolute glob_base to relative
+    fn from_cache_metadata(
+        cache_metadata: &CacheMetadata,
+        globbed_inputs: BTreeMap<RelativePathBuf, u64>,
+        workspace_root: &AbsolutePath,
+    ) -> anyhow::Result<Self> {
+        // Convert absolute glob_base to relative for cache key
+        let glob_base = cache_metadata
+            .glob_base
+            .strip_prefix(workspace_root)
+            .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,
+                    workspace_root
+                )
+            })?;
+
+        Ok(Self {
+            spawn_fingerprint: cache_metadata.spawn_fingerprint.clone(),
+            input_config: cache_metadata.input_config.clone(),
+            glob_base,
+            globbed_inputs,
+        })
+    }
+}
+
 /// 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)]
@@ -140,44 +174,26 @@ impl ExecutionCache {
     /// # 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
+    /// * `workspace_root` - Workspace root for converting paths and validating fingerprints
     pub async fn try_hit(
         &self,
         cache_metadata: &CacheMetadata,
         globbed_inputs: BTreeMap<RelativePathBuf, u64>,
-        base_dir: &AbsolutePath,
+        workspace_root: &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,
-        };
+        let pre_run_fingerprint =
+            PreRunFingerprint::from_cache_metadata(cache_metadata, globbed_inputs, workspace_root)?;
 
         // 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)?
+                    cache_value.post_run_fingerprint.validate(workspace_root)?
                 {
                     // Found the cache with the same pre-run fingerprint, but the post-run fingerprint mismatches
                     return Ok(Err(CacheMiss::FingerprintMismatch(
@@ -217,39 +233,20 @@ impl ExecutionCache {
     /// # 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
+    /// * `workspace_root` - 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,
+        workspace_root: &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,
-        };
+        let pre_run_fingerprint =
+            PreRunFingerprint::from_cache_metadata(cache_metadata, globbed_inputs, workspace_root)?;
 
         self.upsert_pre_run_fingerprint_cache(&pre_run_fingerprint, &cache_value).await?;
         self.upsert_execution_key_to_fingerprint(execution_cache_key, spawn_fingerprint).await?;

crates/vite_task/src/session/execute/spawn.rs

@@ -154,18 +154,22 @@ where
         }
     }
 
-    let termination = match tracking_state {
-        TrackingState::FspyEnabled(tracked_child) => Some(tracked_child.wait_handle.await?),
+    // Wait for process termination and process path accesses if fspy was enabled
+    let (termination, path_accesses) = match tracking_state {
+        TrackingState::FspyEnabled(tracked_child) => {
+            let termination = tracked_child.wait_handle.await?;
+            // path_accesses must be Some when fspy is enabled (they're set together)
+            let path_accesses = path_accesses.ok_or_else(|| {
+                anyhow::anyhow!("internal error: fspy enabled but path_accesses is None")
+            })?;
+            (termination, path_accesses)
+        }
         TrackingState::FspyDisabled(mut tokio_child) => {
             let exit_status = tokio_child.wait().await?;
             return Ok(SpawnResult { exit_status, duration: start.elapsed() });
         }
     };
     let duration = start.elapsed();
-
-    // Process path accesses from fspy (only when fspy was enabled)
-    let termination = termination.expect("fspy enabled but no termination");
-    let path_accesses = path_accesses.expect("fspy enabled but no path_accesses");
     let path_reads = &mut path_accesses.path_reads;
     let path_writes = &mut path_accesses.path_writes;
 

crates/vite_task_bin/tests/e2e_snapshots/fixtures/glob-base-test/other/other.ts

@@ -0,0 +1 @@
+export const rootOther = 'initial';

crates/vite_task_bin/tests/e2e_snapshots/fixtures/glob-base-test/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "glob-base-test",
+  "private": true
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/glob-base-test/packages/sub-pkg/other/other.ts

@@ -0,0 +1 @@
+export const other = 'initial';

crates/vite_task_bin/tests/e2e_snapshots/fixtures/glob-base-test/packages/sub-pkg/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "sub-pkg",
+  "private": true
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/glob-base-test/packages/sub-pkg/src/sub.ts

@@ -0,0 +1 @@
+export const sub = 'initial';

crates/vite_task_bin/tests/e2e_snapshots/fixtures/glob-base-test/packages/sub-pkg/vite.config.json

@@ -0,0 +1,15 @@
+{
+  "tasks": {
+    "sub-glob-test": {
+      "command": "print-file src/sub.ts",
+      "inputs": ["src/**/*.ts"],
+      "cache": true
+    },
+    "sub-glob-with-cwd": {
+      "command": "print-file sub.ts",
+      "cwd": "src",
+      "inputs": ["src/**/*.ts"],
+      "cache": true
+    }
+  }
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/glob-base-test/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+packages:
+  - 'packages/*'

crates/vite_task_bin/tests/e2e_snapshots/fixtures/glob-base-test/snapshots.toml

@@ -0,0 +1,86 @@
+# Test glob base directory behavior
+# Globs are relative to PACKAGE directory, NOT task cwd
+
+# 1. Root package - glob matches files in root's src/
+[[e2e]]
+name = "root glob - matches src files"
+steps = [
+  "vite run root-glob-test",
+  # Modify matched file
+  "replace-file-content src/root.ts initial modified",
+  # Cache miss: file matches glob
+  "vite run root-glob-test",
+]
+
+[[e2e]]
+name = "root glob - ignores other directory"
+steps = [
+  "vite run root-glob-test",
+  # Modify file outside glob pattern
+  "replace-file-content other/other.ts initial modified",
+  # Cache hit: file doesn't match glob
+  "vite run root-glob-test",
+]
+
+[[e2e]]
+name = "root glob - ignores subpackage files"
+steps = [
+  "vite run root-glob-test",
+  # Modify file in subpackage - should NOT match root's src/**
+  "replace-file-content packages/sub-pkg/src/sub.ts initial modified",
+  # Cache hit: subpackage files don't match root's glob
+  "vite run root-glob-test",
+]
+
+# 2. Root package with custom cwd - glob still relative to package root
+[[e2e]]
+name = "root glob with cwd - glob relative to package not cwd"
+steps = [
+  "vite run root-glob-with-cwd",
+  # Modify file - glob is src/** relative to package root
+  "replace-file-content src/root.ts initial modified",
+  # Cache miss: file matches glob (relative to package, not cwd)
+  "vite run root-glob-with-cwd",
+]
+
+# 3. Subpackage - glob matches files in subpackage's src/
+[[e2e]]
+name = "subpackage glob - matches own src files"
+steps = [
+  "vite run sub-pkg#sub-glob-test",
+  # Modify matched file in subpackage
+  "replace-file-content packages/sub-pkg/src/sub.ts initial modified",
+  # Cache miss: file matches subpackage's glob
+  "vite run sub-pkg#sub-glob-test",
+]
+
+[[e2e]]
+name = "subpackage glob - ignores other directory in subpackage"
+steps = [
+  "vite run sub-pkg#sub-glob-test",
+  # Modify file outside glob pattern
+  "replace-file-content packages/sub-pkg/other/other.ts initial modified",
+  # Cache hit: file doesn't match glob
+  "vite run sub-pkg#sub-glob-test",
+]
+
+[[e2e]]
+name = "subpackage glob - ignores root src files"
+steps = [
+  "vite run sub-pkg#sub-glob-test",
+  # Modify file in root - should NOT match subpackage's src/**
+  "replace-file-content src/root.ts initial modified",
+  # Cache hit: root files don't match subpackage's glob
+  "vite run sub-pkg#sub-glob-test",
+]
+
+# 4. Subpackage with custom cwd - glob still relative to subpackage root
+[[e2e]]
+name = "subpackage glob with cwd - glob relative to package not cwd"
+steps = [
+  "vite run sub-pkg#sub-glob-with-cwd",
+  # Modify file - glob is src/** relative to subpackage root
+  "replace-file-content packages/sub-pkg/src/sub.ts initial modified",
+  # Cache miss: file matches glob (relative to subpackage, not cwd)
+  "vite run sub-pkg#sub-glob-with-cwd",
+]