feat(cache): support .. prefix in input glob patterns

Glob patterns like `../shared/src/**` and `!../shared/dist/**` now work
correctly by using wax's `partition()` to split the invariant base from
the wildcard, then resolving `..` components with `path_clean`. This
applies to both positive globs (in compute_globbed_inputs) and negative
globs (in both compute_globbed_inputs and PostRunFingerprint::create).

Also cleans fspy-tracked paths before negative glob matching, since fspy
reports paths with literal `..` (e.g., `packages/sub-pkg/../shared/`).

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

Author: branchseer

Cargo.lock

@@ -23,6 +23,7 @@ fspy = { workspace = true }
 futures-util = { workspace = true }
 once_cell = { workspace = true }
 owo-colors = { workspace = true }
+path-clean = { workspace = true }
 pty_terminal_test_client = { workspace = true }
 rayon = { workspace = true }
 rusqlite = { workspace = true, features = ["bundled"] }

crates/vite_task/Cargo.toml

@@ -13,12 +13,14 @@ use std::{
 use bincode::{Decode, Encode};
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 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 super::{
+    glob_inputs::{is_excluded, resolve_negative_globs},
+    spawn::PathRead,
+};
 use crate::collections::HashMap;
 
 /// Post-run fingerprint capturing file state after execution.
@@ -88,28 +90,21 @@ impl PostRunFingerprint {
             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)?) };
