refactor: address review comments on task runner summary

- Make --last-details exclusive at type level by splitting Command into
  ParsedCommand (clap) and Command (resolved with RunLastDetails variant)
- Use ? to propagate IO errors in show_last_run_details
- Replace summary_file_path with write_summary callback to decouple
  reporter from file paths
- Remove ExecutionInfo/ExecutionStats, build TaskSummary directly in
  leaf reporter's finish() instead of collecting intermediate state
- Add .gitignore to oxlint fixtures to prevent fspy from fingerprinting
  the cache directory, fixing flaky cache-miss snapshots

Author: branchseer

crates/vite_task/src/cli/mod.rs

@@ -36,36 +36,100 @@ pub struct RunFlags {
     pub details: bool,
 }
 
-/// Arguments for the `run` subcommand.
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Clap-parsed types (used only at the parsing boundary)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/// Arguments for the `run` subcommand as parsed by clap.
+///
+/// Contains the `--last-details` flag which is resolved into a separate
+/// [`Command::RunLastDetails`] variant via [`ParsedCommand::into_command`].
 #[derive(Debug, clap::Args)]
-pub struct RunCommand {
+pub struct ParsedRunCommand {
     /// `packageName#taskName` or `taskName`. If omitted, lists all available tasks.
-    pub task_specifier: Option<TaskSpecifier>,
+    task_specifier: Option<TaskSpecifier>,
 
     #[clap(flatten)]
-    pub flags: RunFlags,
+    flags: RunFlags,
 
     /// Additional arguments to pass to the tasks
     #[clap(trailing_var_arg = true, allow_hyphen_values = true)]
-    pub additional_args: Vec<Str>,
+    additional_args: Vec<Str>,
 
     /// Display the detailed summary of the last run.
     #[clap(long, exclusive = true)]
-    pub last_details: bool,
+    last_details: bool,
 }
 
-/// vite task CLI subcommands
+/// vite task CLI subcommands as parsed by clap.
+///
+/// Use [`ParsedCommand::into_command`] to resolve into the dispatched [`Command`]
+/// enum, which makes `--last-details` exclusive at the type level.
 #[derive(Debug, Parser)]
-pub enum Command {
+pub enum ParsedCommand {
     /// Run tasks
-    Run(RunCommand),
+    Run(ParsedRunCommand),
     /// Manage the task cache
     Cache {
         #[clap(subcommand)]
         subcmd: CacheSubcommand,
     },
 }
 
+impl ParsedCommand {
+    /// Resolve the clap-parsed command into the dispatched [`Command`] enum.
+    ///
+    /// When `--last-details` is set on the `run` subcommand, this produces
+    /// [`Command::RunLastDetails`] instead of [`Command::Run`], making the
+    /// exclusivity enforced at the type level.
+    #[must_use]
+    pub fn into_command(self) -> Command {
+        match self {
+            Self::Run(run) if run.last_details => Command::RunLastDetails,
+            Self::Run(run) => Command::Run(RunCommand {
+                task_specifier: run.task_specifier,
+                flags: run.flags,
+                additional_args: run.additional_args,
+            }),
+            Self::Cache { subcmd } => Command::Cache { subcmd },
+        }
+    }
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// Resolved types (used for dispatch — `--last-details` is a separate variant)
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/// Resolved CLI command for dispatch.
+///
+/// Unlike [`ParsedCommand`], this enum makes `--last-details` a separate variant
+/// ([`Command::RunLastDetails`]) so that it is exclusive at the type level —
+/// there is no way to combine it with task execution fields.
+#[derive(Debug)]
+pub enum Command {
+    /// Run tasks with the given parameters.
+    Run(RunCommand),
+    /// Display the saved detailed summary of the last run (`--last-details`).
+    RunLastDetails,
+    /// Manage the task cache.
+    Cache { subcmd: CacheSubcommand },
+}
+
+/// Resolved arguments for executing tasks.
+///
+/// Does not contain `last_details` — that case is represented by
+/// [`Command::RunLastDetails`] instead.
+#[derive(Debug)]
+pub struct RunCommand {
+    /// `packageName#taskName` or `taskName`. If omitted, lists all available tasks.
+    pub task_specifier: Option<TaskSpecifier>,
+
+    pub flags: RunFlags,
+
+    /// Additional arguments to pass to the tasks.
+    pub additional_args: Vec<Str>,
+}
+
 #[derive(thiserror::Error, Debug)]
 pub enum CLITaskQueryError {
     #[error("no task specifier provided")]
@@ -93,7 +157,6 @@ impl RunCommand {
             task_specifier,
             flags: RunFlags { recursive, transitive, ignore_depends_on, .. },
             additional_args,
-            ..
         } = self;
 
         let task_specifier = task_specifier.ok_or(CLITaskQueryError::MissingTaskSpecifier)?;

crates/vite_task/src/lib.rs

@@ -4,7 +4,7 @@ mod maybe_str;
 pub mod session;
 
 // Public exports for vite_task_bin
-pub use cli::{CacheSubcommand, Command, RunCommand, RunFlags};
+pub use cli::{CacheSubcommand, Command, ParsedCommand, RunCommand, RunFlags};
 pub use session::{CommandHandler, ExitStatus, HandledCommand, Session, SessionCallbacks};
 pub use vite_task_graph::{
     config::{

crates/vite_task/src/session/mod.rs

@@ -101,9 +101,11 @@ impl vite_task_plan::PlanRequestParser for PlanRequestParser<'_> {
         match self.command_handler.handle_command(command).await? {
             HandledCommand::Synthesized(synthetic) => Ok(Some(PlanRequest::Synthetic(synthetic))),
             HandledCommand::ViteTaskCommand(cli_command) => match cli_command {
-                Command::Cache { .. } => Ok(Some(PlanRequest::Synthetic(
-                    command.to_synthetic_plan_request(UserCacheConfig::disabled()),
-                ))),
+                Command::Cache { .. } | Command::RunLastDetails => {
+                    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))),
@@ -227,12 +229,8 @@ impl<'a> Session<'a> {
     pub async fn main(mut self, command: Command) -> anyhow::Result<ExitStatus> {
         match command {
             Command::Cache { ref subcmd } => self.handle_cache_command(subcmd),
+            Command::RunLastDetails => self.show_last_run_details(),
             Command::Run(run_command) => {
-                // --last-details: display saved summary and exit (exclusive flag)
-                if run_command.last_details {
-                    return self.show_last_run_details();
-                }
-
                 let cwd = Arc::clone(&self.cwd);
                 let is_interactive =
                     std::io::stdin().is_terminal() && std::io::stdout().is_terminal();
@@ -259,7 +257,7 @@ impl<'a> Session<'a> {
                             self.workspace_path(),
                             Box::new(tokio::io::stdout()),
                             show_details,
-                            Some(self.summary_file_path()),
+                            Some(self.make_summary_writer()),
                         );
                         Ok(self
                             .execute_graph(graph, Box::new(builder))
@@ -401,20 +399,16 @@ impl<'a> Session<'a> {
         let selected_label = &select_items[selected_index].label;
         let task_specifier = TaskSpecifier::parse_raw(selected_label);
         let show_details = flags.details;
-        let run_command = RunCommand {
-            task_specifier: Some(task_specifier),
-            flags,
-            additional_args,
-            last_details: false,
-        };
+        let run_command =
+            RunCommand { task_specifier: Some(task_specifier), flags, additional_args };
 
         let cwd = Arc::clone(&self.cwd);
         let graph = self.plan_from_cli_run(cwd, run_command).await?;
         let builder = LabeledReporterBuilder::new(
             self.workspace_path(),
             Box::new(tokio::io::stdout()),
             show_details,
-            Some(self.summary_file_path()),
+            Some(self.make_summary_writer()),
         );
         Ok(self.execute_graph(graph, Box::new(builder)).await.err().unwrap_or(ExitStatus::SUCCESS))
     }
@@ -439,6 +433,19 @@ impl<'a> Session<'a> {
         self.cache_path.join("last-summary.json")
     }
 
+    /// Create a callback that persists the summary to `last-summary.json`.
+    ///
+    /// The returned closure captures the file path and handles errors internally
+    /// (logging failures without propagating).
+    fn make_summary_writer(&self) -> Box<dyn FnOnce(&LastRunSummary)> {
+        let path = self.summary_file_path();
+        Box::new(move |summary: &LastRunSummary| {
+            if let Err(err) = summary.write_atomic(&path) {
+                tracing::warn!("Failed to write summary to {path:?}: {err}");
+            }
+        })
+    }
+
     /// Display the saved summary from the last run (`--last-details`).
     #[expect(
         clippy::print_stderr,
@@ -452,8 +459,8 @@ impl<'a> Session<'a> {
                 {
                     use std::io::Write;
                     let mut stdout = std::io::stdout().lock();
-                    let _ = stdout.write_all(&buf);
-                    let _ = stdout.flush();
+                    stdout.write_all(&buf)?;
+                    stdout.flush()?;
                 }
                 Ok(ExitStatus(summary.exit_code))
             }