Add live file watching with incremental diffs

Backend:
- Add notify-debouncer-full for 200 ms debounced file watching
- Compute diffs on change, emit directory-diff events
- Session stays active until navigation (not just during load)

Frontend:
- Listen for directory-diff events per session
- Apply diffs incrementally with cursor preservation
- Fallback to full reload on sequence gaps

Tests:
- 19 unit tests for applyDiff covering multi-file diffs and edge cases
- Backend compute_diff tests

Author: vdavid

docs/todo.md

@@ -13,7 +13,7 @@
 - [x] Improve performance
 - [x] Display file info below each panel for the file under the cursor
 - [x] Add context menu for files and folders
-- [ ] Add file watching to auto-update changes. It should be as close to immediate as possible
+- [x] Add file watching to auto-update changes. It should be as close to immediate as possible
 - [ ] Implement proper Full view (with fixed columns)
 - [ ] Add Brief view with view switching option
 - [ ] Add different sorting options

src-tauri/Cargo.lock

@@ -34,6 +34,7 @@ base64 = "0.22.1"
 rayon = "1.11.0"
 uuid = { version = "1.19.0", features = ["v4"] }
 tauri-plugin-clipboard-manager = "2"
+notify-debouncer-full = "0.6.0"
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-window-state = "2"

src-tauri/Cargo.toml

@@ -17,11 +17,13 @@ pub use mock_provider::MockFileSystemProvider;
 pub use operations::{
     ChunkNextResult, SessionStartResult, list_directory_end, list_directory_next, list_directory_start,
 };
-// Re-export FileEntry for internal submodules (provider, mock_provider, real_provider)
+// FileEntry re-exported for test modules (provider, mock_provider, real_provider, mock_provider_test)
 #[cfg(test)]
 pub(crate) use operations::FileEntry;
 #[cfg(test)]
 pub use provider::FileSystemProvider;
+// Watcher management - init_watcher_manager must be called from lib.rs
+pub use watcher::init_watcher_manager;
 
 #[cfg(test)]
 mod operations_test;

src-tauri/src/file_system/mod.rs

@@ -9,10 +9,11 @@ use std::os::unix::fs::{MetadataExt, PermissionsExt};
 use std::path::Path;
 use std::sync::LazyLock;
 use std::sync::RwLock;
-use std::time::Instant;
 use uuid::Uuid;
 use uzers::{get_group_by_gid, get_user_by_uid};
 
+use super::watcher::{start_watching, stop_watching};
+
 /// Cache for uid→username and gid→groupname resolution.
 static OWNER_CACHE: LazyLock<RwLock<HashMap<u32, String>>> = LazyLock::new(|| RwLock::new(HashMap::new()));
 static GROUP_CACHE: LazyLock<RwLock<HashMap<u32, String>>> = LazyLock::new(|| RwLock::new(HashMap::new()));
@@ -24,9 +25,10 @@ static SESSION_CACHE: LazyLock<RwLock<HashMap<String, CachedDirectory>>> =
 
 /// Cached directory entries for cursor-based pagination.
 struct CachedDirectory {
+    path: std::path::PathBuf,
     entries: Vec<FileEntry>,
     cursor: usize,
-    created_at: Instant,
+    // No created_at - sessions are eternal until explicitly ended
 }
 
 /// Resolves a uid to a username, with caching.
@@ -303,19 +305,23 @@ pub fn list_directory_start(path: &Path, chunk_size: usize) -> Result<SessionSta
     let first_chunk: Vec<FileEntry> = all_entries.iter().take(chunk_size).cloned().collect();
     let has_more = total_count > chunk_size;
 
-    // Cache the entries with cursor position
+    // Start watching the directory immediately
+    // Clone entries for the watcher (it needs its own copy for diff computation)
+    if let Err(e) = start_watching(&session_id, path, all_entries.clone()) {
+        eprintln!("[SESSION] Failed to start watcher: {}", e);
+        // Continue anyway - watcher is optional enhancement
+    }
+
+    // Cache the entries with cursor position (no expiry)
     if let Ok(mut cache) = SESSION_CACHE.write() {
         cache.insert(
             session_id.clone(),
             CachedDirectory {
+                path: path.to_path_buf(),
                 entries: all_entries,
                 cursor: chunk_size.min(total_count),
-                created_at: Instant::now(),
             },
         );
-
-        // Clean up old sessions (older than 60 seconds)
-        cache.retain(|_, v| v.created_at.elapsed().as_secs() < 60);
     }
 
     Ok(SessionStartResult {
@@ -357,6 +363,10 @@ pub fn list_directory_next(session_id: &str, chunk_size: usize) -> Result<ChunkN
 /// # Arguments
 /// * `session_id` - The session ID to clean up
 pub fn list_directory_end(session_id: &str) {
+    // Stop the file watcher
+    stop_watching(session_id);
+
+    // Remove from session cache
     if let Ok(mut cache) = SESSION_CACHE.write() {
         cache.remove(session_id);
     }