-
-        // Compute the package path relative to workspace root so we can convert
-        // workspace-relative paths to package-relative paths for negative glob matching.
-        // Negative globs like `!dist/**` are written relative to the package directory.
-        let package_prefix = glob_base.strip_prefix(base_dir).ok().flatten();
+        // Resolve negative globs relative to the package directory (glob_base),
+        // handling `..` components so patterns like `!../shared/dist/**` work.
+        let resolved_negatives = resolve_negative_globs(&input_config.negative_globs, glob_base)?;
 
         let inferred_inputs = path_reads
             .par_iter()
             .filter(|(path, _)| {
-                // Apply negative patterns to exclude from inferred inputs.
-                // Paths must be made package-relative before matching, since negative
-                // globs are relative to the package directory, not the workspace root.
-                negative_matcher.as_ref().is_none_or(|matcher| {
-                    let path_to_match =
-                        package_prefix.as_ref().and_then(|prefix| path.strip_prefix(prefix));
-                    path_to_match
-                        .map_or(true, |pkg_relative| !matcher.is_match(pkg_relative.as_str()))
-                })
+                if resolved_negatives.is_empty() {
+                    return true;
+                }
+                // Convert workspace-relative path to absolute for negative glob matching.
+                // Clean the path to resolve any `..` components from fspy-tracked paths
+                // (e.g., `packages/sub-pkg/../shared/dist/output.js`).
+                let absolute = path_clean::PathClean::clean(base_dir.join(path).as_path());
+                !is_excluded(&absolute, &resolved_negatives)
             })
             .map(|(relative_path, path_read)| {
                 let full_path = Arc::<AbsolutePath>::from(base_dir.join(relative_path));

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

@@ -10,15 +10,63 @@ use std::{
     io::{self, Read},
 };
 
-use vite_glob::GlobPatternSet;
+use path_clean::PathClean;
 #[cfg(test)]
 use vite_path::AbsolutePathBuf;
 use vite_path::{AbsolutePath, RelativePathBuf};
 use vite_str::Str;
-use wax::{Glob, walk::Entry as _};
+use wax::{Glob, Program as _};
+
+/// A negative glob pattern resolved to an absolute base directory and optional variant.
+///
+/// For example, `../shared/dist/**` relative to `/ws/packages/app` resolves to:
+/// - `resolved_base`: `/ws/packages/shared/dist`
+/// - `variant`: `Some(Glob("**"))`
+#[expect(clippy::disallowed_types, reason = "path_clean returns std::path::PathBuf")]
+pub struct ResolvedNegativeGlob {
+    resolved_base: std::path::PathBuf,
+    variant: Option<Glob<'static>>,
+}
+
+/// Resolve negative globs relative to `base_dir`, handling `..` components.
+///
+/// Uses [`Glob::partition`] to split each pattern into an invariant base and an
+/// optional variant, then resolves the base with [`path_clean`] to normalize `..`.
+pub fn resolve_negative_globs(
+    patterns: &std::collections::BTreeSet<Str>,
+    base_dir: &AbsolutePath,
+) -> anyhow::Result<Vec<ResolvedNegativeGlob>> {
+    patterns
+        .iter()
+        .map(|pattern| {
+            let glob = Glob::new(pattern.as_str())?.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()
+            };
+            Ok(ResolvedNegativeGlob { resolved_base, variant: variant.map(Glob::into_owned) })
+        })
+        .collect()
+}
+
+/// Check if an absolute path is excluded by any of the resolved negative globs.
+#[expect(clippy::disallowed_types, reason = "matching against std::path::Path from wax walker")]
+pub fn is_excluded(path: &std::path::Path, negatives: &[ResolvedNegativeGlob]) -> bool {
+    negatives.iter().any(|neg| {
+        path.strip_prefix(&neg.resolved_base).ok().is_some_and(|remainder| {
+            neg.variant.as_ref().map_or(remainder.as_os_str().is_empty(), |v| v.is_match(remainder))
+        })
+    })
+}
 
 /// 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).
+///
 /// # Arguments
 /// * `base_dir` - The package directory where the task is defined (globs are relative to this)
 /// * `workspace_root` - The workspace root for computing relative paths in the result
@@ -40,10 +88,7 @@ use wax::{Glob, walk::Entry as _};
 /// )?;
 /// // Returns: { "packages/foo/src/index.ts" => 0x1234..., ... }
 /// ```
-#[expect(
-    clippy::disallowed_methods,
-    reason = "str::replace needed for path normalization; cow_replace unavailable in this crate"
-)]
+#[expect(clippy::disallowed_types, reason = "path_clean and wax walker return std::path types")]
 pub fn compute_globbed_inputs(
     base_dir: &AbsolutePath,
     workspace_root: &AbsolutePath,
@@ -55,44 +100,44 @@ pub fn compute_globbed_inputs(
         return Ok(BTreeMap::new());
     }
 
-    // Build negative pattern matcher if there are negative patterns
-    let negative_patterns: Vec<Str> = negative_globs.iter().cloned().collect();
-    let negative_matcher = if negative_patterns.is_empty() {
-        None
-    } else {
-        Some(GlobPatternSet::new(&negative_patterns)?)
-    };
+    // Resolve negative globs, normalizing `..` components
+    let resolved_negatives = resolve_negative_globs(negative_globs, base_dir)?;
 
     let mut result = BTreeMap::new();
 
-    // Walk each positive glob pattern
+    // Walk each positive glob pattern, resolving `..` via partition + path_clean
     for pattern in positive_globs {
-        let glob = Glob::new(pattern.as_str())?;
-        for entry in glob.walk(base_dir.as_path()) {
-            let Ok(entry) = entry else {
-                continue;
-            };
+        let glob = Glob::new(pattern.as_str())?.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()
+        };
+
+        let entries: Box<dyn Iterator<Item = std::path::PathBuf>> = match variant {
+            Some(variant_glob) => Box::new(
+                variant_glob
+                    .walk(&resolved_base)
+                    .filter_map(Result::ok)
+                    .map(wax::walk::Entry::into_path),
+            ),
+            None => {
+                // No wildcard: exact file path
+                Box::new(std::iter::once(resolved_base))
+            }
+        };
 
+        for absolute_path in entries {
             // Skip non-files
-            if !entry.file_type().is_file() {
+            if !absolute_path.is_file() {
                 continue;
             }
 
-            let absolute_path = entry.path();
-
-            // Compute path relative to base_dir for negative pattern matching
-            let Ok(relative_to_base) = absolute_path.strip_prefix(base_dir.as_path()) else {
-                continue; // Skip if path is outside base_dir
-            };
-
-            // Apply negative patterns (relative to base_dir)
-            if let Some(ref matcher) = negative_matcher {
-                // Convert to forward slashes for consistent matching
-                let path_str = relative_to_base.to_string_lossy();
-                let normalized = path_str.replace('\\', "/");
-                if matcher.is_match(&normalized) {
-                    continue;
-                }
+            // Apply negative patterns
+            if is_excluded(&absolute_path, &resolved_negatives) {
+                continue;
             }
 
             // Compute path relative to workspace_root for the result
@@ -105,7 +150,7 @@ pub fn compute_globbed_inputs(
             };
 
             // Hash file content
-            match hash_file_content(absolute_path) {
+            match hash_file_content(&absolute_path) {
                 Ok(hash) => {
                     result.insert(relative_to_workspace, hash);
                 }
@@ -376,6 +421,62 @@ mod tests {
         assert!(result.is_empty());
     }
 
+    /// Creates a workspace with a sibling package for testing `..` globs
+    fn create_workspace_with_sibling() -> (TempDir, AbsolutePathBuf, AbsolutePathBuf) {
+        let temp_dir = TempDir::new().unwrap();
+        let workspace_root = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
+
+        // Create sub-pkg
+        let sub_pkg = workspace_root.join("packages/sub-pkg");
+        fs::create_dir_all(sub_pkg.join("src")).unwrap();
+        fs::write(sub_pkg.join("src/main.ts"), "export const sub = 1;").unwrap();
+
+        // Create sibling shared package
+        let shared = workspace_root.join("packages/shared");
+        fs::create_dir_all(shared.join("src")).unwrap();
+        fs::create_dir_all(shared.join("dist")).unwrap();
+        fs::write(shared.join("src/utils.ts"), "export const shared = 1;").unwrap();
+        fs::write(shared.join("dist/output.js"), "// output").unwrap();
+
+        let sub_pkg_abs = AbsolutePathBuf::new(sub_pkg.into_path_buf()).unwrap();
+        (temp_dir, workspace_root, sub_pkg_abs)
+    }
+
+    #[test]
+    fn test_dotdot_positive_glob_matches_sibling_package() {
+        let (_temp, workspace, sub_pkg) = create_workspace_with_sibling();
+        let positive: std::collections::BTreeSet<Str> =
+            std::iter::once("../shared/src/**".into()).collect();
+        let negative = std::collections::BTreeSet::new();
+
+        let result = compute_globbed_inputs(&sub_pkg, &workspace, &positive, &negative).unwrap();
+        eprintln!("dotdot positive result: {result:#?}");
+        assert!(
+            result.contains_key(&RelativePathBuf::new("packages/shared/src/utils.ts").unwrap()),
+            "should find sibling package file via ../shared/src/**"
+        );
+    }
+
+    #[test]
+    fn test_dotdot_negative_glob_excludes_from_sibling() {
+        let (_temp, workspace, sub_pkg) = create_workspace_with_sibling();
+        let positive: std::collections::BTreeSet<Str> =
+            std::iter::once("../shared/**".into()).collect();
+        let negative: std::collections::BTreeSet<Str> =
+            std::iter::once("../shared/dist/**".into()).collect();
+
+        let result = compute_globbed_inputs(&sub_pkg, &workspace, &positive, &negative).unwrap();
+        eprintln!("dotdot negative result: {result:#?}");
+        assert!(
+            result.contains_key(&RelativePathBuf::new("packages/shared/src/utils.ts").unwrap()),
+            "should include non-excluded sibling file"
+        );
+        assert!(
+            !result.contains_key(&RelativePathBuf::new("packages/shared/dist/output.js").unwrap()),
+            "should exclude dist via ../shared/dist/**"
+        );
+    }
+
     #[test]
     fn test_overlapping_positive_globs_deduplicates() {
         let (_temp, workspace, package) = create_test_workspace();

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

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

crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-negative-glob-subpackage/packages/shared/package.json

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

crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-negative-glob-subpackage/packages/shared/src/utils.ts

@@ -4,6 +4,21 @@
       "command": "print-file src/main.ts dist/output.js",
       "inputs": [{ "auto": true }, "!dist/**"],
       "cache": true
+    },
+    "dotdot-positive": {
+      "command": "print-file ../shared/src/utils.ts",
+      "inputs": ["../shared/src/**"],
+      "cache": true
+    },
+    "dotdot-positive-negative": {
+      "command": "print-file ../shared/src/utils.ts ../shared/dist/output.js",
+      "inputs": ["../shared/**", "!../shared/dist/**"],
+      "cache": true
+    },
+    "dotdot-auto-negative": {
+      "command": "print-file ../shared/src/utils.ts ../shared/dist/output.js",
+      "inputs": [{ "auto": true }, "!../shared/dist/**"],
+      "cache": true
     }
   }
 }

crates/vite_task_bin/tests/e2e_snapshots/fixtures/inputs-negative-glob-subpackage/packages/sub-pkg/vite-task.json

@@ -27,3 +27,72 @@ steps = [
   # Cache miss: inferred input changed
   "vp run sub-pkg#auto-with-negative",
 ]
+
+# .. prefix positive globs: inputs: ["../shared/src/**"]
+# - Should find files in sibling package via ..
+# - Cache miss when sibling file changes, hit when unrelated file changes
+[[e2e]]
+name = "dotdot positive glob - miss on sibling file change"
+steps = [
+  "vp run sub-pkg#dotdot-positive",
+  # Modify a file that matches ../shared/src/**
+  "replace-file-content packages/shared/src/utils.ts initial modified",
+  # Cache miss: matched file changed
+  "vp run sub-pkg#dotdot-positive",
+]
+
+[[e2e]]
+name = "dotdot positive glob - hit on unmatched file change"
+steps = [
+  "vp run sub-pkg#dotdot-positive",
+  # Modify a file NOT matched by ../shared/src/**
+  "replace-file-content packages/shared/dist/output.js initial modified",
+  # Cache hit: file not in inputs
+  "vp run sub-pkg#dotdot-positive",
+]
+
+# .. prefix positive + negative globs: inputs: ["../shared/**", "!../shared/dist/**"]
+# - Positive glob matches sibling package files via ..
+# - Negative glob excludes sibling dist/ via ..
+[[e2e]]
+name = "dotdot positive negative - miss on non-excluded sibling file"
+steps = [
+  "vp run sub-pkg#dotdot-positive-negative",
+  # Modify file matching positive but NOT negative
+  "replace-file-content packages/shared/src/utils.ts initial modified",
+  # Cache miss: file changed
+  "vp run sub-pkg#dotdot-positive-negative",
+]
+
+[[e2e]]
+name = "dotdot positive negative - hit on excluded sibling file"
+steps = [
+  "vp run sub-pkg#dotdot-positive-negative",
+  # Modify file in excluded sibling dist/
+  "replace-file-content packages/shared/dist/output.js initial modified",
+  # Cache hit: excluded by !../shared/dist/**
+  "vp run sub-pkg#dotdot-positive-negative",
+]
+
+# .. prefix auto + negative: inputs: [{ "auto": true }, "!../shared/dist/**"]
+# - Auto-inferred files from sibling package are tracked
+# - Negative glob excludes sibling dist/ from inferred inputs
+[[e2e]]
+name = "dotdot auto negative - hit on excluded sibling inferred file"
+steps = [
+  "vp run sub-pkg#dotdot-auto-negative",
+  # Modify file in excluded sibling dist/
+  "replace-file-content packages/shared/dist/output.js initial modified",
+  # Cache hit: excluded by !../shared/dist/**
+  "vp run sub-pkg#dotdot-auto-negative",
+]
+
+[[e2e]]
+name = "dotdot auto negative - miss on non-excluded sibling inferred file"
+steps = [
+  "vp run sub-pkg#dotdot-auto-negative",
+  # Modify non-excluded sibling file
+  "replace-file-content packages/shared/src/utils.ts initial modified",
+  # Cache miss: inferred input changed
+  "vp run sub-pkg#dotdot-auto-negative",
+]