Add file selection feature

- Space toggles selection at cursor
- Shift+arrows/click for range selection with shrink support
- Cmd+A / Cmd+Shift+A for select/deselect all
- Selection preserved on sort, cleared on navigation
- Yellow highlight for selected files
- MCP tools: selection_clear, selection_selectAll, etc.

Author: vdavid

apps/desktop/scripts/check-type-drift.ts

@@ -545,7 +545,10 @@ function typesAreCompatible(expected: string, actual: string): boolean {
 function rustVariantToTsValue(variantName: string, renameAll?: string): string {
     if (renameAll === 'snake_case') {
         // PascalCase to snake_case
-        return variantName.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '')
+        return variantName
+            .replace(/([A-Z])/g, '_$1')
+            .toLowerCase()
+            .replace(/^_/, '')
     }
     if (renameAll === 'camelCase') {
         // PascalCase to camelCase

apps/desktop/src-tauri/src/commands/file_system.rs

@@ -113,20 +113,26 @@ pub fn cancel_listing(listing_id: String) {
 /// * `sort_order` - Ascending or descending.
 /// * `cursor_filename` - Optional filename to track; returns its new index after sorting.
 /// * `include_hidden` - Whether to include hidden files when calculating cursor index.
+/// * `selected_indices` - Optional indices of selected files to track through re-sort.
+/// * `all_selected` - If true, all files are selected (optimization).
 #[tauri::command]
 pub fn resort_listing(
     listing_id: String,
     sort_by: SortColumn,
     sort_order: SortOrder,
     cursor_filename: Option<String>,
     include_hidden: bool,
+    selected_indices: Option<Vec<usize>>,
+    all_selected: Option<bool>,
 ) -> Result<ResortResult, String> {
     ops_resort_listing(
         &listing_id,
         sort_by,
         sort_order,
         cursor_filename.as_deref(),
         include_hidden,
+        selected_indices.as_deref(),
+        all_selected.unwrap_or(false),
     )
 }
 

apps/desktop/src-tauri/src/file_system/operations.rs

@@ -773,6 +773,9 @@ pub struct ResortResult {
     /// New index of the file that was at the cursor position before re-sorting.
     /// None if the filename wasn't provided or wasn't found.
     pub new_cursor_index: Option<usize>,
+    /// New indices of previously selected files after re-sorting.
+    /// None if no selected_indices were provided.
+    pub new_selected_indices: Option<Vec<usize>>,
 }
 
 /// Re-sorts an existing cached listing in-place.
@@ -785,22 +788,44 @@ pub struct ResortResult {
 /// * `sort_order` - Ascending or descending
 /// * `cursor_filename` - Optional filename to track; returns its new index after sorting
 /// * `include_hidden` - Whether to include hidden files when calculating cursor index
+/// * `selected_indices` - Optional indices of selected files to track through re-sort
+/// * `all_selected` - If true, all files are selected (optimization to avoid passing huge arrays)
 ///
 /// # Returns
-/// A `ResortResult` with the new cursor index (if filename was provided and found).
+/// A `ResortResult` with the new cursor index and new selected indices.
 pub fn resort_listing(
     listing_id: &str,
     sort_by: SortColumn,
     sort_order: SortOrder,
     cursor_filename: Option<&str>,
     include_hidden: bool,
+    selected_indices: Option<&[usize]>,
+    all_selected: bool,
 ) -> Result<ResortResult, String> {
     let mut cache = LISTING_CACHE.write().map_err(|_| "Failed to acquire cache lock")?;
 
     let listing = cache
         .get_mut(listing_id)
         .ok_or_else(|| format!("Listing not found: {}", listing_id))?;
 
+    // Collect filenames of selected files before re-sorting
+    let selected_filenames: Option<Vec<String>> = if all_selected {
+        // All files selected - we'll rebuild the full set after sort
+        None
+    } else {
+        selected_indices.map(|indices| {
+            let entries_for_index = if include_hidden {
+                listing.entries.iter().collect::<Vec<_>>()
+            } else {
+                listing.entries.iter().filter(|e| !e.name.starts_with('.')).collect()
+            };
+            indices
+                .iter()
+                .filter_map(|&idx| entries_for_index.get(idx).map(|e| e.name.clone()))
+                .collect()
+        })
+    };
+
     // Re-sort the entries
     sort_entries(&mut listing.entries, sort_by, sort_order);
     listing.sort_by = sort_by;
@@ -819,7 +844,33 @@ pub fn resort_listing(
         }
     });
 
-    Ok(ResortResult { new_cursor_index })
+    // Find new indices of selected files
+    let new_selected_indices = if all_selected {
+        // All files are still selected after re-sort
+        let count = if include_hidden {
+            listing.entries.len()
+        } else {
+            listing.entries.iter().filter(|e| !e.name.starts_with('.')).count()
+        };
+        Some((0..count).collect())
+    } else {
+        selected_filenames.map(|filenames| {
+            let entries_for_lookup: Vec<_> = if include_hidden {
+                listing.entries.iter().collect()
+            } else {
+                listing.entries.iter().filter(|e| !e.name.starts_with('.')).collect()
+            };
+            filenames
+                .iter()
+                .filter_map(|name| entries_for_lookup.iter().position(|e| e.name == *name))
+                .collect()
+        })
+    };
+
+    Ok(ResortResult {
+        new_cursor_index,
+        new_selected_indices,
+    })
 }
 
 // ============================================================================

apps/desktop/src-tauri/src/mcp/executor.rs

@@ -55,6 +55,8 @@ pub fn execute_tool<R: Runtime>(app: &AppHandle<R>, name: &str, params: &Value)
         n if n.starts_with("file_") => execute_file_command(app, n),
         // Volume commands
         n if n.starts_with("volume_") => execute_volume_command(app, n, params),
+        // Selection commands
+        n if n.starts_with("selection_") => execute_selection_command(app, n, params),
         // Context commands
         n if n.starts_with("context_") => execute_context_command(app, n),
         _ => Err(ToolError::invalid_params(format!("Unknown tool: {name}"))),
@@ -229,6 +231,51 @@ fn execute_volume_command<R: Runtime>(app: &AppHandle<R>, name: &str, params: &V
     }
 }
 
+/// Execute a selection command.
+/// These emit events to the frontend to manipulate file selection.
+fn execute_selection_command<R: Runtime>(app: &AppHandle<R>, name: &str, params: &Value) -> ToolResult {
+    match name {
+        "selection_clear" => {
+            app.emit("mcp-selection", json!({"action": "clear"}))
+                .map_err(|e| ToolError::internal(e.to_string()))?;
+            Ok(json!({"success": true, "action": "clear"}))
+        }
+        "selection_selectAll" => {
+            app.emit("mcp-selection", json!({"action": "selectAll"}))
+                .map_err(|e| ToolError::internal(e.to_string()))?;
+            Ok(json!({"success": true, "action": "selectAll"}))
+        }
+        "selection_deselectAll" => {
+            app.emit("mcp-selection", json!({"action": "deselectAll"}))
+                .map_err(|e| ToolError::internal(e.to_string()))?;
+            Ok(json!({"success": true, "action": "deselectAll"}))
+        }
+        "selection_toggleAtCursor" => {
+            app.emit("mcp-selection", json!({"action": "toggleAtCursor"}))
+                .map_err(|e| ToolError::internal(e.to_string()))?;
+            Ok(json!({"success": true, "action": "toggleAtCursor"}))
+        }
+        "selection_selectRange" => {
+            let start_index = params
+                .get("startIndex")
+                .and_then(|v| v.as_i64())
+                .ok_or_else(|| ToolError::invalid_params("Missing 'startIndex' parameter"))?;
+            let end_index = params
+                .get("endIndex")
+                .and_then(|v| v.as_i64())
+                .ok_or_else(|| ToolError::invalid_params("Missing 'endIndex' parameter"))?;
+
+            app.emit(
+                "mcp-selection",
+                json!({"action": "selectRange", "startIndex": start_index, "endIndex": end_index}),
+            )
+            .map_err(|e| ToolError::internal(e.to_string()))?;
+            Ok(json!({"success": true, "action": "selectRange", "startIndex": start_index, "endIndex": end_index}))
+        }
+        _ => Err(ToolError::invalid_params(format!("Unknown selection command: {name}"))),
+    }
+}
+
 /// Execute a context command.
 fn execute_context_command<R: Runtime>(app: &AppHandle<R>, name: &str) -> ToolResult {
     let store = app

apps/desktop/src-tauri/src/mcp/pane_state.rs

@@ -34,6 +34,9 @@ pub struct PaneState {
     pub cursor_index: usize,
     /// View mode (brief or full)
     pub view_mode: String,
+    /// Indices of selected files
+    #[serde(default)]
+    pub selected_indices: Vec<usize>,
 }
 
 /// Shared state for both panes.
@@ -122,6 +125,7 @@ mod tests {
             }],
             cursor_index: 0,
             view_mode: "brief".to_string(),
+            selected_indices: vec![],
         };
 
         store.set_left(state.clone());

