feat: add logging and improve execution UX

Author: beardcoder

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "tide"
-version = "1.2.4"
+version = "1.3.0"
 edition = "2024"
 authors = ["Markus Sommer"]
 description = "🌊 Tide - Refresh your system with the update wave"

Cargo.toml

@@ -13,7 +13,7 @@ skip_optional_on_error = false # Skip optional tasks if a required task fails
 keychain_label = "tide-sudo"   # For storing sudo password in keychain (macOS Keychain)
 use_colors = true              # Enable colored output
 verbose = false                # Show detailed output
-log_file = ""                  # Optional: Path to log file
+log_file = "~/.config/tide/tide.log"  # Optional: capture command output (relative paths allowed)
 desktop_notifications = true   # Enable macOS desktop notifications
 
 # ============================================================================

example-full-config.toml

@@ -39,6 +39,7 @@ Tide coordinates macOS software updates, Homebrew cleanups, and any custom shell
 - Dry-run mode to preview commands with zero side effects.
 - Optional fail-fast behaviour that halts optional work after a required task fails.
 - Verbose logging for debugging plus quiet mode for automation owners.
+- Structured run logs when `log_file` is set—every task start/stop and trimmed output is written to disk for later review.
 
 ### Desktop Notifications 🔔
 
@@ -109,7 +110,7 @@ parallel_limit = 4
 skip_optional_on_error = false
 keychain_label = "tide-sudo"
 verbose = false
-log_file = ""                  # Optional: capture command output
+log_file = "~/.config/tide/tide.log"  # Optional: capture command output
 desktop_notifications = true   # Enable macOS desktop notifications
 
 [[groups]]
@@ -138,6 +139,8 @@ parallel = false
   timeout = 600
 ```
 
+Set `show_progress = false` if you prefer plain log lines instead of spinner-based updates—handy for CI logs or when capturing all details via the log file.
+
 ### Task Fields
 
 - `command` – Array form prevents shell quoting issues.
@@ -202,6 +205,10 @@ command = ["./interactive-tool"]  # asks questions
 # Will hang and timeout after 5 minutes!
 ```
 
+### Logging
+
+Set `log_file` under `[settings]` to capture a full transcript of the run. Relative paths are resolved relative to the config file, tilde-expansion (`~`) is supported, and directories are created automatically. Each entry records the timestamp, group/task name, status, runtime, and a trimmed copy of any captured output so you can audit what happened without scrolling back through your terminal scrollback.
+
 ## Examples
 
 Parallel developer tooling refresh:

readme.md

@@ -46,8 +46,4 @@ pub struct Args {
     /// Enable verbose output
     #[arg(short, long)]
     pub verbose: bool,
-
-    /// Show version information
-    #[arg(short = 'V', long)]
-    pub version: bool,
 }

src/cli.rs

@@ -62,6 +62,16 @@ impl Default for Settings {
     }
 }
 
