Add live git status indicators (#458)

crates-tauri/yaak-app-client/src/git_watcher.rs

@@ -0,0 +1,172 @@
+use crate::error::{Error, Result};
+use chrono::Utc;
+use log::{debug, error, warn};
+use notify::Watcher;
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+use std::sync::mpsc;
+use std::time::Duration;
+use tauri::ipc::Channel;
+use tauri::{AppHandle, Listener, Runtime};
+use tokio::select;
+use tokio::sync::watch;
+use tokio::time::sleep;
+use ts_rs::TS;
+use yaak_git::{GitWorktreeStatus, git_path_is_ignored, git_repository_paths, git_worktree_status};
+
+const GIT_STATUS_COALESCE_WINDOW: Duration = Duration::from_millis(250);
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "index.ts")]
+pub(crate) struct GitWatchResult {
+    unlisten_event: String,
+}
+
+pub(crate) async fn watch_git_worktree_status<R: Runtime>(
+    app_handle: AppHandle<R>,
+    dir: &Path,
+    channel: Channel<GitWorktreeStatus>,
+) -> Result<GitWatchResult> {
+    let paths = git_repository_paths(dir)?;
+    let repo_dir = dir.to_path_buf();
+    let workdir = paths.workdir;
+    let gitdir = paths.gitdir;
+
+    let (tx, rx) = mpsc::channel::<notify::Result<notify::Event>>();
+    let mut watcher = notify::recommended_watcher(tx)
+        .map_err(|e| Error::GenericError(format!("Failed to watch Git repository: {e}")))?;
+
+    watcher
+        .watch(&workdir, notify::RecursiveMode::Recursive)
+        .map_err(|e| Error::GenericError(format!("Failed to watch Git worktree: {e}")))?;
+    if gitdir != workdir {
+        watcher
+            .watch(&gitdir, notify::RecursiveMode::Recursive)
+            .map_err(|e| Error::GenericError(format!("Failed to watch Git metadata: {e}")))?;
+    }
+
+    let (async_tx, mut async_rx) = tokio::sync::mpsc::channel::<notify::Result<notify::Event>>(100);
+    std::thread::spawn(move || {
+        for res in rx {
+            if async_tx.blocking_send(res).is_err() {
+                break;
+            }
+        }
+    });
+
+    let (cancel_tx, cancel_rx) = watch::channel(());
+    let mut cancel_rx = cancel_rx;
+    send_worktree_status(&repo_dir, &channel);
+
+    tauri::async_runtime::spawn(async move {
+        let _watcher = watcher;
+        loop {
+            select! {
+                Some(event_res) = async_rx.recv() => {
+                    handle_git_watch_event(
+                        event_res,
+                        &mut async_rx,
+                        &repo_dir,
+                        &workdir,
+                        &gitdir,
+                        &channel,
+                    ).await;
+                }
+                _ = cancel_rx.changed() => {
+                    break;
+                }
+            }
+        }
+    });
+
+    let app_handle_inner = app_handle.clone();
+    let unlisten_event = format!("git-watch-unlisten-{}", Utc::now().timestamp_millis());
+    app_handle.listen_any(unlisten_event.clone(), move |event| {
+        app_handle_inner.unlisten(event.id());
+        if let Err(e) = cancel_tx.send(()) {
+            warn!("Failed to send git watch cancel signal {e:?}");
+        }
+    });
+
+    Ok(GitWatchResult { unlisten_event })
+}
+
+async fn handle_git_watch_event(
+    event_res: notify::Result<notify::Event>,
+    async_rx: &mut tokio::sync::mpsc::Receiver<notify::Result<notify::Event>>,
+    repo_dir: &Path,
+    workdir: &Path,
+    gitdir: &Path,
+    channel: &Channel<GitWorktreeStatus>,
+) {
+    if !is_relevant_git_watch_event(event_res, repo_dir, workdir, gitdir) {
+        return;
+    }
+
+    send_worktree_status(repo_dir, channel);
+
+    let settle_window = sleep(GIT_STATUS_COALESCE_WINDOW);
+    tokio::pin!(settle_window);
+    loop {
+        select! {
+            Some(event_res) = async_rx.recv() => {
+                let _ = is_relevant_git_watch_event(event_res, repo_dir, workdir, gitdir);
+            }
+            _ = &mut settle_window => {
+                break;
+            }
+        }
+    }
+
+    send_worktree_status(repo_dir, channel);
+}
+
+fn is_relevant_git_watch_event(
+    event_res: notify::Result<notify::Event>,
+    repo_dir: &Path,
+    workdir: &Path,
+    gitdir: &Path,
+) -> bool {
+    let event = match event_res {
+        Ok(event) => event,
+        Err(e) => {
+            error!("Git watch error: {:?}", e);
+            return false;
+        }
+    };
+
+    for path in event.paths {
+        if path.strip_prefix(gitdir).is_ok() {
+            return true;
+        }
+
+        let Ok(rela_path) = path.strip_prefix(workdir) else {
+            continue;
+        };
+
+        match git_path_is_ignored(repo_dir, rela_path) {
+            Ok(true) => {}
+            Ok(false) => return true,
+            Err(e) => {
+                debug!("Failed to check Git ignore status for {:?}: {e}", rela_path);
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
+fn send_worktree_status(repo_dir: &Path, channel: &Channel<GitWorktreeStatus>) {
+    match git_worktree_status(repo_dir) {
+        Ok(status) => {
+            if let Err(e) = channel.send(status) {
+                warn!("Failed to send git worktree status: {:?}", e);
+            }
+        }
+        Err(e) => {
+            warn!("Failed to get git worktree status: {e}");
+        }
+    }
+}