apps/desktop/src-tauri/src/mcp/resources.rs

@@ -82,6 +82,12 @@ pub fn get_all_resources() -> Vec<Resource> {
             description: "List of available volumes (favorites, main volume, attached volumes, cloud drives). Each volume has an index for use with volume_selectLeft/volume_selectRight tools.".to_string(),
             mime_type: "application/json".to_string(),
         },
+        Resource {
+            uri: "cmdr://selection".to_string(),
+            name: "Selected files".to_string(),
+            description: "List of selected file indices in the focused pane".to_string(),
+            mime_type: "application/json".to_string(),
+        },
     ]
 }
 
@@ -149,6 +155,22 @@ pub fn read_resource<R: Runtime>(app: &tauri::AppHandle<R>, uri: &str) -> Result
             (json!({ "cursor": file_under_cursor }), "application/json")
         }
         "cmdr://status" => (json!({ "status": "ok", "app": "cmdr" }), "application/json"),
+        "cmdr://selection" => {
+            let focused = store.get_focused_pane();
+            let state = if focused == "left" {
+                store.get_left()
+            } else {
+                store.get_right()
+            };
+            (
+                json!({
+                    "pane": focused,
+                    "selectedIndices": state.selected_indices,
+                    "count": state.selected_indices.len()
+                }),
+                "application/json",
+            )
+        }
         #[cfg(target_os = "macos")]
         "cmdr://volumes" => {
             let locations = volumes::list_locations();
@@ -186,9 +208,9 @@ mod tests {
     fn test_resource_count() {
         let resources = get_all_resources();
         #[cfg(target_os = "macos")]
-        assert_eq!(resources.len(), 8);
+        assert_eq!(resources.len(), 9); // 8 base + 1 selection
         #[cfg(not(target_os = "macos"))]
-        assert_eq!(resources.len(), 7);
+        assert_eq!(resources.len(), 8); // 7 base + 1 selection
     }
 
     #[test]

apps/desktop/src-tauri/src/mcp/tests.rs

@@ -105,12 +105,12 @@ fn test_tool_input_schemas_are_valid() {
 #[test]
 fn test_total_tool_count() {
     let tools = get_all_tools();
-    // 3 app + 3 view + 1 pane + 12 nav + 8 sort + 5 file + 2 volume = 34
+    // 3 app + 3 view + 1 pane + 12 nav + 8 sort + 5 file + 2 volume + 5 selection = 39
     // (context tools and volume_list moved to resources)
     assert_eq!(
         tools.len(),
-        34,
-        "Expected 34 tools, got {}. Did you add/remove tools?",
+        39,
+        "Expected 39 tools, got {}. Did you add/remove tools?",
         tools.len()
     );
 }
@@ -133,9 +133,9 @@ fn test_no_duplicate_tool_names() {
 fn test_resource_count() {
     let resources = get_all_resources();
     #[cfg(target_os = "macos")]
-    assert_eq!(resources.len(), 8, "Expected 8 resources");
+    assert_eq!(resources.len(), 9, "Expected 9 resources");
     #[cfg(not(target_os = "macos"))]
-    assert_eq!(resources.len(), 7, "Expected 7 resources");
+    assert_eq!(resources.len(), 8, "Expected 8 resources");
 }
 
 #[test]
@@ -542,6 +542,7 @@ fn test_pane_state_store_update_left() {
         }],
         cursor_index: 0,
         view_mode: "brief".to_string(),
+        selected_indices: vec![],
     };
 
     store.set_left(state.clone());
@@ -593,6 +594,7 @@ fn test_pane_state_cursor_index_bounds() {
         }],
         cursor_index: 999, // Out of bounds
         view_mode: "brief".to_string(),
+        selected_indices: vec![],
     };
 
     store.set_left(state);
