refactor: extract ExecutionPlan::plan_query returning ExecutionGraph

Extract the query planning logic from ExecutionPlan::plan into a new
plan_query method that accepts QueryPlanRequest and returns
Result<ExecutionGraph, Error> directly. Session::plan_from_cli now
returns ExecutionGraph instead of ExecutionPlan, and callers wrap it
via the new ExecutionPlan::from_execution_graph constructor.

Also narrows RunCommand::into_plan_request to into_query_plan_request,
since it always produced a Query variant.

Author: branchseer

crates/vite_task/src/cli/mod.rs

@@ -4,7 +4,7 @@ use clap::Parser;
 use vite_path::AbsolutePath;
 use vite_str::Str;
 use vite_task_graph::{TaskSpecifier, query::TaskQueryKind};
-use vite_task_plan::plan_request::{PlanOptions, PlanRequest, QueryPlanRequest};
+use vite_task_plan::plan_request::{PlanOptions, QueryPlanRequest};
 
 #[derive(Debug, Clone, clap::Subcommand)]
 pub enum CacheSubcommand {
@@ -70,16 +70,16 @@ pub enum CLITaskQueryError {
 }
 
 impl RunCommand {
-    /// Convert to `PlanRequest`, or return an error if invalid.
+    /// Convert to `QueryPlanRequest`, or return an error if invalid.
     ///
     /// # Errors
     ///
     /// Returns an error if `--recursive` and `--transitive` are both set,
     /// or if a package name is specified with `--recursive`.
-    pub fn into_plan_request(
+    pub fn into_query_plan_request(
         self,
         cwd: &Arc<AbsolutePath>,
-    ) -> Result<PlanRequest, CLITaskQueryError> {
+    ) -> Result<QueryPlanRequest, CLITaskQueryError> {
         let Self {
             task_specifier,
             flags: RunFlags { recursive, transitive, ignore_depends_on },
@@ -110,9 +110,9 @@ impl RunCommand {
                 include_topological_deps: transitive,
             }
         };
-        Ok(PlanRequest::Query(QueryPlanRequest {
+        Ok(QueryPlanRequest {
             query: vite_task_graph::query::TaskQuery { kind: query_kind, include_explicit_deps },
             plan_options: PlanOptions { extra_args: additional_args.into() },
-        }))
+        })
     }
 }

crates/vite_task/src/session/mod.rs

@@ -21,7 +21,7 @@ use vite_task_graph::{
     loader::UserConfigLoader,
 };
 use vite_task_plan::{
-    ExecutionPlan, TaskGraphLoader, TaskPlanErrorKind,
+    ExecutionGraph, ExecutionPlan, TaskGraphLoader, TaskPlanErrorKind,
     plan_request::{PlanRequest, ScriptCommand, SyntheticPlanRequest},
     prepend_path_env,
 };
@@ -102,15 +102,17 @@ impl vite_task_plan::PlanRequestParser for PlanRequestParser<'_> {
                 Command::Cache { .. } => Ok(Some(PlanRequest::Synthetic(
                     command.to_synthetic_plan_request(UserCacheConfig::disabled()),
                 ))),
-                Command::Run(run_command) => match run_command.into_plan_request(&command.cwd) {
-                    Ok(plan_request) => Ok(Some(plan_request)),
-                    Err(crate::cli::CLITaskQueryError::MissingTaskSpecifier) => {
-                        Ok(Some(PlanRequest::Synthetic(
-                            command.to_synthetic_plan_request(UserCacheConfig::disabled()),
-                        )))
+                Command::Run(run_command) => {
+                    match run_command.into_query_plan_request(&command.cwd) {
+                        Ok(query_plan_request) => Ok(Some(PlanRequest::Query(query_plan_request))),
+                        Err(crate::cli::CLITaskQueryError::MissingTaskSpecifier) => {
+                            Ok(Some(PlanRequest::Synthetic(
+                                command.to_synthetic_plan_request(UserCacheConfig::disabled()),
+                            )))
+                        }
+                        Err(err) => Err(err.into()),
                     }
-                    Err(err) => Err(err.into()),
-                },
+                }
             },
             HandledCommand::Verbatim => Ok(None),
         }
@@ -238,7 +240,7 @@ impl<'a> Session<'a> {
                 let additional_args = run_command.additional_args.clone();
 
                 match self.plan_from_cli(cwd, run_command).await {
-                    Ok(plan) if plan.is_empty() => {
+                    Ok(ref graph) if graph.node_count() == 0 => {
                         // No tasks matched the query — show task selector / "did you mean"
                         self.handle_no_task(
                             is_interactive,
@@ -248,7 +250,8 @@ impl<'a> Session<'a> {
                         )
                         .await
                     }
-                    Ok(plan) => {
+                    Ok(graph) => {
+                        let plan = ExecutionPlan::from_execution_graph(graph);
                         let reporter =
                             LabeledReporter::new(std::io::stdout(), self.workspace_path());
                         Ok(self
@@ -398,7 +401,8 @@ impl<'a> Session<'a> {
             RunCommand { task_specifier: Some(task_specifier), flags, additional_args };
 
         let cwd = Arc::clone(&self.cwd);
-        let plan = self.plan_from_cli(cwd, run_command).await?;
+        let graph = self.plan_from_cli(cwd, run_command).await?;
+        let plan = ExecutionPlan::from_execution_graph(graph);
         let reporter = LabeledReporter::new(std::io::stdout(), self.workspace_path());
         Ok(self.execute(plan, Box::new(reporter)).await.err().unwrap_or(ExitStatus::SUCCESS))
     }
@@ -480,9 +484,9 @@ impl<'a> Session<'a> {
         &mut self,
         cwd: Arc<AbsolutePath>,
         command: RunCommand,
-    ) -> Result<ExecutionPlan, vite_task_plan::Error> {
-        let plan_request = match command.into_plan_request(&cwd) {
-            Ok(plan_request) => plan_request,
+    ) -> Result<ExecutionGraph, vite_task_plan::Error> {
+        let query_plan_request = match command.into_query_plan_request(&cwd) {
+            Ok(query_plan_request) => query_plan_request,
             Err(crate::cli::CLITaskQueryError::MissingTaskSpecifier) => {
                 return Err(TaskPlanErrorKind::MissingTaskSpecifier.with_empty_call_stack());
             }
@@ -496,15 +500,14 @@ impl<'a> Session<'a> {
                 .with_empty_call_stack());
             }
         };
-        let plan = ExecutionPlan::plan(
-            plan_request,
+        ExecutionPlan::plan_query(
+            query_plan_request,
             &self.workspace_path,
             &cwd,
             &self.envs,
             &mut self.plan_request_parser,
             &mut self.lazy_task_graph,
         )
-        .await?;
-        Ok(plan)
+        .await
     }
 }

crates/vite_task_plan/src/lib.rs

@@ -13,11 +13,11 @@ use std::{collections::BTreeMap, ffi::OsStr, fmt::Debug, sync::Arc};
 use context::PlanContext;
 use error::TaskPlanErrorKindResultExt;
 pub use error::{Error, TaskPlanErrorKind};
-use execution_graph::ExecutionGraph;
+pub use execution_graph::ExecutionGraph;
 use in_process::InProcessExecution;
 pub use path_env::{get_path_env, prepend_path_env};
 use plan::{ParentCacheConfig, plan_query_request, plan_synthetic_request};
-use plan_request::{PlanRequest, SyntheticPlanRequest};
+use plan_request::{PlanRequest, QueryPlanRequest, SyntheticPlanRequest};
 use rustc_hash::FxHashMap;
 use serde::{Serialize, ser::SerializeMap as _};
 use vite_graph_ser::serialize_by_key;
@@ -201,6 +201,41 @@ impl ExecutionPlan {
         }
     }
 
+    /// Create an execution plan from an execution graph.
+    #[must_use]
+    pub const fn from_execution_graph(execution_graph: ExecutionGraph) -> Self {
+        Self { root_node: ExecutionItemKind::Expanded(execution_graph) }
+    }
+
+    /// Plan a query execution: load the task graph, query it, and build the execution graph.
+    ///
+    /// # Errors
+    /// Returns an error if task graph loading, query, or execution planning fails.
+    #[expect(clippy::future_not_send, reason = "PlanRequestParser and TaskGraphLoader are !Send")]
+    pub async fn plan_query(
+        query_plan_request: QueryPlanRequest,
+        workspace_path: &Arc<AbsolutePath>,
+        cwd: &Arc<AbsolutePath>,
+        envs: &FxHashMap<Arc<OsStr>, Arc<OsStr>>,
+        plan_request_parser: &mut (dyn PlanRequestParser + '_),
+        task_graph_loader: &mut (dyn TaskGraphLoader + '_),
+    ) -> Result<ExecutionGraph, Error> {
+        let indexed_task_graph = task_graph_loader
+            .load_task_graph()
+            .await
+            .map_err(TaskPlanErrorKind::TaskGraphLoadError)
+            .with_empty_call_stack()?;
+
+        let context = PlanContext::new(
+            workspace_path,
+            Arc::clone(cwd),
+            envs.clone(),
+            plan_request_parser,
+            indexed_task_graph,
+        );
+        plan_query_request(query_plan_request, context).await
+    }
+
     /// Plan an execution from a plan request.
     ///
     /// # Errors
@@ -216,20 +251,15 @@ impl ExecutionPlan {
     ) -> Result<Self, Error> {
         let root_node = match plan_request {
             PlanRequest::Query(query_plan_request) => {
-                let indexed_task_graph = task_graph_loader
-                    .load_task_graph()
-                    .await
-                    .map_err(TaskPlanErrorKind::TaskGraphLoadError)
-                    .with_empty_call_stack()?;
-
-                let context = PlanContext::new(
+                let execution_graph = Self::plan_query(
+                    query_plan_request,
                     workspace_path,
-                    Arc::clone(cwd),
-                    envs.clone(),
+                    cwd,
+                    envs,
                     plan_request_parser,
-                    indexed_task_graph,
-                );
-                let execution_graph = plan_query_request(query_plan_request, context).await?;
+                    task_graph_loader,
+                )
+                .await?;
                 ExecutionItemKind::Expanded(execution_graph)
             }
             PlanRequest::Synthetic(synthetic_plan_request) => {

crates/vite_task_plan/tests/plan_snapshots/main.rs

@@ -11,6 +11,7 @@ use tokio::runtime::Runtime;
 use vite_path::{AbsolutePath, AbsolutePathBuf, RelativePathBuf};
 use vite_str::Str;
 use vite_task::{Command, Session};
+use vite_task_plan::ExecutionPlan;
 use vite_workspace::find_workspace_root;
 
 /// Local parser wrapper for `BuiltInCommand`
@@ -183,7 +184,7 @@ fn run_case_inner(
                 session.plan_from_cli(workspace_root.path.join(plan.cwd).into(), run_command).await;
 
             let plan = match plan_result {
-                Ok(plan) => plan,
+                Ok(graph) => ExecutionPlan::from_execution_graph(graph),
                 Err(err) => {
                     #[expect(
                         clippy::disallowed_macros,