feat: add global cross-project session search to projects view

Add a search bar to the ProjectList that filters projects by name
(instant, client-side) and searches across all projects' sessions
(debounced backend call). Results are grouped by project with
expandable accordion snippets, highlighting, and action buttons.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Jose Monteiro

src-tauri/src/commands/claude.rs

@@ -997,6 +997,153 @@ pub async fn search_project_sessions(
     .map_err(|e| format!("Search task failed: {}", e))?
 }
 
+/// Searches through all projects' session JSONL files for messages containing the query
+#[tauri::command]
+pub async fn search_all_sessions(query: String) -> Result<Vec<SessionSearchResult>, String> {
+    let query = query.trim().to_string();
+    if query.is_empty() || query.len() < 2 {
+        return Ok(Vec::new());
+    }
+    if query.len() > 256 {
+        return Err("Query is too long".to_string());
+    }
+
+    log::info!(
+        "Searching all sessions across all projects (query length: {})",
+        query.len()
+    );
+
+    let parsed = parse_query(&query);
+    if parsed.and_terms.is_empty() && parsed.or_groups.is_empty() && parsed.not_terms.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let claude_dir = get_claude_dir().map_err(|e| e.to_string())?;
+    let projects_dir = claude_dir.join("projects");
+
+    if !projects_dir.exists() {
+        return Ok(Vec::new());
+    }
+
+    let todos_dir = claude_dir.join("todos");
+
+    tokio::task::spawn_blocking(move || {
+        const MAX_RESULTS: usize = 100;
+
+        let mut results: Vec<SessionSearchResult> = Vec::new();
+
+        let project_entries = fs::read_dir(&projects_dir)
+            .map_err(|e| format!("Failed to read projects directory: {}", e))?;
+
+        for project_entry in project_entries {
+            if results.len() >= MAX_RESULTS {
+                break;
+            }
+
+            let project_entry = match project_entry {
+                Ok(e) => e,
+                Err(_) => continue,
+            };
+            let project_dir = project_entry.path();
+            if !project_dir.is_dir() {
+                continue;
+            }
+
+            let project_id = match project_dir.file_name().and_then(|n| n.to_str()) {
+                Some(name) => name.to_string(),
+                None => continue,
+            };
+
+            let project_path = match get_project_path_from_sessions(&project_dir) {
+                Ok(path) => path,
+                Err(_) => decode_project_path(&project_id),
+            };
+
+            let session_entries = match fs::read_dir(&project_dir) {
+                Ok(entries) => entries,
+                Err(_) => continue,
+            };
+
+            for entry in session_entries {
+                if results.len() >= MAX_RESULTS {
+                    break;
+                }
+
+                let entry = match entry {
+                    Ok(e) => e,
+                    Err(_) => continue,
+                };
+                let file_type = match entry.file_type() {
+                    Ok(ft) => ft,
+                    Err(_) => continue,
+                };
+                if file_type.is_symlink() || !file_type.is_file() {
+                    continue;
+                }
+                let path = entry.path();
+
+                if path.extension().and_then(|s| s.to_str()) == Some("jsonl") {
+                    if let Some(session_id) = path.file_stem().and_then(|s| s.to_str()) {
+                        if !session_matches(&path, &parsed) {
+                            continue;
+                        }
+                        let snippets = extract_snippets_for_terms(&path, &parsed.highlight_terms);
+
+                        let metadata = match fs::metadata(&path) {
+                            Ok(m) => m,
+                            Err(_) => continue,
+                        };
+
+                        let created_at = metadata
+                            .created()
+                            .or_else(|_| metadata.modified())
+                            .unwrap_or(SystemTime::UNIX_EPOCH)
+                            .duration_since(SystemTime::UNIX_EPOCH)
+                            .unwrap_or_default()
+                            .as_secs();
+
+                        let (first_message, message_timestamp) = extract_first_user_message(&path);
+
+                        let todo_path = todos_dir.join(format!("{}.json", session_id));
+                        let todo_data = if todo_path.exists() {
+                            fs::read_to_string(&todo_path)
+                                .ok()
+                                .and_then(|content| serde_json::from_str(&content).ok())
+                        } else {
+                            None
+                        };
+
+                        results.push(SessionSearchResult {
+                            session: Session {
+                                id: session_id.to_string(),
+                                project_id: project_id.clone(),
+                                project_path: project_path.clone(),
+                                todo_data,
+                                created_at,
+                                first_message,
+                                message_timestamp,
+                            },
+                            snippets,
+                            highlight_terms: parsed.highlight_terms.clone(),
+                        });
+                    }
+                }
+            }
+        }
+
+        results.sort_by(|a, b| b.session.created_at.cmp(&a.session.created_at));
+        results.truncate(MAX_RESULTS);
+
+        log::info!(
+            "Found {} matching sessions across all projects",
+            results.len()
+        );
+        Ok(results)
+    })
+    .await
+    .map_err(|e| format!("Search task failed: {}", e))?
+}
+
 /// Reads the Claude settings file
 #[tauri::command]
 pub async fn get_claude_settings() -> Result<ClaudeSettings, String> {

src-tauri/src/main.rs

@@ -26,8 +26,8 @@ use commands::claude::{
     get_recently_modified_files, get_session_timeline, get_system_prompt, list_checkpoints,
     list_directory_contents, list_projects, list_running_claude_sessions, load_session_history,
     open_new_session, read_claude_md_file, restore_checkpoint, resume_claude_code,
-    save_claude_md_file, save_claude_settings, save_system_prompt, search_files,
-    search_project_sessions, track_checkpoint_message, track_session_messages,
+    save_claude_md_file, save_claude_settings, save_system_prompt, search_all_sessions,
+    search_files, search_project_sessions, track_checkpoint_message, track_session_messages,
     update_checkpoint_settings, update_hooks_config, validate_hook_command, ClaudeProcessState,
 };
 use commands::mcp::{
@@ -189,6 +189,7 @@ fn main() {
             create_project,
             get_project_sessions,
             search_project_sessions,
+            search_all_sessions,
             get_home_directory,
             get_claude_settings,
             open_new_session,

src-tauri/src/web_server.rs

@@ -150,6 +150,20 @@ async fn search_sessions(
     }
 }
 
+/// API endpoint to search sessions across all projects
+async fn search_all_sessions_handler(
+    Query(params): Query<SearchQuery>,
+) -> Json<ApiResponse<Vec<commands::claude::SessionSearchResult>>> {
+    let query = params.query.trim().to_string();
+    if query.is_empty() {
+        return Json(ApiResponse::success(Vec::new()));
+    }
+    match commands::claude::search_all_sessions(query).await {
+        Ok(sessions) => Json(ApiResponse::success(sessions)),
+        Err(e) => Json(ApiResponse::error(e.to_string())),
+    }
+}
+
 /// Simple agents endpoint - return empty for now (needs DB state)
 async fn get_agents() -> Json<ApiResponse<Vec<serde_json::Value>>> {
     Json(ApiResponse::success(vec![]))
@@ -811,6 +825,10 @@ pub async fn create_web_server(port: u16) -> Result<(), Box<dyn std::error::Erro
             "/api/projects/{project_id}/sessions/search",
             get(search_sessions),
         )
+        .route(
+            "/api/sessions/search/global",
+            get(search_all_sessions_handler),
+        )
         .route("/api/agents", get(get_agents))
         .route("/api/usage", get(get_usage))
         // Settings and configuration

src/components/HighlightedText.tsx

@@ -0,0 +1,32 @@
+import React from "react";
+
+/** Highlights all occurrences of `terms` in `text` (case-insensitive, Unicode-safe) */
+export function HighlightedText({ text, terms }: { text: string; terms: string[] }) {
+  if (!terms.length) return <>{text}</>;
+  const escaped = terms
+    .filter(t => t.trim())
+    .map(t => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  if (!escaped.length) return <>{text}</>;
+  const re = new RegExp(escaped.join('|'), 'gi');
+  const parts: React.ReactNode[] = [];
+  let lastIndex = 0;
+  let match: RegExpExecArray | null;
+
+  while ((match = re.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      parts.push(text.slice(lastIndex, match.index));
+    }
+    parts.push(
+      <mark key={match.index} className="bg-primary/30 text-foreground rounded-sm px-0.5">
+        {match[0]}
+      </mark>
+    );
+    lastIndex = match.index + match[0].length;
+  }
+
+  if (lastIndex < text.length) {
+    parts.push(text.slice(lastIndex));
+  }
+
+  return <>{parts}</>;
+}