@@ -711,6 +713,7 @@ fn test_empty_file_list() {
         files: vec![],
         cursor_index: 0,
         view_mode: "brief".to_string(),
+        selected_indices: vec![],
     };
 
     let json = serde_json::to_value(&state).unwrap();
@@ -736,6 +739,7 @@ fn test_large_file_count() {
         files,
         cursor_index: 500,
         view_mode: "full".to_string(),
+        selected_indices: vec![1, 5, 10], // Some selected files
     };
 
     // Should serialize reasonably fast

apps/desktop/src-tauri/src/mcp/tools.rs

@@ -135,6 +135,37 @@ fn get_volume_tools() -> Vec<Tool> {
     ]
 }
 
+/// Get selection tools.
+fn get_selection_tools() -> Vec<Tool> {
+    vec![
+        Tool::no_params("selection_clear", "Clear all selected files in the focused pane"),
+        Tool::no_params("selection_selectAll", "Select all files in the focused pane"),
+        Tool::no_params("selection_deselectAll", "Deselect all files in the focused pane"),
+        Tool::no_params(
+            "selection_toggleAtCursor",
+            "Toggle selection of the file under the cursor",
+        ),
+        Tool {
+            name: "selection_selectRange".to_string(),
+            description: "Select a range of files by index".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "startIndex": {
+                        "type": "integer",
+                        "description": "Start index (inclusive)"
+                    },
+                    "endIndex": {
+                        "type": "integer",
+                        "description": "End index (inclusive)"
+                    }
+                },
+                "required": ["startIndex", "endIndex"]
+            }),
+        },
+    ]
+}
+
 /// Get all available tools.
 pub fn get_all_tools() -> Vec<Tool> {
     let mut tools = Vec::new();
@@ -145,6 +176,7 @@ pub fn get_all_tools() -> Vec<Tool> {
     tools.extend(get_sort_tools());
     tools.extend(get_file_tools());
     tools.extend(get_volume_tools());
+    tools.extend(get_selection_tools());
     tools
 }
 
@@ -173,9 +205,15 @@ mod tests {
     #[test]
     fn test_all_tools_count() {
         let tools = get_all_tools();
-        // 3 app + 3 view + 1 pane + 12 nav + 8 sort + 5 file + 2 volume = 34
+        // 3 app + 3 view + 1 pane + 12 nav + 8 sort + 5 file + 2 volume + 5 selection = 39
         // (context tools and volume_list moved to resources)
-        assert_eq!(tools.len(), 34);
+        assert_eq!(tools.len(), 39);
+    }
+
+    #[test]
+    fn test_selection_tools_count() {
+        let tools = get_selection_tools();
+        assert_eq!(tools.len(), 5);
     }
 
     #[test]