feat: exit 0 on --filter no-match, add --fail-if-no-match (#393)

## Summary

- Match pnpm: `vp run --filter <expr>` now exits **0** with a warning
when the expression matches no packages, instead of failing with `Task
"X" not found`.
- This also covers `--filter {.}^...` on a leaf package: the seed
matches but the traversal collapses to zero, a legitimate no-op rather
than a typo.
- Add `--fail-if-no-match` for callers (CI scripts) that want the
previous strict behaviour. In strict mode, any unmatched `--filter`
aborts the run, even when other filters did match.

## Implementation notes

- `unmatched_selectors` now tracks filters whose expanded set is empty
(was: whose core selector matched nothing), so traversal collapses are
reported too.
- `TaskQueryResult` exposes `selected_package_count` and `plan_query`
returns a `PlanResult { graph, no_packages_matched }` so the CLI can
distinguish "no packages matched filter" (succeed) from "packages
matched but task missing" (still errors as `NoTasksMatched`).
- Nested `vp run --filter X build` inside a task script gets the same
default-success treatment.

Closes #380

---------

Co-authored-by: branchseer <dk4rest@gmail.com>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 3 people

crates/vite_task/src/cli/mod.rs

@@ -217,6 +217,8 @@ impl ResolvedRunCommand {
         let include_explicit_deps = !self.flags.ignore_depends_on;
         let concurrency_limit = self.flags.concurrency_limit.map(|n| n.max(1));
         let parallel = self.flags.parallel;
+        // Read before `into_package_query` consumes the args.
+        let fail_if_no_match = self.flags.package_query.fail_if_no_match;
 
         let (package_query, is_cwd_only) =
             self.flags.package_query.into_package_query(task_specifier.package_name, cwd)?;
@@ -233,6 +235,7 @@ impl ResolvedRunCommand {
                     cache_override,
                     concurrency_limit,
                     parallel,
+                    fail_if_no_match,
                 },
             },
             is_cwd_only,

crates/vite_task/src/session/mod.rs

@@ -274,14 +274,22 @@ impl<'a> Session<'a> {
                 let graph = if let Some(ref task_specifier) = run_command.task_specifier {
                     // Task specifier provided — plan it.
                     let cwd = Arc::clone(&self.cwd);
-                    let (graph, is_cwd_only) =
+                    let (plan_result, is_cwd_only) =
                         self.plan_from_cli_run_resolved(cwd, run_command.clone()).await?;
 
-                    if graph.graph.node_count() == 0 {
-                        // No tasks matched. Show the interactive selector only when
-                        // the command has no scope flags and no execution flags
-                        // (concurrency-limit, parallel) — otherwise the user intended
-                        // a specific execution mode and a typo should be an error.
+                    if plan_result.graph.graph.node_count() == 0 {
+                        // Three empty-graph outcomes, in order of precedence:
+                        //   1. `--filter` selected zero packages — the planner has
+                        //      already warned per filter; exit 0 silently. This is the
+                        //      pnpm-compatible default; `--fail-if-no-match` opts in
+                        //      to strict behaviour and is raised inside the planner.
+                        //   2. Bare `vp run` (cwd-only, no execution flags) — fall
+                        //      through to the interactive task selector.
+                        //   3. Otherwise (e.g. typoed task, `-r` with no matching
+                        //      package) — surface NoTasksMatched.
+                        if plan_result.no_packages_matched {
+                            return Ok(());
+                        }
                         let has_execution_flags = run_command.flags.concurrency_limit.is_some()
                             || run_command.flags.parallel;
                         if is_cwd_only && !has_execution_flags {
@@ -294,7 +302,7 @@ impl<'a> Session<'a> {
                             .into());
                         }
                     } else {
-                        graph
+                        plan_result.graph
                     }
                 } else {
                     // No task specifier (e.g. `vp run` or `vp run --verbose`).
@@ -563,6 +571,9 @@ impl<'a> Session<'a> {
                 cache_override: run_command.flags.cache_override(),
                 concurrency_limit: None,
                 parallel: false,
+                // The selector path runs whatever the user picked interactively;
+                // there is no `--filter` in play, so strict-mode does not apply.
+                fail_if_no_match: false,
             },
         })
     }
@@ -741,8 +752,9 @@ impl<'a> Session<'a> {
         cwd: Arc<AbsolutePath>,
         command: RunCommand,
     ) -> Result<ExecutionGraph, vite_task_plan::Error> {
-        let (graph, _) = self.plan_from_cli_run_resolved(cwd, command.into_resolved()).await?;
-        Ok(graph)
+        let (plan_result, _) =
+            self.plan_from_cli_run_resolved(cwd, command.into_resolved()).await?;
+        Ok(plan_result.graph)
     }
 
     /// Internal: plans execution from a resolved run command.
@@ -751,7 +763,7 @@ impl<'a> Session<'a> {
         &mut self,
         cwd: Arc<AbsolutePath>,
         command: crate::cli::ResolvedRunCommand,
-    ) -> Result<(ExecutionGraph, bool), vite_task_plan::Error> {
+    ) -> Result<(vite_task_plan::PlanResult, bool), vite_task_plan::Error> {
         let (query_plan_request, is_cwd_only) = match command.into_query_plan_request(&cwd) {
             Ok(result) => result,
             Err(crate::cli::CLITaskQueryError::MissingTaskSpecifier) => {
@@ -766,7 +778,7 @@ impl<'a> Session<'a> {
                 });
             }
         };
-        let graph = vite_task_plan::plan_query(
+        let plan_result = vite_task_plan::plan_query(
             query_plan_request,
             &self.workspace_path,
             &cwd,
@@ -775,7 +787,7 @@ impl<'a> Session<'a> {
             &mut self.lazy_task_graph,
         )
         .await?;
-        Ok((graph, is_cwd_only))
+        Ok((plan_result, is_cwd_only))
     }
 
     /// Plan execution from a pre-built [`QueryPlanRequest`].
@@ -787,15 +799,16 @@ impl<'a> Session<'a> {
         request: QueryPlanRequest,
     ) -> Result<ExecutionGraph, vite_task_plan::Error> {
         let cwd = Arc::clone(&self.cwd);
-        vite_task_plan::plan_query(
+        let plan_result = vite_task_plan::plan_query(
             request,
             &self.workspace_path,
             &cwd,
             &self.envs,
             &mut self.plan_request_parser,
             &mut self.lazy_task_graph,
         )
-        .await
+        .await?;
+        Ok(plan_result.graph)
     }
 }
 

crates/vite_task_bin/tests/e2e_snapshots/fixtures/filter_unmatched/snapshots.toml

@@ -39,3 +39,64 @@ comment = """
 A directory-style `--filter` (`./packages/...`) that points nowhere should warn just like an unmatched name filter.
 """
 steps = [["vt", "run", "--filter", "@test/app", "--filter", "./packages/nope", "build"]]
+
+[[e2e]]
+name = "filter_with_zero_results_exits_zero_by_default"
+comment = """
+A `--filter` whose entire result is empty (typo, glob with no match, …) prints the warning and exits 0 — pnpm's default. Previously this errored with `Task "build" not found`.
+"""
+steps = [["vt", "run", "--filter", "nonexistent", "build"]]
+
+[[e2e]]
+name = "traversal_collapsed_to_empty_exits_zero_by_default"
+comment = """
+`{.}^...` selects the dependencies of the current package, excluding itself. On a leaf with no workspace deps the expression collapses to zero matches — a legitimate no-op rather than a typo — so the run warns and exits 0.
+"""
+cwd = "packages/lib"
+steps = [["vt", "run", "--filter", "{.}^...", "build"]]
+
+[[e2e]]
+name = "fail_if_no_match_errors_on_unmatched_filter"
+comment = """
+With `--fail-if-no-match`, an unmatched `--filter` aborts the run with a non-zero exit code instead of warning. Mirrors pnpm's `--fail-if-no-match`.
+"""
+steps = [["vt", "run", "--filter", "nonexistent", "--fail-if-no-match", "build"]]
+
+[[e2e]]
+name = "fail_if_no_match_errors_even_when_other_filters_match"
+comment = """
+Strict mode errors on **any** unmatched filter, even when other filters did match packages — this catches typos in CI scripts that combine an exact name with a glob.
+"""
+steps = [
+  [
+    "vt",
+    "run",
+    "--filter",
+    "@test/app",
+    "--filter",
+    "nonexistent",
+    "--fail-if-no-match",
+    "build",
+  ],
+]
+
+[[e2e]]
+name = "fail_if_no_match_succeeds_when_all_filters_match"
+comment = """
+With `--fail-if-no-match` and only matching filters, the run proceeds normally — strict mode does not change the success path.
+"""
+steps = [["vt", "run", "--filter", "@test/app", "--fail-if-no-match", "build"]]
+
+[[e2e]]
+name = "nested_filter_no_match_succeeds_by_default"
+comment = """
+The default-success rule must apply to nested `vt run --filter ...` invocations too: a task whose command is `vt run --filter nonexistent build` should exit 0 with the warning, not fail the outer task. Guards the script wrapping that pnpm users typically write.
+"""
+steps = [["vt", "run", "filter-nonexistent"]]
+
+[[e2e]]
+name = "nested_filter_no_match_with_fail_if_no_match_errors"
+comment = """
+Strict mode also propagates through nesting: a task command that adds `--fail-if-no-match` aborts the outer task when the nested filter selects nothing. The error chain identifies both the nested command and the unmatched filter source.
+"""
+steps = [["vt", "run", "filter-nonexistent-strict"]]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/filter_unmatched/snapshots/fail_if_no_match_errors_even_when_other_filters_match.md

@@ -0,0 +1,11 @@
+# fail_if_no_match_errors_even_when_other_filters_match
+
+Strict mode errors on **any** unmatched filter, even when other filters did match packages — this catches typos in CI scripts that combine an exact name with a glob.
+
+## `vt run --filter @test/app --filter nonexistent --fail-if-no-match build`
+
+**Exit code:** 1
+
+```
+error: No packages matched the filter: nonexistent
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/filter_unmatched/snapshots/fail_if_no_match_errors_on_unmatched_filter.md

@@ -0,0 +1,11 @@
+# fail_if_no_match_errors_on_unmatched_filter
+
+With `--fail-if-no-match`, an unmatched `--filter` aborts the run with a non-zero exit code instead of warning. Mirrors pnpm's `--fail-if-no-match`.
+
+## `vt run --filter nonexistent --fail-if-no-match build`
+
+**Exit code:** 1
+
+```
+error: No packages matched the filter: nonexistent
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/filter_unmatched/snapshots/fail_if_no_match_succeeds_when_all_filters_match.md

@@ -0,0 +1,10 @@
+# fail_if_no_match_succeeds_when_all_filters_match
+
+With `--fail-if-no-match` and only matching filters, the run proceeds normally — strict mode does not change the success path.
+
+## `vt run --filter @test/app --fail-if-no-match build`
+
+```
+~/packages/app$ vtt print built-app
+built-app
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/filter_unmatched/snapshots/filter_with_zero_results_exits_zero_by_default.md

@@ -0,0 +1,9 @@
+# filter_with_zero_results_exits_zero_by_default
+
+A `--filter` whose entire result is empty (typo, glob with no match, …) prints the warning and exits 0 — pnpm's default. Previously this errored with `Task "build" not found`.
+
+## `vt run --filter nonexistent build`
+
+```
+No packages matched the filter: nonexistent
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/filter_unmatched/snapshots/nested_filter_no_match_succeeds_by_default.md

@@ -0,0 +1,11 @@
+# nested_filter_no_match_succeeds_by_default
+
+The default-success rule must apply to nested `vt run --filter ...` invocations too: a task whose command is `vt run --filter nonexistent build` should exit 0 with the warning, not fail the outer task. Guards the script wrapping that pnpm users typically write.
+
+## `vt run filter-nonexistent`
+
+```
+No packages matched the filter: nonexistent
+---
+vt run: 0/0 cache hit (0%). (Run `vt run --last-details` for full details)
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/filter_unmatched/snapshots/nested_filter_no_match_with_fail_if_no_match_errors.md

@@ -0,0 +1,12 @@
+# nested_filter_no_match_with_fail_if_no_match_errors
+
+Strict mode also propagates through nesting: a task command that adds `--fail-if-no-match` aborts the outer task when the nested filter selects nothing. The error chain identifies both the nested command and the unmatched filter source.
+
+## `vt run filter-nonexistent-strict`
+
+**Exit code:** 1
+
+```
+error: Failed to plan tasks from `vt run --filter nonexistent --fail-if-no-match build` in task filter-unmatched-test#filter-nonexistent-strict
+* No packages matched the filter: nonexistent
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/filter_unmatched/snapshots/traversal_collapsed_to_empty_exits_zero_by_default.md

@@ -0,0 +1,9 @@
+# traversal_collapsed_to_empty_exits_zero_by_default
+
+`{.}^...` selects the dependencies of the current package, excluding itself. On a leaf with no workspace deps the expression collapses to zero matches — a legitimate no-op rather than a typo — so the run warns and exits 0.
+
+## `vt run --filter {.}^... build`
+
+```
+No packages matched the filter: {.}^...
+```