feat: filter packages with --filter (#176)

## Summary

Add pnpm-compatible `--filter` flag to `vp run` for selecting which
packages to run tasks in.

Supports:
- **Package name**: exact (`--filter @test/app`) and glob (`--filter
@test/*`)
- **Directory**: exact (`--filter ./packages/app`), glob (`--filter
./packages/*`), relative (`.`, `..`)
- **Braced paths**: `{./path}` for traversal on paths, `name{./dir}` for
name + directory intersection
- **Dependency traversal**: `foo...` (dependencies), `...foo`
(dependents), `^` to exclude self, `...foo...` (both)
- **Exclusion**: `!foo` to exclude packages from the result
- **Multiple filters**: `--filter a --filter b` (union); `--filter "a
b"` (whitespace split, pnpm compat)
- **`-w` / `--workspace-root`**: select workspace root; additive with
`--filter`, redundant with `-r`, supports `-t` for root + transitive
deps
- **Nested expansion**: `vp run --filter .... build` inside package
scripts is expanded in the plan

### Architecture: `PackageQueryArgs` → `PackageQuery` →
`FilterResolution`

Package selection lives in `vite_workspace`, not in the task runner. Any
command that needs to pick packages can reuse it.

**Step 1 — Parse CLI flags into a query.**

`PackageQueryArgs` is a clap struct with `-r`, `-t`, `-w`, and
`--filter`. Embed it via `#[clap(flatten)]`, then call
`into_package_query()`:

```rust
// in any command definition (e.g. `vp exec`, `vp run`)
#[derive(clap::Args)]
struct MyCommand {
    #[clap(flatten)]
    packages: PackageQueryArgs,
}

// at runtime — package_name comes from `pkg#task` syntax (e.g. "app" in `vp run app#build`).
// commands that don't use `pkg#task` (like `vp exec`) pass None.
let query: PackageQuery = args.packages.into_package_query(package_name, &cwd)?;
```

`into_package_query` validates flag combinations (e.g. `--filter` + `-r`
is an error), splits whitespace, parses each `--filter` token, and
returns an opaque `PackageQuery`.

**Step 2 — Resolve the query against the package graph.**

```rust
let resolution: FilterResolution = indexed_package_graph.resolve_query(&query);
// resolution.package_subgraph  — the selected packages + edges between them
// resolution.unmatched_selectors — filter strings that matched nothing (for warnings)
```

`PackageQuery` is opaque — callers don't inspect its internals. They
just pass it to `resolve_query` and get back the selected subgraph.

Future commands like `vp exec` only need steps 1 and 2 — they get the
selected packages without depending on the task graph at all.

**Step 3 (task runner only) — Map packages to tasks.**

The task-graph layer maps the package subgraph to task nodes,
reconnecting across packages that lack the requested task. Only `vp run`
needs this step.

### `unmatched_selectors` tracks original filter strings

Each `--filter` token is stored as a `source: Option<Str>` inside the
parsed filter. Synthetic filters (implicit cwd, `-w`) get `source: None`
since the user didn't type them. When a filter matches nothing,
`resolve_query` collects the original string into `unmatched_selectors:
Vec<Str>` so the caller can show a warning like:

```
warn: --filter "typo-pkg" matched no packages
```

This works correctly even with whitespace splitting (`--filter "a b"` →
two filters, each with its own source string).

## Test plan

- [x] 48 unit tests in `package_filter` for `parse_filter`,
`into_package_query`, `resolve_directory_pattern`, and source tracking —
covering all selector types, traversal modes, flag combinations, path
normalization, and error cases
- [x] 40 plan snapshot tests across `filter-workspace` (35) and
`transitive-skip-intermediate` (5) fixtures
- [x] Existing plan and e2e snapshot tests still pass

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: branchseer

Cargo.lock

@@ -91,6 +91,7 @@ os_str_bytes = "7.1.1"
 ouroboros = "0.18.5"
 owo-colors = { version = "4.1.0", features = ["supports-colors"] }
 passfd = { git = "https://github.com/polachok/passfd", rev = "d55881752c16aced1a49a75f9c428d38d3767213", default-features = false }
+path-clean = "1.0.1"
 pathdiff = "0.2.3"
 petgraph = "0.8.2"
 phf = { version = "0.11.3", features = ["macros"] }
@@ -145,7 +146,7 @@ vite_task_graph = { path = "crates/vite_task_graph" }
 vite_task_plan = { path = "crates/vite_task_plan" }
 vite_workspace = { path = "crates/vite_workspace" }
 vt100 = "0.16.2"
-wax = "0.6.0"
+wax = "0.7.0"
 which = "8.0.0"
 widestring = "1.2.0"
 winapi = "0.3.9"

Cargo.toml

@@ -4,7 +4,7 @@ mod error;
 use std::path::Path;
 
 pub use error::Error;
-use wax::{Glob, Pattern};
+use wax::{Glob, Program};
 
 /// If there are no negated patterns, it will follow the first match wins semantics.
 /// Otherwise, it will follow the last match wins semantics.

crates/vite_glob/src/lib.rs

@@ -17,17 +17,19 @@ pub trait GetKey {
 }
 
 #[derive(Serialize)]
-#[serde(bound = "E: Serialize, N: Serialize")]
-struct DiGraphNodeItem<'a, N: GetKey, E> {
+#[serde(bound = "N: Serialize")]
+struct DiGraphNodeItem<'a, N: GetKey> {
     key: N::Key<'a>,
     node: &'a N,
-    neighbors: Vec<(N::Key<'a>, &'a E)>,
+    neighbors: Vec<N::Key<'a>>,
 }
 
 /// A wrapper around `DiGraph` that serializes nodes by their keys.
+///
+/// Only node connectivity is recorded — edge weights are ignored in the output.
 #[derive(Serialize)]
 #[serde(transparent)]
-pub struct SerializeByKey<'a, N: GetKey + Serialize, E: Serialize, Ix: petgraph::graph::IndexType>(
+pub struct SerializeByKey<'a, N: GetKey + Serialize, E, Ix: petgraph::graph::IndexType>(
     #[serde(serialize_with = "serialize_by_key")] pub &'a DiGraph<N, E, Ix>,
 );
 
@@ -45,25 +47,20 @@ pub struct SerializeByKey<'a, N: GetKey + Serialize, E: Serialize, Ix: petgraph:
 ///
 /// # Panics
 /// Panics if an edge references a node index not present in the graph.
-pub fn serialize_by_key<
-    N: GetKey + Serialize,
-    E: Serialize,
-    Ix: petgraph::graph::IndexType,
-    S: Serializer,
->(
+pub fn serialize_by_key<N: GetKey + Serialize, E, Ix: petgraph::graph::IndexType, S: Serializer>(
     graph: &DiGraph<N, E, Ix>,
     serializer: S,
 ) -> Result<S::Ok, S::Error> {
-    let mut items = Vec::<DiGraphNodeItem<'_, N, E>>::with_capacity(graph.node_count());
+    let mut items = Vec::<DiGraphNodeItem<'_, N>>::with_capacity(graph.node_count());
     for (node_idx, node) in graph.node_references() {
-        let mut neighbors = Vec::<(N::Key<'_>, &E)>::new();
+        let mut neighbors = Vec::<N::Key<'_>>::new();
 
         for edge in graph.edges(node_idx) {
             let target_idx = edge.target();
             let target_node = graph.node_weight(target_idx).unwrap();
-            neighbors.push((target_node.key().map_err(serde::ser::Error::custom)?, edge.weight()));
+            neighbors.push(target_node.key().map_err(serde::ser::Error::custom)?);
         }
-        neighbors.sort_unstable_by(|a, b| a.0.cmp(&b.0));
+        neighbors.sort_unstable();
         items.push(DiGraphNodeItem {
             key: node.key().map_err(serde::ser::Error::custom)?,
             node,
@@ -101,19 +98,19 @@ mod tests {
     #[derive(Serialize)]
     struct GraphWrapper {
         #[serde(serialize_with = "serialize_by_key")]
-        graph: DiGraph<TestNode, &'static str>,
+        graph: DiGraph<TestNode, ()>,
     }
 
     #[test]
     fn test_serialize_graph_happy_path() {
-        let mut graph = DiGraph::<TestNode, &'static str>::new();
+        let mut graph = DiGraph::<TestNode, ()>::new();
         let a = graph.add_node(TestNode { id: "a", value: 1 });
         let b = graph.add_node(TestNode { id: "b", value: 2 });
         let c = graph.add_node(TestNode { id: "c", value: 3 });
 
-        graph.add_edge(a, b, "a->b");
-        graph.add_edge(a, c, "a->c");
-        graph.add_edge(b, c, "b->c");
+        graph.add_edge(a, b, ());
+        graph.add_edge(a, c, ());
+        graph.add_edge(b, c, ());
 
         let json = serde_json::to_value(GraphWrapper { graph }).unwrap();
         assert_eq!(
@@ -123,12 +120,12 @@ mod tests {
                     {
                         "key": "a",
                         "node": {"id": "a", "value": 1},
-                        "neighbors": [["b", "a->b"], ["c", "a->c"]]
+                        "neighbors": ["b", "c"]
                     },
                     {
                         "key": "b",
                         "node": {"id": "b", "value": 2},
-                        "neighbors": [["c", "b->c"]]
+                        "neighbors": ["c"]
                     },
                     {
                         "key": "c",