feat: add Rust backend modules for file operations and project management

Add new IPC command modules that complement the existing fs module:

- models.rs: Shared data models (FileContent, ProjectConfig, ProjectInfo)
  with serde serialization and re-exports of FileEntry/FileMetadata

- fs_commands.rs: Additional file system commands
  - read_file: Returns FileContent with chardetng+encoding_rs encoding detection
  - delete_entry: Unified file/directory delete with cache invalidation

- project.rs: Project management commands
  - open_project: Native folder picker via tauri_plugin_dialog DialogExt
  - get_recent_projects: Load from app data dir with in-memory caching
  - save_recent_project: Persist to recent_projects.json with LRU limit

- commands/mod.rs: Command registry documentation and re-exports

All commands use async tokio I/O, path validation security, and follow
the existing cortex_commands! macro-chain registration pattern.

Author: echobt

src-tauri/src/app/mod.rs

@@ -453,6 +453,7 @@ pub fn register_state(
         .manage(crate::extensions::api::debug::DebugApiState::new())
         .manage(crate::extensions::api::scm::ScmApiState::new())
         .manage(crate::workspace::manager::WorkspaceManagerState::new())
+        .manage(Arc::new(crate::project::ProjectState::new()))
         .manage(crate::remote::port_forwarding::PortForwardingState::new())
         .manage(LazyState::new(SandboxState::new))
         .manage(crate::remote::tunnel::TunnelState::new())

src-tauri/src/app/workspace_commands.rs

@@ -147,6 +147,13 @@ macro_rules! workspace_commands {
             $crate::fs::fs_get_supported_encodings,
             // Workspace edit support
             $crate::fs::apply_workspace_edit,
+            // Unified file commands (fs_commands module)
+            $crate::fs_commands::read_file,
+            $crate::fs_commands::delete_entry,
+            // Project management commands
+            $crate::project::open_project,
+            $crate::project::get_recent_projects,
+            $crate::project::save_recent_project,
             // Batch command system for IPC optimization
             $crate::batch_ipc::batch_invoke,
             $crate::batch::batch_commands,

src-tauri/src/commands/mod.rs

@@ -0,0 +1,37 @@
+//! Command Registry — Central reference for all Tauri IPC commands.
+//!
+//! Cortex Desktop uses a macro-chain pattern defined in `app/mod.rs` to
+//! register commands with `tauri::generate_handler![]`. Each feature area
+//! has its own `*_commands.rs` file under `app/` that contributes commands
+//! to the chain via the `cortex_commands!` macro.
+//!
+//! ## Command Groups
+//!
+//! | Group | File | Description |
+//! |-------|------|-------------|
+//! | AI | `app/ai_commands.rs` | AI providers, agents, sessions, completions |
+//! | Collab | `app/collab_commands.rs` | Real-time collaboration (CRDT, WebSocket) |
+//! | Editor | `app/editor_commands.rs` | Folding, symbols, refactoring, snippets |
+//! | Extension | `app/extension_commands.rs` | Extension lifecycle, marketplace, WASM/Node host |
+//! | Git | `app/git_commands.rs` | Git operations (branch, commit, diff, merge, etc.) |
+//! | I18n | `app/i18n_commands.rs` | Internationalization and locale detection |
+//! | Misc | `app/misc_commands.rs` | Server, notifications, updates, MCP, window, WSL |
+//! | Notebook | `app/notebook_commands.rs` | Jupyter-style notebook kernels |
+//! | Remote | `app/remote_commands.rs` | SSH remote development |
+//! | Settings | `app/settings_commands.rs` | User/workspace settings, profiles, sync |
+//! | Terminal | `app/terminal_commands.rs` | PTY terminal management |
+//! | Workspace | `app/workspace_commands.rs` | FS ops, search, testing, tasks, projects |
+//!
+//! ## Adding New Commands
+//!
+//! 1. Define `#[tauri::command]` functions in the appropriate module.
+//! 2. Add the command paths to the matching `*_commands.rs` macro.
+//! 3. If creating a new group, add a new `*_commands.rs` file and insert
+//!    a chain step in `app/mod.rs`.
+//!
+//! ## Re-exports
+//!
+//! This module re-exports key command-bearing modules for discoverability.
+
+pub use crate::fs_commands::{delete_entry, read_file};
+pub use crate::project::{get_recent_projects, open_project, save_recent_project};

src-tauri/src/fs_commands.rs

@@ -0,0 +1,101 @@
+//! File System Commands — Unified IPC commands for file operations.
+//!
+//! This module provides additional Tauri commands that complement the
+//! existing `fs` module. It adds:
+//! - `read_file` — returns `FileContent` with encoding detection
+//! - `delete_entry` — unified delete for files and directories
+//!
+//! The bulk of file system operations (`fs_read_file`, `fs_write_file`,
+//! `fs_create_file`, `fs_create_directory`, `fs_rename`, `fs_get_metadata`,
+//! `fs_watch_directory`, etc.) are defined in the `fs` module and registered
+//! via `workspace_commands!`.
+
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use tauri::{AppHandle, Manager};
+use tracing::info;
+
+use crate::fs::security::{validate_path_for_delete, validate_path_for_read};
+use crate::fs::types::DirectoryCache;
+use crate::models::FileContent;
+
+/// Read a file and return its content with encoding metadata.
+///
+/// Uses `chardetng` + `encoding_rs` to detect the file encoding and decode
+/// the content accordingly. Returns a `FileContent` struct containing the
+/// decoded text, detected encoding name, file size, and path.
+#[tauri::command]
+pub async fn read_file(path: String) -> Result<FileContent, String> {
+    let file_path = PathBuf::from(&path);
+    let validated_path = validate_path_for_read(&file_path)?;
+
+    if !validated_path.exists() {
+        return Err(format!("File does not exist: {}", path));
+    }
+
+    if !validated_path.is_file() {
+        return Err(format!("Path is not a file: {}", path));
+    }
+
+    let bytes = tokio::fs::read(&validated_path)
+        .await
+        .map_err(|e| format!("Failed to read file: {}", e))?;
+
+    let size = bytes.len() as u64;
+
+    // Detect encoding via BOM first, then chardetng
+    let (encoding, content) = if let Some((enc, _bom_len)) = encoding_rs::Encoding::for_bom(&bytes)
+    {
+        let (decoded, _, _) = enc.decode(&bytes);
+        (enc.name().to_string(), decoded.into_owned())
+    } else {
+        let mut detector = chardetng::EncodingDetector::new();
+        detector.feed(&bytes, true);
+        let enc = detector.guess(None, true);
+        let (decoded, _, _) = enc.decode(&bytes);
+        (enc.name().to_string(), decoded.into_owned())
+    };
+
+    Ok(FileContent {
+        content,
+        encoding,
+        size,
+        path,
+    })
+}
+
+/// Delete a file or directory at the given path.
+///
+/// For directories, performs a recursive delete. Invalidates the directory
+/// cache for the parent path and (for directories) any cached subtrees.
+#[tauri::command]
+pub async fn delete_entry(app: AppHandle, path: String) -> Result<(), String> {
+    let entry_path = PathBuf::from(&path);
+    let validated_path = validate_path_for_delete(&entry_path)?;
+
+    if !validated_path.exists() {
+        return Ok(());
+    }
+
+    let cache = app.state::<Arc<DirectoryCache>>();
+
+    if let Some(parent) = validated_path.parent() {
+        cache.invalidate(&parent.to_string_lossy());
+    }
+
+    if validated_path.is_dir() {
+        cache.invalidate_prefix(&path);
+        tokio::fs::remove_dir_all(&validated_path)
+            .await
+            .map_err(|e| format!("Failed to delete directory: {}", e))?;
+        info!("Deleted directory: {}", path);
+    } else {
+        tokio::fs::remove_file(&validated_path)
+            .await
+            .map_err(|e| format!("Failed to delete file: {}", e))?;
+        info!("Deleted file: {}", path);
+    }
+
+    Ok(())
+}

src-tauri/src/lib.rs

@@ -14,6 +14,7 @@ mod batch;
 mod batch_ipc;
 mod browser;
 mod collab;
+mod commands;
 mod context_server;
 mod cortex_engine;
 mod cortex_protocol;
@@ -27,15 +28,18 @@ mod extensions;
 mod factory;
 mod formatter;
 mod fs;
+mod fs_commands;
 mod git;
 mod i18n;
 mod keybindings;
 mod language_selector;
 mod lsp;
 mod mcp;
+mod models;
 mod notebook;
 mod process;
 mod process_utils;
+mod project;
 mod prompt_store;
 mod remote;
 mod repl;

src-tauri/src/models.rs

@@ -0,0 +1,41 @@
+//! Shared data models for the Cortex Desktop backend.
+//!
+//! This module provides serde-serializable structs used across IPC commands.
+//! Core file system types (`FileEntry`, `FileMetadata`) live in `fs::types`
+//! and are re-exported here for convenience.
+
+use serde::{Deserialize, Serialize};
+
+// Re-export core file system types from the fs module
+pub use crate::fs::types::{FileEntry, FileMetadata};
+
+/// File content returned by `read_file`, including encoding metadata.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FileContent {
+    pub content: String,
+    pub encoding: String,
+    pub size: u64,
+    pub path: String,
+}
+
+/// Project configuration stored alongside a project.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProjectConfig {
+    pub name: String,
+    pub root_path: String,
+    #[serde(default)]
+    pub excluded_paths: Vec<String>,
+    #[serde(default)]
+    pub settings: serde_json::Value,
+}
+
+/// Information about an opened or recent project.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProjectInfo {
+    pub name: String,
+    pub path: String,
+    pub last_opened: u64,
+}