feat: persist project selection

src-tauri/src/commands/fs.rs

@@ -1,8 +1,13 @@
 use crate::state::SessionState;
 use serde::Serialize;
+use serde_json::json;
 use std::fs;
 use std::path::PathBuf;
-use tauri::State;
+use tauri::{AppHandle, State};
+use tauri_plugin_store::StoreExt;
+
+const STORE_PATH: &str = "store.json";
+const KEY_LAST_PROJECT: &str = "last_project_path";
 
 // -----------------------------------------------------------------------------
 // Helper Functions
@@ -32,7 +37,11 @@ fn resolve_path(state: &State<'_, SessionState>, relative_path: &str) -> Result<
 // -----------------------------------------------------------------------------
 
 #[tauri::command]
-pub async fn open_project(path: String, state: State<'_, SessionState>) -> Result<String, String> {
+pub async fn open_project(
+    app: AppHandle,
+    path: String,
+    state: State<'_, SessionState>,
+) -> Result<String, String> {
     let p = PathBuf::from(&path);
 
     // Validate path existence in blocking thread
@@ -49,13 +58,73 @@ pub async fn open_project(path: String, state: State<'_, SessionState>) -> Resul
     .await
     .map_err(|e| format!("Task failed: {}", e))??;
 
-    let mut root = state.project_root.lock().map_err(|e| e.to_string())?;
-    *root = Some(p.clone());
+    {
+        let mut root = state.project_root.lock().map_err(|e| e.to_string())?;
+        *root = Some(p.clone());
+    }
+
+    // Persist to store
+    let store = app
+        .store(STORE_PATH)
+        .map_err(|e| format!("Failed to access store: {}", e))?;
+    store.set(KEY_LAST_PROJECT, json!(path));
+    let _ = store.save();
 
     println!("Project opened: {:?}", p);
     Ok(path)
 }
 
+#[tauri::command]
+pub async fn close_project(app: AppHandle, state: State<'_, SessionState>) -> Result<(), String> {
+    // Clear session state
+    {
+        let mut root = state.project_root.lock().map_err(|e| e.to_string())?;
+        *root = None;
+    }
+
+    // Clear from store
+    let store = app
+        .store(STORE_PATH)
+        .map_err(|e| format!("Failed to access store: {}", e))?;
+    store.delete(KEY_LAST_PROJECT);
+    let _ = store.save();
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn get_current_project(
+    app: AppHandle,
+    state: State<'_, SessionState>,
+) -> Result<Option<String>, String> {
+    // 1. Check in-memory state
+    {
+        let root = state.project_root.lock().map_err(|e| e.to_string())?;
+        if let Some(path) = &*root {
+            return Ok(Some(path.to_string_lossy().to_string()));
+        }
+    }
+
+    // 2. Check store
+    let store = app
+        .store(STORE_PATH)
+        .map_err(|e| format!("Failed to access store: {}", e))?;
+
+    if let Some(val) = store.get(KEY_LAST_PROJECT) {
+        if let Some(path_str) = val.as_str() {
+            let p = PathBuf::from(path_str);
+            if p.exists() && p.is_dir() {
+                // Update session state
+                let mut root = state.project_root.lock().map_err(|e| e.to_string())?;
+                *root = Some(p.clone());
+                return Ok(Some(path_str.to_string()));
+            }
+        }
+    }
+
+    Ok(None)
+}
+
 #[tauri::command]
 pub async fn read_file(path: String, state: State<'_, SessionState>) -> Result<String, String> {
     let full_path = resolve_path(&state, &path)?;

src-tauri/src/lib.rs

@@ -9,9 +9,12 @@ pub fn run() {
     tauri::Builder::default()
         .plugin(tauri_plugin_opener::init())
         .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_store::Builder::default().build())
         .manage(SessionState::default())
         .invoke_handler(tauri::generate_handler![
             commands::fs::open_project,
+            commands::fs::close_project,
+            commands::fs::get_current_project,
             commands::fs::read_file,
             commands::fs::write_file,
             commands::fs::list_directory,