perf: throttle system snapshot to 1Hz off System tab, 4Hz on it

snapshot_with_threads rebuilds the full process Vec on every call
(hundreds of procs, String allocations, cmd-line clones). Calling it
on every 33 ms ratatui tick made every screen feel laggy because the
snapshot work fires regardless of which tab the user is on.

Also drops the `brew --cache` subprocess from the Homebrew rule —
spawning Ruby per scan added ~1s of stall — in favour of a static
list of well-known cache paths.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: akhil-gautam

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bloat"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 description = "An htop-style disk storage analyzer and cleanup TUI for macOS"
 

Cargo.toml

@@ -1173,6 +1173,7 @@ fn chrono_now() -> String {
 
 pub fn run(mut terminal: DefaultTerminal, mut app: App) -> std::io::Result<()> {
     let mut rx: Option<mpsc::Receiver<ScanProgress>> = None;
+    let mut last_snapshot = std::time::Instant::now() - std::time::Duration::from_secs(10);
 
     loop {
         // Check quit first — before any auto-start logic
@@ -1188,10 +1189,18 @@ pub fn run(mut terminal: DefaultTerminal, mut app: App) -> std::io::Result<()> {
             rx = Some(app.start_scan());
         }
 
-        // Always collect a live snapshot so the alert engine stays current.
-        // When paused, we don't replace sys_snapshot (which holds the live view
-        // used as the base for the UI), but we still run alerts against fresh data.
-        {
+        // Throttle snapshot collection. snapshot_with_threads rebuilds the
+        // full process Vec on every call (heavy: hundreds of procs, String
+        // allocations, cmd-line clones), so calling it on every 33 ms tick
+        // makes every screen feel laggy. The System tab needs ~4 fps to feel
+        // live; other tabs only need the alert engine to stay current.
+        let snapshot_interval = if app.tab == Tab::System {
+            std::time::Duration::from_millis(250)
+        } else {
+            std::time::Duration::from_millis(1000)
+        };
+        if last_snapshot.elapsed() >= snapshot_interval {
+            last_snapshot = std::time::Instant::now();
             let expanded_pid = app.system_tab.expanded_pid;
             let snap = app.sys_monitor.snapshot_with_threads(
                 std::time::Duration::from_secs(1),

src/app.rs

@@ -4,7 +4,6 @@
 // and /Users/<user>/Library/Caches/Homebrew on Intel; we just probe both.
 
 use std::path::PathBuf;
-use std::process::Command;
 
 use crate::tree::FsTree;
 
@@ -23,21 +22,17 @@ impl CleanupRule for HomebrewCacheRule {
     fn safety(&self) -> Safety { Safety::Safe }
 
     fn detect(&self, _tree: &FsTree) -> Vec<CleanupItem> {
+        // Probe well-known cache paths directly — never spawn `brew --cache`,
+        // which costs ~1s of Ruby startup per scan.
         let mut paths: Vec<PathBuf> = Vec::new();
-
-        if let Ok(out) = Command::new("brew").arg("--cache").output() {
-            if out.status.success() {
-                let p = String::from_utf8_lossy(&out.stdout).trim().to_string();
-                if !p.is_empty() {
-                    paths.push(PathBuf::from(p));
-                }
-            }
-        }
-        if paths.is_empty() {
-            if let Some(home) = dirs::home_dir() {
-                let p = home.join("Library/Caches/Homebrew");
-                if p.exists() {
-                    paths.push(p);
+        if let Some(home) = dirs::home_dir() {
+            for candidate in [
+                home.join("Library/Caches/Homebrew"),
+                PathBuf::from("/opt/homebrew/Library/Homebrew/cache"),
+                PathBuf::from("/usr/local/Library/Homebrew/cache"),
+            ] {
+                if candidate.exists() {
+                    paths.push(candidate);
                 }
             }
         }