feat: implement project session loading and caching functionality, enhancing conversation management in the ConversationList component

Author: milisp

src-tauri/src/lib.rs

@@ -18,8 +18,8 @@ use commands::{
 use crate::config::provider::ensure_default_providers;
 use session_files::{
     delete::{delete_session_file, delete_sessions_files},
-    save::get_project_sessions,
-    scan::scan_projects,
+    cache::{load_project_sessions, write_project_cache},
+    scanner::scan_projects,
     update::update_cache_title,
 };
 use terminal::open_terminal_with_command;
@@ -107,11 +107,12 @@ pub fn run() {
             cmd::respond_exec_command_request,
             cmd::delete_file,
             scan_projects,
-            get_project_sessions,
+            load_project_sessions,
             delete_session_file,
             update_cache_title,
             open_terminal_with_command,
             delete_sessions_files,
+            write_project_cache,
         ])
         .setup(|_app| {
             #[cfg(debug_assertions)]

src-tauri/src/session_files/cache.rs

@@ -0,0 +1,110 @@
+use super::get::get_cache_path_for_project;
+use super::scanner::scan_sessions_after;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use std::fs::{read_to_string, File};
+use std::io::Write;
+
+/// Structure stored in cache file
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct ProjectCache {
+    last_scanned: String,
+    sessions: Vec<Value>,
+    favorites: Vec<String>,
+}
+
+/// Read cache file for a project
+fn read_project_cache(project_path: &str) -> Result<Option<(DateTime<Utc>, Vec<Value>, Vec<String>)>, String> {
+    let cache_path = get_cache_path_for_project(project_path)?;
+    if !cache_path.exists() {
+        return Ok(None);
+    }
+
+    let cache_str =
+        read_to_string(&cache_path).map_err(|e| format!("Failed to read cache: {}", e))?;
+
+    let cache: ProjectCache = match serde_json::from_str(&cache_str) {
+        Ok(v) => v,
+        Err(e) => {
+            eprintln!("Cache parse failed ({}), fallback to full scan.", e);
+            return Ok(None); // fallback gracefully
+        }
+    };
+
+    let last_scanned = DateTime::parse_from_rfc3339(&cache.last_scanned)
+        .ok()
+        .map(|dt| dt.with_timezone(&Utc));
+
+    match last_scanned {
+        Some(dt) => Ok(Some((dt, cache.sessions, cache.favorites))),
+        None => Ok(None),
+    }
+}
+
+/// Write updated cache to disk
+#[tauri::command]
+pub fn write_project_cache(project_path: String, sessions: Vec<Value>, favorites: Vec<String>) -> Result<(), String> {
+    let cache_path = get_cache_path_for_project(&project_path)?;
+    let data = ProjectCache {
+        last_scanned: Utc::now().to_rfc3339(),
+        sessions,
+        favorites,
+    };
+
+    let json_str =
+        serde_json::to_string_pretty(&data).map_err(|e| format!("Failed to serialize cache: {}", e))?;
+    let mut file =
+        File::create(&cache_path).map_err(|e| format!("Failed to create cache file: {}", e))?;
+    file.write_all(json_str.as_bytes())
+        .map_err(|e| format!("Failed to write cache file: {}", e))?;
+
+    Ok(())
+}
+
+/// Main tauri command: load or refresh sessions for given project
+#[tauri::command]
+pub async fn load_project_sessions(project_path: String) -> Result<Value, String> {
+    match read_project_cache(&project_path)? {
+        Some((last_scanned, mut cached_sessions, favorites)) => {
+            // Incremental scan
+            let new_sessions = scan_sessions_after(&project_path, Some(last_scanned))?;
+
+            // Deduplicate by conversationId
+            let new_ids: std::collections::HashSet<_> = new_sessions
+                .iter()
+                .filter_map(|s| s["conversationId"].as_str())
+                .collect();
+
+            cached_sessions.retain(|s| {
+                !new_ids.contains(s["conversationId"].as_str().unwrap_or_default())
+            });
+
+            cached_sessions.extend(new_sessions);
+
+            // Sort newest first
+            cached_sessions.sort_by(|a, b| {
+                use super::utils::extract_datetime;
+                let a_dt = extract_datetime(a["path"].as_str().unwrap_or_default());
+                let b_dt = extract_datetime(b["path"].as_str().unwrap_or_default());
+                match (a_dt, b_dt) {
+                    (Some(a_dt), Some(b_dt)) => b_dt.cmp(&a_dt),
+                    (Some(_), None) => std::cmp::Ordering::Less,
+                    (None, Some(_)) => std::cmp::Ordering::Greater,
+                    (None, None) => a["path"].as_str().cmp(&b["path"].as_str()),
+                }
+            });
+
+            write_project_cache(project_path.clone(), cached_sessions.clone(), favorites.clone())?;
+            Ok(json!({ "sessions": cached_sessions, "favorites": favorites }))
+        }
+        None => {
+            // No cache or broken cache → full scan
+            let sessions = scan_sessions_after(&project_path, None)?;
+            let favorites: Vec<String> = Vec::new();
+            write_project_cache(project_path.clone(), sessions.clone(), favorites.clone())?;
+            Ok(json!({ "sessions": sessions, "favorites": favorites }))
+        }
+    }
+}

src-tauri/src/session_files/mod.rs

@@ -1,7 +1,7 @@
+pub mod cache;
 pub mod delete;
 pub mod file;
 pub mod get;
-pub mod save;
-pub mod scan;
+pub mod scanner;
 pub mod update;
 pub mod utils;

src-tauri/src/session_files/save.rs

@@ -6,6 +6,7 @@ use std::collections::HashSet;
 use std::path::Path;
 use walkdir::WalkDir;
 
+/// Walk through all `.jsonl` files in sessions directory
 pub fn scan_jsonl_files<P: AsRef<Path>>(dir_path: P) -> impl Iterator<Item = walkdir::DirEntry> {
     WalkDir::new(dir_path)
         .into_iter()
@@ -14,7 +15,8 @@ pub fn scan_jsonl_files<P: AsRef<Path>>(dir_path: P) -> impl Iterator<Item = wal
         .filter(|e| e.path().extension().and_then(|s| s.to_str()) == Some("jsonl"))
 }
 
-pub fn scan_project_sessions_incremental(
+/// Scan sessions incrementally — only include files modified after cutoff
+pub fn scan_sessions_after(
     project_path: &str,
     after: Option<DateTime<Utc>>,
 ) -> Result<Vec<Value>, String> {
@@ -24,19 +26,21 @@ pub fn scan_project_sessions_incremental(
     for entry in scan_jsonl_files(&sessions_dir) {
         let path = entry.path();
 
-        // Skip files that haven't been modified since last scan
+        // Skip unmodified files
         if let Some(cutoff) = after {
             if let Ok(metadata) = std::fs::metadata(path) {
                 if let Ok(modified) = metadata.modified() {
                     let modified_datetime: DateTime<Utc> = modified.into();
                     if modified_datetime <= cutoff {
-                        continue; // Skip this file
+                        continue;
                     }
                 }
             }
         }
 
         let file_path = path.to_string_lossy().to_string();
+
+        // Read first line and parse JSON
         match read_first_line(path) {
             Ok(line) => {
                 if let Ok(value) = serde_json::from_str::<Value>(&line) {
@@ -57,6 +61,7 @@ pub fn scan_project_sessions_incremental(
         }
     }
 
+    // Sort newest first
     results.sort_by(|a, b| {
         let a_dt = extract_datetime(a["path"].as_str().unwrap_or_default());
         let b_dt = extract_datetime(b["path"].as_str().unwrap_or_default());
@@ -71,6 +76,7 @@ pub fn scan_project_sessions_incremental(
     Ok(results)
 }
 
+/// Scan all projects that appear in sessions folder
 #[tauri::command]
 pub async fn scan_projects() -> Result<Vec<Value>, String> {
     let sessions_dir = get_sessions_path()?;
@@ -79,6 +85,7 @@ pub async fn scan_projects() -> Result<Vec<Value>, String> {
     for entry in scan_jsonl_files(&sessions_dir) {
         let file_path = entry.path().to_path_buf();
 
+        // Filter out invalid small files
         match count_lines(&file_path) {
             Ok(line_count) if line_count < 4 => {
                 eprintln!("Deleting file with {} lines: {:?}", line_count, file_path);
@@ -87,15 +94,15 @@ pub async fn scan_projects() -> Result<Vec<Value>, String> {
                 }
                 continue;
             }
-            Ok(_) => { /* File has enough lines, proceed */ }
+            Ok(_) => {}
             Err(e) => {
                 eprintln!("Failed to count lines for {:?}: {}", file_path, e);
                 continue;
             }
         }
 
         let mut project_path: Option<String> = None;
-        match read_first_line(file_path.clone()) {
+        match read_first_line(&file_path) {
             Ok(line) => {
                 if let Ok(value) = serde_json::from_str::<Value>(&line) {
                     if let Some(cwd) = value["payload"]["cwd"].as_str() {
@@ -116,10 +123,10 @@ pub async fn scan_projects() -> Result<Vec<Value>, String> {
         .map(|path| {
             json!({
                 "path": path,
-                "trust_level": Some("no"),
+                "trust_level": "no",
             })
         })
         .collect();
 
     Ok(results)
-}
+}

src-tauri/src/session_files/scan.rs renamed to src-tauri/src/session_files/scanner.rs

@@ -1,4 +1,4 @@
-import { useMemo, type SetStateAction, type Dispatch } from "react";
+import { useMemo, useEffect, type SetStateAction, type Dispatch } from "react";
 import { Button } from "@/components/ui/button";
 import { Trash2, MoreVertical, Star, StarOff, FolderPlus } from "lucide-react";
 import { invoke } from "@tauri-apps/api/core";
@@ -8,7 +8,7 @@ import {
   DropdownMenuItem,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu"
-import { useConversationListStore } from "@/stores/useConversationListStore";
+import { useConversationListStore, loadProjectSessions } from "@/stores/useConversationListStore";
 import { useCodexStore } from "@/stores/useCodexStore";
 import { useActiveConversationStore } from "@/stores/useActiveConversationStore";
 import { Checkbox } from "@/components/ui/checkbox";
@@ -42,6 +42,13 @@ export function ConversationList({
   const { activeConversationId, setActiveConversationId } = useActiveConversationStore();
   const { cwd } = useCodexStore();
 
+  useEffect(() => {
+    if (cwd) {
+      console.log("cwd", cwd)
+      loadProjectSessions(cwd);
+    }
+  }, [cwd]);
+
   const favoriteIds = useMemo(() => {
     const list = favoriteConversationIdsByCwd[cwd || ""] ?? [];
     return new Set(list);
@@ -145,9 +152,9 @@ export function ConversationList({
                     </div>
                     <DropdownMenuContent align="end">
                       <DropdownMenuItem
-                        onClick={(event) => {
+                        onClick={async (event) => {
                           event.stopPropagation();
-                          toggleFavorite(conv.conversationId);
+                          await toggleFavorite(conv.conversationId);
                         }}
                       >
                         {isFavorite ? (