Merge branch 'main' into feature/cursor-cli-support

Author: njbrake

src/session/instance.rs

@@ -108,12 +108,6 @@ pub struct Instance {
     pub last_start_time: Option<std::time::Instant>,
     #[serde(skip)]
     pub last_error: Option<String>,
-
-    // Search optimization: pre-computed lowercase strings (not serialized)
-    #[serde(skip)]
-    pub title_lower: String,
-    #[serde(skip)]
-    pub project_path_lower: String,
 }
 
 impl Instance {
@@ -136,18 +130,9 @@ impl Instance {
             last_error_check: None,
             last_start_time: None,
             last_error: None,
-            title_lower: title.to_lowercase(),
-            project_path_lower: project_path.to_lowercase(),
         }
     }
 
-    /// Update the pre-computed lowercase fields for search optimization.
-    /// Call this after loading instances from disk or modifying title/path.
-    pub fn update_search_cache(&mut self) {
-        self.title_lower = self.title.to_lowercase();
-        self.project_path_lower = self.project_path.to_lowercase();
-    }
-
     pub fn is_sub_session(&self) -> bool {
         self.parent_session_id.is_some()
     }
@@ -772,25 +757,6 @@ mod tests {
         assert_eq!(inst.get_tool_command(), "claude --resume abc123");
     }
 
