feat: add search functionality with incremental search

Implement comprehensive search functionality including:

- Incremental search with live preview (/ for forward, ? for backward)
- Search navigation (n/N for next/previous match)
- Auto-expand collapsed sections containing matches
- Visual highlighting of matches (yellow for matches, bright yellow for current)
- Restore cursor/scroll/collapsed state on search cancellation
- Case-insensitive search with pattern persistence

Key changes:
- Add SearchForward, SearchBackward, SearchNext, SearchPrevious operations
- Separate Cancel operation from Quit (Esc now cancels search first)
- Add prompt_with_callback for live search preview
- Implement SearchState (Inactive/Incremental/Active) management
- Add search_match and current_search_match style configuration

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: sei40kr

src/app.rs

@@ -55,6 +55,7 @@ pub(crate) struct State {
     pub clipboard: Option<Clipboard>,
     needs_redraw: bool,
     file_watcher: Option<FileWatcher>,
+    pub search_pattern: Option<String>,
 }
 
 pub(crate) struct App {
@@ -106,6 +107,7 @@ impl App {
                 clipboard,
                 file_watcher: None,
                 needs_redraw: true,
+                search_pattern: None,
             },
         };
 
@@ -543,6 +545,15 @@ impl App {
     }
 
     pub fn prompt(&mut self, term: &mut Term, params: &PromptParams) -> Res<String> {
+        self.prompt_with_callback(term, params, &mut |_, _| {})
+    }
+
+    pub(crate) fn prompt_with_callback(
+        &mut self,
+        term: &mut Term,
+        params: &PromptParams,
+        on_change: &mut dyn FnMut(&mut Self, &str),
+    ) -> Res<String> {
         let prompt_text = if let Some(default) = (params.create_default_value)(self) {
             format!("{} (default {}):", params.prompt, default).into()
         } else {
@@ -554,7 +565,7 @@ impl App {
         }
 
         self.state.prompt.set(prompt::PromptData { prompt_text });
-        let result = self.handle_prompt(term, params);
+        let result = self.handle_prompt_with_callback(term, params, on_change);
 
         self.unhide_menu();
         if result.is_err() {
@@ -565,13 +576,25 @@ impl App {
         result
     }
 
-    fn handle_prompt(&mut self, term: &mut Term, params: &PromptParams) -> Res<String> {
+    fn handle_prompt_with_callback(
+        &mut self,
+        term: &mut Term,
+        params: &PromptParams,
+        on_change: &mut dyn FnMut(&mut Self, &str),
+    ) -> Res<String> {
         self.redraw_now(term)?;
+        let mut last_value = String::new();
 
         loop {
             let event = term.backend_mut().read_event()?;
             self.handle_event(term, event)?;
 
+            let current_value = self.state.prompt.state.value().to_string();
+            if current_value != last_value {
+                on_change(self, &current_value);
+                last_value = current_value;
+            }
+
             if self.state.prompt.state.status().is_done() {
                 return get_prompt_result(params, self);
             } else if self.state.prompt.state.status().is_aborted() {

src/config.rs

@@ -80,6 +80,9 @@ pub struct StyleConfig {
     pub command: StyleConfigEntry,
     pub active_arg: StyleConfigEntry,
     pub hotkey: StyleConfigEntry,
+
+    pub search_match: StyleConfigEntry,
+    pub current_search_match: StyleConfigEntry,
 }
 
 #[derive(Default, Debug, Deserialize)]

src/default_config.toml

@@ -86,8 +86,12 @@ command = { fg = "blue", mods = "BOLD" }
 active_arg = { fg = "light red", mods = "BOLD" }
 hotkey = { fg = "magenta" }
 
+search_match = { bg = "yellow", fg = "black", mods = "BOLD" }
+current_search_match = { bg = "light yellow", fg = "black", mods = "BOLD" }
+
 [bindings]
-root.quit = ["q", "esc"]
+root.quit = ["q"]
+root.cancel = ["esc"]
 root.refresh = ["g"]
 root.toggle_section = ["tab"]
 root.move_up = ["k", "up"]
@@ -99,6 +103,10 @@ root.move_next_section = ["alt+j", "alt+down"]
 root.move_parent_section = ["alt+h", "alt+left"]
 root.half_page_up = ["ctrl+u"]
 root.half_page_down = ["ctrl+d"]
+root.search_forward = ["/"]
+root.search_backward = ["?"]
+root.search_next = ["n"]
+root.search_previous = ["N"]
 root.show_refs = ["Y"]
 root.show = ["enter"]
 root.discard = ["K"]
@@ -107,14 +115,16 @@ root.unstage = ["u"]
 root.copy_hash = ["y"]
 
 root.help_menu = ["h", "?"]
-help_menu.quit = ["q", "h", "?", "esc"]
+help_menu.quit = ["q"]
+help_menu.cancel = ["h", "?", "esc"]
 
 root.branch_menu = ["b"]
 branch_menu.checkout = ["b"]
 branch_menu.checkout_new_branch = ["c"]
 branch_menu.spinoff = ["s"]
 branch_menu.delete = ["K"]
-branch_menu.quit = ["q", "esc"]
+branch_menu.quit = ["q"]
+branch_menu.cancel = ["esc"]
 
 root.commit_menu = ["c"]
 commit_menu.--all = ["-a"]
@@ -128,19 +138,22 @@ commit_menu.commit_amend = ["a"]
 commit_menu.commit_extend = ["e"]
 commit_menu.commit_fixup = ["f"]
 commit_menu.commit_instant_fixup = ["F"]
-commit_menu.quit = ["q", "esc"]
+commit_menu.quit = ["q"]
+commit_menu.cancel = ["esc"]
 
 root.fetch_menu = ["f"]
 fetch_menu.--prune = ["-p"]
 fetch_menu.--tags = ["-t"]
 fetch_menu.fetch_all = ["a"]
-fetch_menu.quit = ["q", "esc"]
+fetch_menu.quit = ["q"]
+fetch_menu.cancel = ["esc"]
 fetch_menu.fetch_elsewhere = ["e"]
 
 root.log_menu = ["l"]
 log_menu.log_current = ["l"]
 log_menu.log_other = ["o"]
-log_menu.quit = ["q", "esc"]
+log_menu.quit = ["q"]
+log_menu.cancel = ["esc"]
 log_menu.-n = ["-n"]
 log_menu.--grep = ["-F"]
 
@@ -150,14 +163,16 @@ merge_menu.--no-ff = ["-n"]
 merge_menu.merge_abort = ["a"]
 merge_menu.merge_continue = ["c"]
 merge_menu.merge = ["m"]
-merge_menu.quit = ["q", "<esc>"]
+merge_menu.quit = ["q"]
+merge_menu.cancel = ["esc"]
 
 root.pull_menu = ["F"]
 pull_menu.--rebase = ["-r"]
 pull_menu.pull_from_push_remote = ["p"]
 pull_menu.pull_from_upstream = ["u"]
 pull_menu.pull_from_elsewhere = ["e"]
-pull_menu.quit = ["q", "esc"]
+pull_menu.quit = ["q"]
+pull_menu.cancel = ["esc"]
 
 root.push_menu = ["P"]
 push_menu.--force-with-lease = ["-f"]
@@ -167,7 +182,8 @@ push_menu.--dry-run = ["-n"]
 push_menu.push_to_push_remote = ["p"]
 push_menu.push_to_upstream = ["u"]
 push_menu.push_to_elsewhere = ["e"]
-push_menu.quit = ["q", "esc"]
+push_menu.quit = ["q"]
+push_menu.cancel = ["esc"]
 
 root.rebase_menu = ["r"]
 rebase_menu.--keep-empty = ["-k"]
@@ -182,19 +198,22 @@ rebase_menu.rebase_abort = ["a"]
 rebase_menu.rebase_continue = ["c"]
 rebase_menu.rebase_elsewhere = ["e"]
 rebase_menu.rebase_autosquash = ["f"]
-rebase_menu.quit = ["q", "esc"]
+rebase_menu.quit = ["q"]
+rebase_menu.cancel = ["esc"]
 
 root.remote_menu=["M"]
 remote_menu.add_remote=["a"]
 remote_menu.remove_remote=["K"]
 remote_menu.rename_remote=["r"]
-remote_menu.quit = ["q", "esc"]
+remote_menu.quit = ["q"]
+remote_menu.cancel = ["esc"]
 
 root.reset_menu = ["X"]
 reset_menu.reset_soft = ["s"]
 reset_menu.reset_mixed = ["m"]
 reset_menu.reset_hard = ["h"]
-reset_menu.quit = ["q", "esc"]
+reset_menu.quit = ["q"]
+reset_menu.cancel = ["esc"]
 
 root.revert_menu = ["V"]
 revert_menu.--edit = ["-e"]
@@ -203,7 +222,8 @@ revert_menu.--signoff = ["-s"]
 revert_menu.revert_abort = ["a"]
 revert_menu.revert_continue = ["c"]
 revert_menu.revert_commit = ["V"]
-revert_menu.quit = ["q", "esc"]
+revert_menu.quit = ["q"]
+revert_menu.cancel = ["esc"]
 
 root.stash_menu = ["z"]
 stash_menu.--all = ["-a"]
@@ -215,4 +235,5 @@ stash_menu.stash_keep_index = ["x"]
 stash_menu.stash_pop = ["p"]
 stash_menu.stash_apply = ["a"]
 stash_menu.stash_drop = ["k"]
-stash_menu.quit = ["q", "esc"]
+stash_menu.quit = ["q"]
+stash_menu.cancel = ["esc"]

src/ops/editor.rs

@@ -42,6 +42,47 @@ impl OpTrait for Quit {
     }
 }
 
+pub(crate) struct Cancel;
+impl OpTrait for Cancel {
+    fn get_action(&self, _target: &ItemData) -> Option<Action> {
+        Some(Rc::new(|app, term| {
+            // First, check if there's an active search and clear it
+            if app.screen().get_search_pattern().is_some() {
+                app.screen_mut().clear_search();
+                app.state.search_pattern = None;
+                return Ok(());
+            }
+
+            let menu = app
+                .state
+                .pending_menu
+                .as_ref()
+                .map(|pending_menu| pending_menu.menu);
+
+            if menu == root_menu(&app.state.config) {
+                if app.state.screens.len() == 1 {
+                    if app.state.config.general.confirm_quit.enabled {
+                        app.confirm(term, "Really quit? (y or n)")?;
+                    };
+
+                    app.state.quit = true;
+                } else {
+                    app.state.screens.pop();
+                }
+            } else {
+                app.close_menu();
+                return Ok(());
+            }
+
+            Ok(())
+        }))
+    }
+
+    fn display(&self, _state: &State) -> String {
+        "Cancel/Close".into()
+    }
+}
+
 pub(crate) struct OpenMenu(pub crate::menu::Menu);
 impl OpTrait for OpenMenu {
     fn get_action(&self, _target: &ItemData) -> Option<Action> {
@@ -315,3 +356,115 @@ impl OpTrait for HalfPageDown {
         "Half page down".into()
     }
 }
+
+pub(crate) struct SearchForward;
+impl OpTrait for SearchForward {
+    fn get_action(&self, _target: &ItemData) -> Option<Action> {
+        Some(Rc::new(|app, term| {
+            let pattern = match app.prompt_with_callback(
+                term,
+                &PromptParams {
+                    prompt: "Search",
+                    create_default_value: Box::new(|app| app.state.search_pattern.clone()),
+                    hide_menu: true,
+                },
+                &mut |app, value| {
+                    app.screen_mut().search(value, crate::screen::SearchDirection::Forward, true);
+                },
+            ) {
+                Ok(p) => p,
+                Err(_) => {
+                    // Prompt was aborted (Esc pressed), clear the search
+                    app.screen_mut().clear_search();
+                    app.state.search_pattern = None;
+                    return Ok(());
+                }
+            };
+
+            app.state.search_pattern = if pattern.is_empty() {
+                None
+            } else {
+                Some(pattern.clone())
+            };
+
+            app.screen_mut().search(&pattern, crate::screen::SearchDirection::Forward, false);
+            app.close_menu();
+            Ok(())
+        }))
+    }
+
+    fn display(&self, _state: &State) -> String {
+        "Search forward".into()
+    }
+}
+
+pub(crate) struct SearchBackward;
+impl OpTrait for SearchBackward {
+    fn get_action(&self, _target: &ItemData) -> Option<Action> {
+        Some(Rc::new(|app, term| {
+            let pattern = match app.prompt_with_callback(
+                term,
+                &PromptParams {
+                    prompt: "Search backward",
+                    create_default_value: Box::new(|app| app.state.search_pattern.clone()),
+                    hide_menu: true,
+                },
+                &mut |app, value| {
+                    app.screen_mut().search(value, crate::screen::SearchDirection::Backward, true);
+                },
+            ) {
+                Ok(p) => p,
+                Err(_) => {
+                    // Prompt was aborted (Esc pressed), clear the search
+                    app.screen_mut().clear_search();
+                    app.state.search_pattern = None;
+                    return Ok(());
+                }
+            };
+
+            app.state.search_pattern = if pattern.is_empty() {
+                None
+            } else {
+                Some(pattern.clone())
+            };
+
+            app.screen_mut().search(&pattern, crate::screen::SearchDirection::Backward, false);
+            app.close_menu();
+            Ok(())
+        }))
+    }
+
+    fn display(&self, _state: &State) -> String {
+        "Search backward".into()
+    }
+}
+
+pub(crate) struct SearchNext;
+impl OpTrait for SearchNext {
+    fn get_action(&self, _target: &ItemData) -> Option<Action> {
+        Some(Rc::new(|app, _term| {
+            app.screen_mut().search_next();
+            app.close_menu();
+            Ok(())
+        }))
+    }
+
+    fn display(&self, _state: &State) -> String {
+        "Next match".into()
+    }
+}
+
+pub(crate) struct SearchPrevious;
+impl OpTrait for SearchPrevious {
+    fn get_action(&self, _target: &ItemData) -> Option<Action> {
+        Some(Rc::new(|app, _term| {
+            app.screen_mut().search_previous();
+            app.close_menu();
+            Ok(())
+        }))
+    }
+
+    fn display(&self, _state: &State) -> String {
+        "Previous match".into()
+    }
+}