feat: add spinner for git fetch in non-verbose mode

Shows a progress spinner when fetching from git remotes in non-verbose mode.
Suppresses git fetch output and listing messages when not in verbose mode.
Uses NGITTEST environment variable for test timeouts.

2 files changed, 195 insertions, 41 deletions

diff --git a/src/lib/client.rs b/src/lib/client.rs
index 89fcaf7..583f01c 100644
--- a/src/lib/client.rs
+++ b/src/lib/client.rs
@@ -16,10 +16,10 @@ use std::{
     fs::create_dir_all,
     path::Path,
     sync::{
-        Arc, RwLock,
+        Arc, Mutex, RwLock,
         atomic::{AtomicU64, Ordering},
     },
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 use anyhow::{Context, Result, anyhow, bail};
@@ -65,6 +65,65 @@ use crate::{
     repo_state::RepoState,
 };
 
+pub fn is_verbose() -> bool {
+    std::env::var("NGIT_VERBOSE").is_ok()
+}
+
+const SPINNER_EXPAND_DELAY_SECS: u64 = 5;
+
+struct SpinnerState {
+    spinner: ProgressBar,
+    start_time: Instant,
+    expanded_multi: Option<MultiProgress>,
+}
+
+impl SpinnerState {
+    fn new() -> Self {
+        let multi_progress = MultiProgress::new();
+        let spinner = multi_progress.add(
+            ProgressBar::new_spinner()
+                .with_style(
+                    ProgressStyle::with_template("{spinner} {msg}")
+                        .unwrap()
+                        .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"),
+                )
+                .with_message("Checking relays and git servers..."),
+        );
+        spinner.enable_steady_tick(Duration::from_millis(100));
+        Self {
+            spinner,
+            start_time: Instant::now(),
+            expanded_multi: None,
+        }
+    }
+
+    fn should_expand(&self) -> bool {
+        self.expanded_multi.is_none()
+            && self.start_time.elapsed().as_secs() >= SPINNER_EXPAND_DELAY_SECS
+    }
+
+    fn expand(&mut self) -> &MultiProgress {
+        if self.expanded_multi.is_none() {
+            self.spinner.finish_and_clear();
+            self.expanded_multi = Some(MultiProgress::new());
+        }
+        self.expanded_multi.as_ref().unwrap()
+    }
+
+    fn finish(&self, has_errors: bool) {
+        if has_errors {
+            if let Some(ref multi) = self.expanded_multi {
+                let _ = multi.clear();
+            }
+        } else {
+            self.spinner.finish_and_clear();
+            if let Some(ref multi) = self.expanded_multi {
+                let _ = multi.clear();
+            }
+        }
+    }
+}
+
 #[allow(clippy::struct_field_names)]
 pub struct Client {
     client: nostr_sdk::Client,
@@ -370,14 +429,15 @@ impl Connect for Client {
         )
         .await?;
 
+        let verbose = is_verbose();
+        let spinner_state = if !verbose {
+            Some(Arc::new(Mutex::new(SpinnerState::new())))
+        } else {
+            None
+        };
         let progress_reporter = MultiProgress::new();
 
-        // Track successful relays for adaptive timeout (switch to SHORT when
-        // SUCCESS_THRESHOLD succeed)
         let success_count = Arc::new(AtomicU64::new(0));
-
-        // Track current timeout value for progress bar display (starts at LONG,
-        // switches to SHORT)
         let current_timeout = Arc::new(AtomicU64::new(long_timeout()));
 
         let mut processed_relays = HashSet::new();
@@ -388,7 +448,6 @@ impl Connect for Client {
             let relays = request
                 .repo_relays
                 .union(&request.user_relays_for_profiles)
-                // don't look for events on blaster
                 .filter(|&r| !r.as_str().contains("nostr.mutinywallet.com"))
                 .cloned()
                 .collect::<HashSet<RelayUrl>>()
@@ -412,12 +471,12 @@ impl Connect for Client {
             let success_count_for_loop = success_count.clone();
             let current_timeout_for_loop = current_timeout.clone();
             let total_relays = relays.len() as u64;
+            let spinner_state_clone = spinner_state.clone();
 
             let futures: Vec<_> = relays
                 .iter()
                 .map(|r| {
                     if profile_relays_only.contains(r) {
-                        // if relay isn't a repo relay, just filter for user profile
                         FetchRequest {
                             selected_relay: Some(r.to_owned()),
                             repo_coordinates_without_relays: vec![],
@@ -447,6 +506,8 @@ impl Connect for Client {
                     let current_timeout_clone = current_timeout_for_loop.clone();
                     let progress_reporter_clone = progress_reporter.clone();
                     let total_relays_clone = total_relays;
+                    let spinner_state_for_task = spinner_state_clone.clone();
+                    let verbose_for_task = verbose;
                     async move {
                         let relay_column_width = request.relay_column_width;
 
@@ -455,7 +516,7 @@ impl Connect for Client {
                             .clone()
                             .context("fetch_all_from_relay called without a relay")?;
 
-                        let pb = if std::env::var("NGITTEST").is_err() {
+                        let pb = if verbose_for_task {
                             let pb = progress_reporter_clone.add(
                                 ProgressBar::new(1)
                                     .with_prefix(
@@ -469,6 +530,26 @@ impl Connect for Client {
                             );
                             pb.enable_steady_tick(Duration::from_millis(300));
                             Some(pb)
+                        } else if let Some(ref state) = spinner_state_for_task {
+                            let mut state = state.lock().unwrap();
+                            if state.should_expand() {
+                                let multi = state.expand().clone();
+                                let pb = multi.add(
+                                    ProgressBar::new(1)
+                                        .with_prefix(
+                                            format!(
+                                                "{: <relay_column_width$} connecting",
+                                                &relay_url
+                                            )
+                                            .to_string(),
+                                        )
+                                        .with_style(pb_style(current_timeout_clone.clone())?),
+                                );
+                                pb.enable_steady_tick(Duration::from_millis(300));
+                                Some(pb)
+                            } else {
+                                None
+                            }
                         } else {
                             None
                         };
@@ -508,36 +589,27 @@ impl Connect for Client {
                             bail!("{reason}");
                         }
 
-                        // Adaptive timeout using tokio::select!
-                        // Start the fetch operation once and race it against an adaptive timeout
                         let pb_clone = pb.clone();
                         let fetch_future = self.fetch_all_from_relay(git_repo_path, request, &pb_clone);
                         tokio::pin!(fetch_future);
 
-                        // Create an adaptive timeout that switches from long to short
-                        // when SUCCESS_THRESHOLD of relays succeed
                         let timeout_future = async {
-                            // Poll for timeout or SUCCESS_THRESHOLD success threshold
                             let check_interval = Duration::from_millis(100);
                             let long_timeout_end = tokio::time::Instant::now() + Duration::from_secs(long_timeout());
 
                             loop {
-                                // Check if SUCCESS_THRESHOLD of relays have succeeded
                                 let current_success_count = success_count_clone.load(Ordering::Relaxed);
                                 let threshold = (total_relays_clone as f64 * SUCCESS_THRESHOLD).ceil() as u64;
 
                                 if current_success_count >= threshold {
-                                    // SUCCESS_THRESHOLD reached, switch to short timeout
                                     tokio::time::sleep(Duration::from_secs(short_timeout())).await;
                                     return "short";
                                 }
 
-                                // Check if long timeout has expired
                                 if tokio::time::Instant::now() >= long_timeout_end {
                                     return "long";
                                 }
 
-                                // Sleep briefly before checking again
                                 tokio::time::sleep(check_interval).await;
                             }
                         };
@@ -546,11 +618,9 @@ impl Connect for Client {
                         let result = tokio::select! {
                             result = &mut fetch_future => {
                                 if result.is_ok() {
-                                    // Increment success count
                                     let new_count = success_count_clone.fetch_add(1, Ordering::Relaxed) + 1;
                                     let threshold = (total_relays_clone as f64 * SUCCESS_THRESHOLD).ceil() as u64;
 
-                                    // If we've reached SUCCESS_THRESHOLD, update timeout display
                                     if new_count >= threshold {
                                         current_timeout_clone.store(short_timeout(), Ordering::Relaxed);
                                     }
@@ -565,7 +635,6 @@ impl Connect for Client {
 
                         match result {
                             Err(error) => {
-                                // Check error for timeout/connection issues and add to skip list
                                 if error.to_string().contains("connection timeout") || error.to_string().contains("timeout after") {
                                     self.skip_relay_for_session(relay_url.clone(), error.to_string());
                                 }
@@ -619,6 +688,12 @@ impl Connect for Client {
                 set
             };
         }
+
+        if let Some(ref state) = spinner_state {
+            let has_errors = relay_reports.iter().any(Result::is_err);
+            state.lock().unwrap().finish(has_errors);
+        }
+
         Ok((relay_reports, progress_reporter))
     }
 
@@ -2084,8 +2159,11 @@ pub async fn fetching_with_report(
     #[cfg(not(test))] client: &Client,
     trusted_maintainer_coordinate: &Nip19Coordinate,
 ) -> Result<FetchReport> {
-    let term = console::Term::stderr();
-    term.write_line("fetching updates...")?;
+    let verbose = is_verbose();
+    if verbose {
+        let term = console::Term::stderr();
+        term.write_line("fetching updates...")?;
+    }
     let (relay_reports, progress_reporter) = client
         .fetch_all(
             Some(git_repo_path),
diff --git a/src/lib/list.rs b/src/lib/list.rs
index ce8737c..3b37b37 100644
--- a/src/lib/list.rs
+++ b/src/lib/list.rs
@@ -3,10 +3,10 @@ use std::{
     path::PathBuf,
     str::FromStr,
     sync::{
-        Arc,
+        Arc, Mutex,
         atomic::{AtomicU64, Ordering},
     },
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 use anyhow::{Result, anyhow};
@@ -16,6 +16,7 @@ use indicatif::{MultiProgress, ProgressBar, ProgressState, ProgressStyle};
 use nostr::hashes::sha1::Hash as Sha1Hash;
 
 use crate::{
+    client::is_verbose,
     git::{
         Repo, RepoActions,
         nostr_url::{CloneUrl, NostrUrlDecoded, ServerProtocol},
@@ -28,6 +29,61 @@ use crate::{
     },
 };
 
+const SPINNER_EXPAND_DELAY_SECS: u64 = 5;
+
+struct GitSpinnerState {
+    spinner: ProgressBar,
+    start_time: Instant,
+    expanded_multi: Option<MultiProgress>,
+}
+
+impl GitSpinnerState {
+    fn new() -> Self {
+        let multi_progress = MultiProgress::new();
+        let spinner = multi_progress.add(
+            ProgressBar::new_spinner()
+                .with_style(
+                    ProgressStyle::with_template("{spinner} {msg}")
+                        .unwrap()
+                        .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"),
+                )
+                .with_message("Checking git servers..."),
+        );
+        spinner.enable_steady_tick(Duration::from_millis(100));
+        Self {
+            spinner,
+            start_time: Instant::now(),
+            expanded_multi: None,
+        }
+    }
+
+    fn should_expand(&self) -> bool {
+        self.expanded_multi.is_none()
+            && self.start_time.elapsed().as_secs() >= SPINNER_EXPAND_DELAY_SECS
+    }
+
+    fn expand(&mut self) -> &MultiProgress {
+        if self.expanded_multi.is_none() {
+            self.spinner.finish_and_clear();
+            self.expanded_multi = Some(MultiProgress::new());
+        }
+        self.expanded_multi.as_ref().unwrap()
+    }
+
+    fn finish(&self, has_errors: bool) {
+        if has_errors {
+            if let Some(ref multi) = self.expanded_multi {
+                let _ = multi.clear();
+            }
+        } else {
+            self.spinner.finish_and_clear();
+            if let Some(ref multi) = self.expanded_multi {
+                let _ = multi.clear();
+            }
+        }
+    }
+}
+
 /// Sync issues identified for a single remote
 #[derive(Default, Debug, Clone)]
 pub struct RemoteIssues {
@@ -111,18 +167,18 @@ pub async fn list_from_remotes(
         return HashMap::new();
     }
 
-    let progress_reporter = if std::env::var("NGITTEST").is_err() {
-        MultiProgress::new()
+    let verbose = is_verbose();
+    let spinner_state = if !verbose {
+        Some(Arc::new(Mutex::new(GitSpinnerState::new())))
     } else {
-        MultiProgress::with_draw_target(indicatif::ProgressDrawTarget::hidden())
+        None
     };
+    let progress_reporter = MultiProgress::new();
 
-    // Track successful servers for adaptive timeout
     let success_count = Arc::new(AtomicU64::new(0));
     let current_timeout = Arc::new(AtomicU64::new(git_server_long_timeout()));
     let total_servers = git_servers.len() as u64;
 
-    // Calculate column width for alignment
     let server_column_width = git_servers
         .iter()
         .map(|s| get_short_git_server_name(s).chars().count())
@@ -139,11 +195,13 @@ pub async fn list_from_remotes(
             let current_timeout_clone = current_timeout.clone();
             let progress_reporter_clone = progress_reporter.clone();
             let decoded_nostr_url = decoded_nostr_url.clone();
+            let spinner_state_clone = spinner_state.clone();
+            let verbose_for_task = verbose;
 
             async move {
                 let server_name = get_short_git_server_name(&url);
 
-                let pb = if std::env::var("NGITTEST").is_err() {
+                let pb = if verbose_for_task {
                     match git_server_pb_style(current_timeout_clone.clone()) {
                         Ok(style) => {
                             let pb = progress_reporter_clone.add(
@@ -164,6 +222,28 @@ pub async fn list_from_remotes(
                         }
                         Err(_) => None,
                     }
+                } else if let Some(ref spinner_state_arc) = spinner_state_clone {
+                    let mut state = spinner_state_arc.lock().unwrap();
+                    if state.should_expand() {
+                        let multi = state.expand().clone();
+                        let pb = multi.add(
+                            ProgressBar::new(1)
+                                .with_prefix(
+                                    console::style(format!(
+                                        "{: <server_column_width$} connecting",
+                                        &server_name
+                                    ))
+                                    .for_stderr()
+                                    .yellow()
+                                    .to_string(),
+                                )
+                                .with_style(git_server_pb_style(current_timeout_clone.clone()).unwrap()),
+                        );
+                        pb.enable_steady_tick(Duration::from_millis(300));
+                        Some(pb)
+                    } else {
+                        None
+                    }
                 } else {
                     None
                 };
@@ -191,7 +271,6 @@ pub async fn list_from_remotes(
                     }
                 }
 
-                // Create the list operation future - spawn_blocking to avoid blocking async runtime
                 let git_repo_path = git_repo.get_path().ok().map(|p| p.to_path_buf());
                 let url_clone = url.clone();
                 let decoded_nostr_url_clone = decoded_nostr_url.clone();
@@ -199,7 +278,6 @@ pub async fn list_from_remotes(
 
                 let list_future = async move {
                     match tokio::task::spawn_blocking(move || {
-                        // Re-open repo in blocking thread (git2::Repository is not Send)
                         let git_repo = match git_repo_path {
                             Some(path) => Repo::from_path(&path).ok(),
                             None => None,
@@ -274,11 +352,9 @@ pub async fn list_from_remotes(
                         Err((url, error))
                     }
                     Ok(state) => {
-                        // Determine sync status message and styling using existing functions
                         let status_msg = if state.is_empty() {
                             "empty repository".to_string()
                         } else if let Some(nostr_state) = nostr_state {
-                            // Use existing generate_remote_sync_warnings to get detailed status
                             let mut temp_states = HashMap::new();
                             temp_states.insert(url.clone(), (state.clone(), is_grasp_server));
                             let remote_issues = identify_remote_sync_issues(git_repo, nostr_state, &temp_states);
@@ -287,7 +363,6 @@ pub async fn list_from_remotes(
                             if warnings.is_empty() {
                                 "in sync".to_string()
                             } else {
-                                // Extract the message after "WARNING: <server> "
                                 let warning = &warnings[0];
                                 let server_name = get_short_git_server_name(&url);
                                 let prefix = format!("WARNING: {} ", server_name);
@@ -296,7 +371,6 @@ pub async fn list_from_remotes(
                                     .to_string()
                             }
                         } else {
-                            // No nostr state to compare against
                             "success".to_string()
                         };
 
@@ -333,20 +407,22 @@ pub async fn list_from_remotes(
         .await;
 
     let mut remote_states = HashMap::new();
-    let mut all_succeeded = true;
+    let mut has_errors = false;
     for result in results {
         match result {
             Ok((url, state, is_grasp_server)) => {
                 remote_states.insert(url, (state, is_grasp_server));
             }
             Err((url, error)) => {
-                all_succeeded = false;
+                has_errors = true;
                 let _ = term.write_line(&format!("failed to list from {}: {}", url, error));
             }
         }
     }
 
-    if all_succeeded {
+    if let Some(ref spinner_state_arc) = spinner_state {
+        spinner_state_arc.lock().unwrap().finish(has_errors);
+    } else if !has_errors {
         let _ = progress_reporter.clear();
     }