-    // Tests for update_search_cache
-    #[test]
-    fn test_update_search_cache() {
-        let mut inst = Instance::new("Test Title", "/Path/To/Project");
-        // Manually modify title
-        inst.title = "New Title".to_string();
-        inst.project_path = "/New/Path".to_string();
-
-        // Cache is stale
-        assert_ne!(inst.title_lower, "new title");
-        assert_ne!(inst.project_path_lower, "/new/path");
-
-        // Update cache
-        inst.update_search_cache();
-
-        assert_eq!(inst.title_lower, "new title");
-        assert_eq!(inst.project_path_lower, "/new/path");
-    }
-
     // Tests for Status enum
     #[test]
     fn test_status_default() {

src/tui/components/help.rs

@@ -6,7 +6,7 @@ use ratatui::widgets::*;
 use crate::tui::styles::Theme;
 
 const DIALOG_WIDTH: u16 = 50;
-const DIALOG_HEIGHT: u16 = 30;
+const DIALOG_HEIGHT: u16 = 31;
 #[cfg(test)]
 const BORDER_HEIGHT: u16 = 2;
 #[cfg(test)]
@@ -50,6 +50,7 @@ fn shortcuts() -> Vec<(&'static str, Vec<(&'static str, &'static str)>)> {
             "Other",
             vec![
                 ("/", "Search"),
+                ("n/N", "Next/prev match"),
                 ("s", "Settings"),
                 ("P", "Next profile"),
                 ("?", "Toggle help"),

src/tui/home/input.rs

@@ -314,22 +314,33 @@ impl HomeView {
                 KeyCode::Esc => {
                     self.search_active = false;
                     self.search_query = Input::default();
-                    self.filtered_items = None;
+                    self.search_matches.clear();
+                    self.search_match_index = 0;
                 }
                 KeyCode::Enter => {
                     self.search_active = false;
+                    self.search_query = Input::default();
+                    self.search_matches.clear();
+                    self.search_match_index = 0;
                 }
                 _ => {
                     self.search_query
                         .handle_event(&crossterm::event::Event::Key(key));
-                    self.update_filter();
+                    self.update_search();
                 }
             }
             return None;
         }
 
         // Normal mode keybindings
         match key.code {
+            KeyCode::Esc => {
+                if !self.search_matches.is_empty() {
+                    self.search_matches.clear();
+                    self.search_match_index = 0;
+                    self.search_query = Input::default();
+                }
+            }
             KeyCode::Char('q') => return Some(Action::Quit),
             KeyCode::Char('?') => {
                 self.show_help = true;
@@ -368,20 +379,38 @@ impl HomeView {
                 self.search_query = Input::default();
             }
             KeyCode::Char('n') => {
-                let existing_titles: Vec<String> =
-                    self.instances.iter().map(|i| i.title.clone()).collect();
-                let existing_groups: Vec<String> = self
-                    .group_tree
-                    .get_all_groups()
-                    .iter()
-                    .map(|g| g.path.clone())
-                    .collect();
-                self.new_dialog = Some(NewSessionDialog::new(
-                    self.available_tools.clone(),
-                    existing_titles,
-                    existing_groups,
-                    self.storage.profile(),
-                ));
+                if !self.search_matches.is_empty() {
+                    self.search_match_index =
+                        (self.search_match_index + 1) % self.search_matches.len();
+                    self.cursor = self.search_matches[self.search_match_index];
+                    self.update_selected();
+                } else {
+                    let existing_titles: Vec<String> =
+                        self.instances.iter().map(|i| i.title.clone()).collect();
+                    let existing_groups: Vec<String> = self
+                        .group_tree
+                        .get_all_groups()
+                        .iter()
+                        .map(|g| g.path.clone())
+                        .collect();
+                    self.new_dialog = Some(NewSessionDialog::new(
+                        self.available_tools.clone(),
+                        existing_titles,
+                        existing_groups,
+                        self.storage.profile(),
+                    ));
+                }
+            }
+            KeyCode::Char('N') => {
+                if !self.search_matches.is_empty() {
+                    self.search_match_index = if self.search_match_index == 0 {
+                        self.search_matches.len() - 1
+                    } else {
+                        self.search_match_index - 1
+                    };
+                    self.cursor = self.search_matches[self.search_match_index];
+                    self.update_selected();
+                }
             }
             KeyCode::Char('s') => {
                 // Open settings view with selected session's project path (if any)
@@ -604,44 +633,30 @@ impl HomeView {
     }
 
     pub(super) fn move_cursor(&mut self, delta: i32) {
-        let items = if let Some(ref filtered) = self.filtered_items {
-            filtered.len()
-        } else {
-            self.flat_items.len()
-        };
-
-        if items == 0 {
+        if self.flat_items.is_empty() {
             return;
         }
 
         let new_cursor = if delta < 0 {
             self.cursor.saturating_sub((-delta) as usize)
         } else {
-            (self.cursor + delta as usize).min(items - 1)
+            (self.cursor + delta as usize).min(self.flat_items.len() - 1)
         };
 
         self.cursor = new_cursor;
         self.update_selected();
     }
 
     pub(super) fn update_selected(&mut self) {
-        let item_idx = if let Some(ref filtered) = self.filtered_items {
-            filtered.get(self.cursor).copied()
-        } else {
-            Some(self.cursor)
-        };
-
-        if let Some(idx) = item_idx {
-            if let Some(item) = self.flat_items.get(idx) {
-                match item {
-                    Item::Session { id, .. } => {
-                        self.selected_session = Some(id.clone());
-                        self.selected_group = None;
-                    }
-                    Item::Group { path, .. } => {
-                        self.selected_session = None;
-                        self.selected_group = Some(path.clone());
-                    }
+        if let Some(item) = self.flat_items.get(self.cursor) {
+            match item {
+                Item::Session { id, .. } => {
+                    self.selected_session = Some(id.clone());
+                    self.selected_group = None;
+                }
+                Item::Group { path, .. } => {
+                    self.selected_session = None;
+                    self.selected_group = Some(path.clone());
                 }
             }
         }
@@ -658,38 +673,111 @@ impl HomeView {
         }
     }
 
-    pub(super) fn update_filter(&mut self) {
-        if self.search_query.value().is_empty() {
-            self.filtered_items = None;
+    /// Re-score matches after a reload without moving the cursor.
+    pub(super) fn refresh_search_matches(&mut self) {
+        let query = self.search_query.value();
+        if query.is_empty() {
+            self.search_matches.clear();
+            self.search_match_index = 0;
             return;
         }
 
-        let query = self.search_query.value().to_lowercase();
-        let mut matches = Vec::new();
+        use nucleo_matcher::pattern::{Atom, AtomKind, CaseMatching, Normalization};
+        use nucleo_matcher::{Config, Matcher, Utf32Str};
+
+        let mut matcher = Matcher::new(Config::DEFAULT.match_paths());
+        let atom = Atom::new(
+            query,
+            CaseMatching::Ignore,
+            Normalization::Smart,
+            AtomKind::Fuzzy,
+            false,
+        );
+
+        let mut scored: Vec<(usize, u16)> = Vec::new();
+        let mut buf = Vec::new();
 
         for (idx, item) in self.flat_items.iter().enumerate() {
-            match item {
+            let haystack = match item {
                 Item::Session { id, .. } => {
                     if let Some(inst) = self.instance_map.get(id) {
-                        if inst.title_lower.contains(&query)
-                            || inst.project_path_lower.contains(&query)
-                        {
-                            matches.push(idx);
-                        }
+                        format!("{} {}", inst.title, inst.project_path)
+                    } else {
+                        continue;
                     }
                 }
                 Item::Group { name, path, .. } => {
-                    if name.to_lowercase().contains(&query) || path.to_lowercase().contains(&query)
-                    {
-                        matches.push(idx);
+                    format!("{} {}", name, path)
+                }
+            };
+
+            let haystack_utf32 = Utf32Str::new(&haystack, &mut buf);
+            if let Some(score) = atom.score(haystack_utf32, &mut matcher) {
+                scored.push((idx, score));
+            }
+        }
+
+        scored.sort_by(|a, b| b.1.cmp(&a.1));
+        self.search_matches = scored.into_iter().map(|(idx, _)| idx).collect();
+        // Clamp match_index in case matches shrank
+        if self.search_matches.is_empty() {
+            self.search_match_index = 0;
+        } else if self.search_match_index >= self.search_matches.len() {
+            self.search_match_index = self.search_matches.len() - 1;
+        }
+    }
+
+    pub(super) fn update_search(&mut self) {
+        self.search_matches.clear();
+        self.search_match_index = 0;
+
+        let query = self.search_query.value();
+        if query.is_empty() {
+            return;
+        }
+
+        use nucleo_matcher::pattern::{Atom, AtomKind, CaseMatching, Normalization};
+        use nucleo_matcher::{Config, Matcher, Utf32Str};
+
+        let mut matcher = Matcher::new(Config::DEFAULT.match_paths());
+        let atom = Atom::new(
+            query,
+            CaseMatching::Ignore,
+            Normalization::Smart,
+            AtomKind::Fuzzy,
+            false,
+        );
+
+        let mut scored: Vec<(usize, u16)> = Vec::new();
+        let mut buf = Vec::new();
+
+        for (idx, item) in self.flat_items.iter().enumerate() {
+            let haystack = match item {
+                Item::Session { id, .. } => {
+                    if let Some(inst) = self.instance_map.get(id) {
+                        format!("{} {}", inst.title, inst.project_path)
+                    } else {
+                        continue;
                     }
                 }
+                Item::Group { name, path, .. } => {
+                    format!("{} {}", name, path)
+                }
+            };
+
+            let haystack_utf32 = Utf32Str::new(&haystack, &mut buf);
+            if let Some(score) = atom.score(haystack_utf32, &mut matcher) {
+                scored.push((idx, score));
             }
         }
 
-        self.filtered_items = Some(matches);
-        self.cursor = 0;
-        self.update_selected();
+        scored.sort_by(|a, b| b.1.cmp(&a.1));
+        self.search_matches = scored.into_iter().map(|(idx, _)| idx).collect();
+
+        if let Some(&best) = self.search_matches.first() {
+            self.cursor = best;
+            self.update_selected();
+        }
     }
 
     /// Create a session with optional hooks. Delegates to the background