+impl Settings {
+    /// Return the configured log file path, ignoring empty values.
+    pub fn log_file_path(&self) -> Option<&str> {
+        self.log_file
+            .as_deref()
+            .map(str::trim)
+            .filter(|path| !path.is_empty())
+    }
+}
+
 /// Task group configuration
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct TaskGroup {

src/config.rs

@@ -9,6 +9,7 @@ use std::time::{Duration, Instant};
 
 use crate::config::TaskConfig;
 use crate::keychain;
+use crate::logger::Logger;
 use crate::notifications::NotificationManager;
 
 /// Task execution result
@@ -33,20 +34,97 @@ pub enum TaskStatus {
 /// Task executor with progress tracking
 #[derive(Clone)]
 pub struct TaskExecutor {
-    pub multi_progress: Arc<MultiProgress>,
+    pub multi_progress: Option<Arc<MultiProgress>>,
     pub dry_run: bool,
     pub verbose: bool,
     pub notifier: Arc<NotificationManager>,
+    logger: Option<Arc<Logger>>,
+    show_progress: bool,
 }
 
 impl TaskExecutor {
     /// Create a new task executor
-    pub fn new(dry_run: bool, verbose: bool, notifications_enabled: bool) -> Self {
+    pub fn new(
+        dry_run: bool,
+        verbose: bool,
+        notifications_enabled: bool,
+        show_progress: bool,
+        logger: Option<Arc<Logger>>,
+    ) -> Self {
         Self {
-            multi_progress: Arc::new(MultiProgress::new()),
+            multi_progress: show_progress.then(|| Arc::new(MultiProgress::new())),
             dry_run,
             verbose,
             notifier: Arc::new(NotificationManager::new(notifications_enabled)),
+            logger,
+            show_progress,
+        }
+    }
+
+    fn update_progress(&self, pb: &ProgressBar, message: &str) {
+        if self.show_progress {
+            pb.set_message(message.to_string());
+        } else {
+            println!("{}", message);
+        }
+    }
+
+    fn finish_progress(&self, pb: &ProgressBar, message: &str) {
+        if self.show_progress {
+            pb.finish_with_message(message.to_string());
+        } else {
+            println!("{}", message);
+        }
+    }
+
+    fn log_line(&self, message: String) {
+        if let Some(logger) = &self.logger {
+            if let Err(err) = logger.log_line(&message) {
+                if self.verbose {
+                    eprintln!("{}", format!("Failed to write log entry: {}", err).yellow());
+                }
+            }
+        }
+    }
+
+    fn log_task_completion(
+        &self,
+        group_label: &str,
+        task_label: &str,
+        status: TaskStatus,
+        duration: Duration,
+        output: Option<&str>,
+    ) {
+        if self.logger.is_none() {
+            return;
+        }
+
+        let status_prefix = match status {
+            TaskStatus::Success => "✓ SUCCESS",
+            TaskStatus::Failed => "✗ FAILED",
+            TaskStatus::Skipped => "○ SKIPPED",
+        };
+        self.log_line(format!(
+            "{} [{}] {} ({})",
+            status_prefix,
+            group_label,
+            task_label,
+            format_duration(duration)
+        ));
+
+        if let Some(output) = output {
+            let trimmed = output.trim();
+            if trimmed.is_empty() {
+                return;
+            }
+            if let Some(logger) = &self.logger {
+                let header = format!("└ output [{}] {}", group_label, task_label);
+                if let Err(err) = logger.log_block(&header, trimmed) {
+                    if self.verbose {
+                        eprintln!("{}", format!("Failed to write log entry: {}", err).yellow());
+                    }
+                }
+            }
         }
     }
 
@@ -141,14 +219,18 @@ impl TaskExecutor {
 
     /// Create a configured spinner progress bar
     pub fn new_spinner(&self) -> ProgressBar {
-        let pb = self.multi_progress.add(ProgressBar::new_spinner());
-        pb.set_style(
-            ProgressStyle::with_template("{spinner:.cyan} {msg}")
-                .unwrap()
-                .tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]),
-        );
-        pb.enable_steady_tick(Duration::from_millis(120));
-        pb
+        if let Some(multi) = &self.multi_progress {
+            let pb = multi.add(ProgressBar::new_spinner());
+            pb.set_style(
+                ProgressStyle::with_template("{spinner:.cyan} {msg}")
+                    .unwrap()
+                    .tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]),
+            );
+            pb.enable_steady_tick(Duration::from_millis(120));
+            pb
+        } else {
+            ProgressBar::hidden()
+        }
     }
 
     /// Execute a single task
@@ -165,76 +247,109 @@ impl TaskExecutor {
         let group_label = format_group_label(&group_name, &group_icon);
         let task_label = format_task_label(&task_name, &task.icon);
         let progress_label = format!("[{}] {}", group_label, task_label);
+        let running_message = format!("{} {}", progress_label.bold(), "Running…".bright_white());
+        self.update_progress(&pb, &running_message);
 
-        // Update progress bar
-        pb.set_message(format!(
-            "{} {}",
-            progress_label.clone().bold(),
-            "Running…".bright_white()
+        let mut cmd = task.command.clone();
+        if task.sudo && !cmd.is_empty() && cmd[0] != "sudo" {
+            cmd.insert(0, "sudo".to_string());
+        }
+        let command_display = if cmd.is_empty() {
+            "<empty command>".to_string()
+        } else {
+            cmd.join(" ")
+        };
+        self.log_line(format!(
+            "▶ [{}] {} :: {}",
+            group_label, task_label, command_display
         ));
 
         if self.dry_run {
             tokio::time::sleep(Duration::from_millis(100)).await;
-            pb.finish_with_message(format!(
+            let dry_run_msg = format!(
                 "{} {} {}",
-                progress_label.clone().bold(),
+                progress_label.bold(),
                 "○".yellow(),
                 "[dry run]".dimmed()
-            ));
+            );
+            self.finish_progress(&pb, &dry_run_msg);
+            let duration = start.elapsed();
+            let reason = "Dry run - command not executed".to_string();
+            self.log_task_completion(
+                &group_label,
+                &task_label,
+                TaskStatus::Skipped,
+                duration,
+                Some(reason.as_str()),
+            );
             return TaskResult {
                 name: task_name.clone(),
                 group: group_name,
                 group_icon,
                 status: TaskStatus::Skipped,
-                duration: start.elapsed(),
-                output: Some("Dry run - command not executed".to_string()),
+                duration,
+                output: Some(reason),
             };
         }
 
         // Check preconditions
         if let Some(check_cmd) = &task.check_command
             && !keychain::command_exists(check_cmd)
         {
-            pb.finish_with_message(format!(
+            let skip_msg = format!(
                 "{} {}",
-                progress_label.clone().bold(),
+                progress_label.bold(),
                 "[skipped: command not found]".dimmed()
-            ));
+            );
+            self.finish_progress(&pb, &skip_msg);
+            let duration = start.elapsed();
+            let reason = format!("Command '{}' not found", check_cmd);
+            self.log_task_completion(
+                &group_label,
+                &task_label,
+                TaskStatus::Skipped,
+                duration,
+                Some(reason.as_str()),
+            );
             return TaskResult {
                 name: task_name.clone(),
                 group: group_name,
                 group_icon,
                 status: TaskStatus::Skipped,
-                duration: start.elapsed(),
-                output: Some(format!("Command '{}' not found", check_cmd)),
+                duration,
+                output: Some(reason),
             };
         }
 
         if let Some(check_path) = &task.check_path {
             let expanded = shellexpand::tilde(check_path);
             if !Path::new(expanded.as_ref()).exists() {
-                pb.finish_with_message(format!(
+                let skip_msg = format!(
                     "{} {}",
-                    progress_label.clone().bold(),
+                    progress_label.bold(),
                     "[skipped: path not found]".dimmed()
-                ));
+                );
+                self.finish_progress(&pb, &skip_msg);
+                let duration = start.elapsed();
+                let reason = format!("Path '{}' not found", check_path);
+                self.log_task_completion(
+                    &group_label,
+                    &task_label,
+                    TaskStatus::Skipped,
+                    duration,
+                    Some(reason.as_str()),
+                );
                 return TaskResult {
                     name: task_name.clone(),
                     group: group_name,
                     group_icon,
                     status: TaskStatus::Skipped,
-                    duration: start.elapsed(),
-                    output: Some(format!("Path '{}' not found", check_path)),
+                    duration,
+                    output: Some(reason),
                 };
             }
         }
 
-        // Build command
-        let mut cmd = task.command.clone();
-        if task.sudo && !cmd.is_empty() && cmd[0] != "sudo" {
-            cmd.insert(0, "sudo".to_string());
-        }
-
         // Warn if command might internally call sudo (heuristic check)
         if !task.sudo && self.verbose && !cmd.is_empty() {
             let cmd_str = cmd.join(" ").to_lowercase();
@@ -276,12 +391,20 @@ impl TaskExecutor {
             TaskStatus::Skipped => "○".yellow(),
         };
 
-        pb.finish_with_message(format!(
+        let completion_message = format!(
             "{} {} {}",
             progress_label.bold(),
             status_icon,
             format!("({})", format_duration(duration)).dimmed()
-        ));
+        );
+        self.finish_progress(&pb, &completion_message);
+        self.log_task_completion(
+            &group_label,
+            &task_label,
+            status,
+            duration,
+            output.as_deref(),
+        );
 
         TaskResult {
             name: task_name,