feat: add directory pruning for negative glob patterns in input selection

Move negative glob filtering from fingerprint.rs to spawn.rs so fspy-tracked
paths are filtered at the absolute path stage. Refactor glob_inputs.rs to
partition globs and walk from cleaned roots, enabling wax's automatic directory
pruning for exhaustive negative patterns like !dist/**.

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

Author: branchseer

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

@@ -15,9 +15,8 @@ use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use serde::{Deserialize, Serialize};
 use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_str::Str;
-use vite_task_graph::config::ResolvedInputConfig;
 
-use super::{glob_inputs::ResolvedGlob, spawn::PathRead};
+use super::spawn::PathRead;
 use crate::collections::HashMap;
 
 /// Post-run fingerprint capturing file state after execution.
@@ -70,42 +69,26 @@ impl std::fmt::Display for PostRunFingerprintMismatch {
 impl PostRunFingerprint {
     /// Creates a new fingerprint from path accesses after task execution.
     ///
+    /// Negative glob filtering is done upstream in `spawn_with_tracking`.
+    /// Paths may contain `..` components from fspy, so this method cleans them
+    /// before fingerprinting.
+    ///
     /// # Arguments
-    /// * `path_reads` - Map of paths that were read during execution (from fspy)
+    /// * `inferred_path_reads` - Map of paths that were read during execution (from fspy)
     /// * `base_dir` - Workspace root for resolving relative paths
-    /// * `glob_base` - Package directory where the task is defined (negative globs are relative to this)
-    /// * `input_config` - Resolved input configuration controlling what to fingerprint
     #[tracing::instrument(level = "debug", skip_all, name = "create_post_run_fingerprint")]
     pub fn create(
         inferred_path_reads: &HashMap<RelativePathBuf, PathRead>,
         base_dir: &AbsolutePath,
-        glob_base: &AbsolutePath,
-        input_config: &ResolvedInputConfig,
     ) -> anyhow::Result<Self> {
-        // If inference is disabled, return empty inferred_inputs
-        if !input_config.includes_auto {
-            return Ok(Self { inferred_inputs: HashMap::default() });
-        }
-
-        let negatives: Vec<ResolvedGlob> = input_config
-            .negative_globs
-            .iter()
-            .map(|p| ResolvedGlob::new(p.as_str(), glob_base))
-            .collect::<anyhow::Result<_>>()?;
-
         let inferred_inputs = inferred_path_reads
             .par_iter()
-            .filter_map(|(relative_path, path_read)| {
+            .map(|(relative_path, path_read)| {
                 // Clean the absolute path to normalize `..` from fspy-tracked paths
                 // (e.g., `packages/sub-pkg/../shared/dist/output.js`).
                 let cleaned_abs =
                     path_clean::PathClean::clean(base_dir.join(relative_path).as_path());
 
-                // Apply negative globs against the cleaned path
-                if negatives.iter().any(|neg| neg.matches(&cleaned_abs)) {
-                    return None;
-                }
-
                 // Derive a cleaned workspace-relative key so stored paths are normalized
                 let clean_key = cleaned_abs
                     .strip_prefix(base_dir.as_path())
@@ -114,11 +97,8 @@ impl PostRunFingerprint {
                     .unwrap_or_else(|| relative_path.clone());
 
                 let full_path = Arc::<AbsolutePath>::from(base_dir.join(&clean_key));
-                let fingerprint = match fingerprint_path(&full_path, *path_read) {
-                    Ok(f) => f,
-                    Err(e) => return Some(Err(e)),
-                };
-                Some(Ok((clean_key, fingerprint)))
+                let fingerprint = fingerprint_path(&full_path, *path_read)?;
+                Ok((clean_key, fingerprint))
             })
             .collect::<anyhow::Result<HashMap<_, _>>>()?;
 

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

@@ -10,71 +10,90 @@ use std::{
     io::{self, Read},
 };
 
-use path_clean::PathClean;
 #[cfg(test)]
 use vite_path::AbsolutePathBuf;
 use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_str::Str;
-use wax::{Glob, Program as _};
+use wax::{Glob, walk::Entry as _};
 
-/// A glob pattern resolved to an absolute base directory.
+use super::spawn::ResolvedNegativeGlob;
+
+/// Collect walk entries into the result map, filtering against resolved negatives.
 ///
-/// Uses [`wax::Glob::partition`] to separate the invariant prefix from the
-/// wildcard suffix, then resolves the prefix to an absolute path via
-/// [`path_clean`] (normalizing components like `..`).
+/// Each positive glob is partitioned into an invariant prefix and a variant pattern.
+/// The prefix is joined with `base_dir` and cleaned (normalizing `..`) to get the walk root.
+/// The variant pattern is then walked from the cleaned root.
 ///
-/// For example, `../shared/src/**` relative to `/ws/packages/app` resolves to:
-/// - `resolved_base`: `/ws/packages/shared/src`
-/// - `variant`: `Some(Glob("**"))`
-#[expect(clippy::disallowed_types, reason = "path_clean returns std::path::PathBuf")]
-pub struct ResolvedGlob {
-    resolved_base: std::path::PathBuf,
-    variant: Option<Glob<'static>>,
-}
-
-impl ResolvedGlob {
-    /// Resolve a glob pattern relative to `base_dir`.
-    pub fn new(pattern: &str, base_dir: &AbsolutePath) -> anyhow::Result<Self> {
-        let glob = Glob::new(pattern)?.into_owned();
-        let (base_pathbuf, variant) = glob.partition();
-        let base_str = base_pathbuf.to_str().unwrap_or(".");
-        let resolved_base = if base_str.is_empty() {
-            base_dir.as_path().to_path_buf()
-        } else {
-            base_dir.join(base_str).as_path().clean()
+/// Walk errors for non-existent directories are skipped gracefully.
+fn collect_walk_entries(
+    walk: impl Iterator<Item = Result<wax::walk::GlobEntry, wax::walk::WalkError>>,
+    workspace_root: &AbsolutePath,
+    resolved_negatives: &[ResolvedNegativeGlob],
+    result: &mut BTreeMap<RelativePathBuf, u64>,
+) -> anyhow::Result<()> {
+    use path_clean::PathClean as _;
+    use wax::Program as _;
+
+    for entry in walk {
+        let entry = match entry {
+            Ok(entry) => entry,
+            Err(err) => {
+                // WalkError -> io::Error preserves the error kind
+                let io_err: io::Error = err.into();
+                if io_err.kind() == io::ErrorKind::NotFound {
+                    continue;
+                }
+                return Err(io_err.into());
+            }
         };
-        Ok(Self { resolved_base, variant: variant.map(Glob::into_owned) })
-    }
+        if !entry.file_type().is_file() {
+            continue;
+        }
+
+        // Clean the path to normalize `..` components (from globs like `../shared/src/**`)
+        let cleaned_path = entry.path().clean();
 
-    /// Walk the filesystem and yield matching file paths.
-    #[expect(clippy::disallowed_types, reason = "yields std::path::PathBuf from wax walker")]
-    pub fn walk(&self) -> Box<dyn Iterator<Item = std::path::PathBuf> + '_> {
-        match &self.variant {
-            Some(variant_glob) => Box::new(
-                variant_glob
-                    .walk(&self.resolved_base)
-                    .filter_map(Result::ok)
-                    .map(wax::walk::Entry::into_path),
-            ),
-            None => Box::new(std::iter::once(self.resolved_base.clone())),
+        // Filter against resolved negatives
+        if resolved_negatives.iter().any(|(prefix, variant)| {
+            let Ok(remainder) = cleaned_path.strip_prefix(prefix) else {
+                return false;
+            };
+            variant.as_ref().map_or(remainder.as_os_str().is_empty(), |v| v.is_match(remainder))
+        }) {
+            continue;
         }
-    }
 
-    /// Check if an absolute path matches this resolved glob.
-    #[expect(clippy::disallowed_types, reason = "matching against std::path::Path")]
-    pub fn matches(&self, path: &std::path::Path) -> bool {
-        path.strip_prefix(&self.resolved_base).ok().is_some_and(|remainder| {
-            self.variant
-                .as_ref()
-                .map_or(remainder.as_os_str().is_empty(), |v| v.is_match(remainder))
-        })
+        // Compute path relative to workspace_root for the result
+        let Some(relative_to_workspace) = cleaned_path
+            .strip_prefix(workspace_root.as_path())
+            .ok()
+            .and_then(|p| RelativePathBuf::new(p).ok())
+        else {
+            continue; // Skip if path is outside workspace_root
+        };
+
+        // Hash file content
+        match hash_file_content(&cleaned_path) {
+            Ok(hash) => {
+                result.insert(relative_to_workspace, hash);
+            }
+            Err(err) if err.kind() == io::ErrorKind::NotFound => {
+                // File was deleted between walk and hash, skip it
+            }
+            Err(err) => {
+                return Err(err.into());
+            }
+        }
     }
+    Ok(())
 }
 
 /// Compute globbed inputs by walking positive glob patterns and filtering with negative patterns.
 ///
-/// Glob patterns may contain `..` to reference files outside the package directory
-/// (e.g., `../shared/src/**` to include a sibling package's source files).
+/// Each glob is partitioned into an invariant prefix and a variant pattern. The prefix is
+/// joined with `base_dir` and cleaned to normalize `..` components, producing the walk root.
+/// The variant pattern walks the cleaned root. Negative patterns are resolved the same way
+/// and used to filter walked entries by matching against cleaned absolute paths.
 ///
 /// # Arguments
 /// * `base_dir` - The package directory where the task is defined (globs are relative to this)
@@ -85,69 +104,59 @@ impl ResolvedGlob {
 /// # Returns
 /// A sorted map of relative paths (from `workspace_root`) to their content hashes.
 /// Only files are included (directories are skipped).
-///
-/// # Example
-/// ```ignore
-/// // For a task defined in `packages/foo/` with inputs: ["src/**/*.ts", "!**/*.test.ts"]
-/// let inputs = compute_globbed_inputs(
-///     &packages_foo_path,
-///     &workspace_root,
-///     &["src/**/*.ts".into()].into_iter().collect(),
-///     &["**/*.test.ts".into()].into_iter().collect(),
-/// )?;
-/// // Returns: { "packages/foo/src/index.ts" => 0x1234..., ... }
-/// ```
 pub fn compute_globbed_inputs(
     base_dir: &AbsolutePath,
     workspace_root: &AbsolutePath,
     positive_globs: &std::collections::BTreeSet<Str>,
     negative_globs: &std::collections::BTreeSet<Str>,
 ) -> anyhow::Result<BTreeMap<RelativePathBuf, u64>> {
-    // If no positive globs, return empty result
+    use path_clean::PathClean as _;
+
     if positive_globs.is_empty() {
         return Ok(BTreeMap::new());
     }
 
-    let negatives: Vec<ResolvedGlob> = negative_globs
+    // Resolve negatives: partition + clean to get (absolute_prefix, variant)
+    let resolved_negatives: Vec<ResolvedNegativeGlob> = negative_globs
         .iter()
-        .map(|p| ResolvedGlob::new(p.as_str(), base_dir))
+        .map(|p| {
+            let glob = Glob::new(p.as_str())?.into_owned();
+            let (prefix, variant) = glob.partition();
+            let resolved = base_dir.as_path().join(&prefix).clean();
+            Ok((resolved, variant.map(Glob::into_owned)))
+        })
         .collect::<anyhow::Result<_>>()?;
 
     let mut result = BTreeMap::new();
 
     for pattern in positive_globs {
-        let resolved = ResolvedGlob::new(pattern.as_str(), base_dir)?;
-
-        for absolute_path in resolved.walk() {
-            // Skip non-files
-            if !absolute_path.is_file() {
-                continue;
+        let pos = Glob::new(pattern.as_str())?.into_owned();
+        let (pos_prefix, pos_variant) = pos.partition();
+        let walk_root = base_dir.as_path().join(&pos_prefix).clean();
+
+        if let Some(variant_glob) = pos_variant {
+            if walk_root.is_dir() {
+                collect_walk_entries(
+                    variant_glob.into_owned().walk(&walk_root),
+                    workspace_root,
+                    &resolved_negatives,
+                    &mut result,
+                )?;
             }
-
-            // Apply negative patterns
-            if negatives.iter().any(|neg| neg.matches(&absolute_path)) {
-                continue;
-            }
-
-            // Compute path relative to workspace_root for the result
-            let Some(relative_to_workspace) = absolute_path
-                .strip_prefix(workspace_root.as_path())
-                .ok()
-                .and_then(|p| RelativePathBuf::new(p).ok())
-            else {
-                continue; // Skip if path is outside workspace_root
-            };
-
-            // Hash file content
-            match hash_file_content(&absolute_path) {
-                Ok(hash) => {
-                    result.insert(relative_to_workspace, hash);
-                }
-                Err(err) if err.kind() == io::ErrorKind::NotFound => {
-                    // File was deleted between walk and hash, skip it
-                }
-                Err(err) => {
-                    return Err(err.into());
+        } else {
+            // Invariant-only glob (specific file path) — hash directly if it exists
+            if walk_root.is_file()
+                && let Some(relative) = walk_root
+                    .strip_prefix(workspace_root.as_path())
+                    .ok()
+                    .and_then(|p| RelativePathBuf::new(p).ok())
+            {
+                match hash_file_content(&walk_root) {
+                    Ok(hash) => {
+                        result.insert(relative, hash);
+                    }
+                    Err(err) if err.kind() == io::ErrorKind::NotFound => {}
+                    Err(err) => return Err(err.into()),
                 }
             }
         }