refactor: detect empty plan instead of erroring in query_tasks when no tasks match

Author: branchseer

crates/vite_task/src/session/mod.rs

@@ -232,11 +232,22 @@ impl<'a> Session<'a> {
                 let is_interactive =
                     std::io::stdin().is_terminal() && std::io::stdout().is_terminal();
 
-                // Copy flags before consuming run_command
+                // Save task name and flags before consuming run_command
+                let task_name = run_command.task_specifier.as_ref().map(|s| s.task_name.clone());
                 let flags = run_command.flags;
                 let additional_args = run_command.additional_args.clone();
 
                 match self.plan_from_cli(cwd, run_command).await {
+                    Ok(plan) if plan.is_empty() => {
+                        // No tasks matched the query — show task selector / "did you mean"
+                        self.handle_no_task(
+                            is_interactive,
+                            task_name.as_deref(),
+                            flags,
+                            additional_args,
+                        )
+                        .await
+                    }
                     Ok(plan) => {
                         let reporter =
                             LabeledReporter::new(std::io::stdout(), self.workspace_path());

crates/vite_task_graph/src/query/mod.rs

@@ -61,9 +61,6 @@ pub enum TaskQueryError {
         #[source]
         lookup_error: SpecifierLookupError<PackageUnknownError>,
     },
-
-    #[error("No packages have a task named '{task_name}'")]
-    RecursiveTaskNotFound { task_name: Str },
 }
 
 impl IndexedTaskGraph {
@@ -138,24 +135,11 @@ impl IndexedTaskGraph {
             }
             TaskQueryKind::Recursive { task_names } => {
                 // Add all tasks matching the names across all packages
-                let mut matched_names = FxHashSet::<&str>::with_capacity_and_hasher(
-                    task_names.len(),
-                    rustc_hash::FxBuildHasher,
-                );
                 for task_index in self.task_graph.node_indices() {
                     let current_task_name =
                         self.task_graph[task_index].task_display.task_name.as_str();
                     if task_names.contains(current_task_name) {
                         execution_graph.add_node(task_index);
-                        matched_names.insert(current_task_name);
-                    }
-                }
-                // Return an error if any requested task name was not found in any package
-                for task_name in &task_names {
-                    if !matched_names.contains(task_name.as_str()) {
-                        return Err(TaskQueryError::RecursiveTaskNotFound {
-                            task_name: task_name.clone(),
-                        });
                     }
                 }
             }

crates/vite_task_plan/src/error.rs

@@ -185,9 +185,6 @@ impl Error {
             TaskPlanErrorKind::TaskQueryError(
                 vite_task_graph::query::TaskQueryError::SpecifierLookupError { specifier, .. },
             ) => Some(specifier.task_name.as_str()),
-            TaskPlanErrorKind::TaskQueryError(
-                vite_task_graph::query::TaskQueryError::RecursiveTaskNotFound { task_name },
-            ) => Some(task_name.as_str()),
             _ => None,
         }
     }

crates/vite_task_plan/src/lib.rs

@@ -192,6 +192,15 @@ impl ExecutionPlan {
         &self.root_node
     }
 
+    /// Returns `true` if the plan contains no tasks to execute.
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        match &self.root_node {
+            ExecutionItemKind::Expanded(graph) => graph.node_count() == 0,
+            ExecutionItemKind::Leaf(_) => false,
+        }
+    }
+
     /// Plan an execution from a plan request.
     ///
     /// # Errors