feat(run): refine outputs & add summary (#157)

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

Author: branchseer

crates/vite_task/src/cache.rs

@@ -2,7 +2,6 @@ use std::{fmt::Display, io::Write, sync::Arc};
 
 // use bincode::config::{Configuration, standard};
 use bincode::{Decode, Encode, decode_from_slice, encode_to_vec};
-use diff::Diff;
 use rusqlite::{Connection, OptionalExtension as _};
 use serde::Serialize;
 use tokio::sync::Mutex;
@@ -11,7 +10,7 @@ use vite_str::Str;
 
 use crate::{
     Error,
-    config::{CommandFingerprint, CommandFingerprintDiff, ResolvedTask, TaskId},
+    config::{CommandFingerprint, ResolvedTask, TaskId},
     execute::{ExecutedTask, StdOutput},
     fingerprint::{PostRunFingerprint, PostRunFingerprintMismatch},
     fs::FileSystem,
@@ -62,7 +61,7 @@ pub enum CacheMiss {
 pub enum FingerprintMismatch {
     /// Found the cache entry of the same task run, but the command fingerprint mismatches
     /// this happens when the command itself or an env changes.
-    CommandFingerprintMismatch(CommandFingerprintDiff),
+    CommandFingerprintMismatch(CommandFingerprint),
     /// Found the cache entry with the same command fingerprint, but the post-run fingerprint mismatches
     PostRunFingerprintMismatch(PostRunFingerprintMismatch),
 }
@@ -156,16 +155,14 @@ impl TaskCache {
                 self.upsert_taskrun_to_command(&task_run_key, command_fingerprint).await?;
                 Ok(Ok(cache_value))
             }
-        } else if let Some(task_run_fingerprint) =
+        } else if let Some(command_fingerprint_in_cache) =
             self.get_command_fingerprint_by_task_run_key(&task_run_key).await?
         {
             // No command cache found with the current command fingerprint,
             // but found a command fingerprint associated with the same task run key,
             // meaning the command or env has changed since last run
             Ok(Err(CacheMiss::FingerprintMismatch(
-                FingerprintMismatch::CommandFingerprintMismatch(
-                    command_fingerprint.diff(&task_run_fingerprint),
-                ),
+                FingerprintMismatch::CommandFingerprintMismatch(command_fingerprint_in_cache),
             )))
         } else {
             Ok(Err(CacheMiss::NotFound))

crates/vite_task/src/config/mod.rs

@@ -93,11 +93,15 @@ impl ResolvedTask {
             task_group_id: TaskGroupId {
                 task_group_name: self.name.task_group_name.clone(),
                 config_path: self.resolved_config.config_dir.clone(),
-                is_builtin: self.name.package_name.is_none(),
+                is_builtin: self.is_builtin(),
             },
         }
     }
 
+    pub fn is_builtin(&self) -> bool {
+        self.name.package_name.is_none()
+    }
+
     pub fn matches(&self, task_request: &str, current_package_path: Option<&RelativePath>) -> bool {
         if self.name.subcommand_index.is_some() {
             // never match non-last subcommand

crates/vite_task/src/schedule.rs

@@ -4,12 +4,12 @@ use futures_core::future::BoxFuture;
 use futures_util::future::FutureExt as _;
 use petgraph::{algo::toposort, stable_graph::StableDiGraph};
 use tokio::io::AsyncWriteExt as _;
-use vite_path::{AbsolutePath, RelativePathBuf};
+use vite_path::AbsolutePath;
 
 use crate::{
     Error,
     cache::{CacheMiss, CommandCacheValue, TaskCache},
-    config::{DisplayOptions, ResolvedTask, TaskCommand, Workspace},
+    config::{DisplayOptions, ResolvedTask, Workspace},
     execute::{OutputKind, execute_task},
     fs::FileSystem,
 };
@@ -24,8 +24,7 @@ pub struct ExecutionPlan {
 /// Status of a task before execution
 #[derive(Debug)]
 pub struct PreExecutionStatus {
-    pub command: TaskCommand,
-    pub cwd: RelativePathBuf,
+    pub task: ResolvedTask,
     pub cache_status: CacheStatus,
     pub display_options: DisplayOptions,
 }
@@ -42,7 +41,6 @@ pub enum CacheStatus {
 /// Status of a task execution
 #[derive(Debug)]
 pub struct ExecutionStatus {
-    #[expect(dead_code)]
     pub pre_execution_status: PreExecutionStatus,
     /// `Ok` variant means the task was executed (or replayed), no matter the exit status is zero or non-zero.
     ///
@@ -132,28 +130,24 @@ impl ExecutionPlan {
         workspace: &mut Workspace,
     ) -> anyhow::Result<ExecutionStatus> {
         tracing::debug!("Executing task {}", step.display_name());
-
-        let command = step.resolved_command.fingerprint.command.clone();
-        let cwd = step.resolved_command.fingerprint.cwd.clone();
-
         let display_options = step.display_options;
 
         // Check cache and prepare execution
         let (cache_status, execute_or_replay) = get_cached_or_execute(
-            step,
+            step.clone(),
             &mut workspace.task_cache,
             &workspace.fs,
             &workspace.workspace_dir,
         )
         .await?;
 
-        let pre_execution_status =
-            PreExecutionStatus { command, cwd, cache_status, display_options };
+        let pre_execution_status = PreExecutionStatus { task: step, cache_status, display_options };
 
         print!("{}", pre_execution_status);
 
         // Execute or replay the task
         let exit_status = execute_or_replay.await?;
+        println!();
         Ok(ExecutionStatus { pre_execution_status, execution_result: Ok(exit_status) })
     }
 }