diff --git a/codex-rs/config/src/tui_keymap.rs b/codex-rs/config/src/tui_keymap.rs index 7e6d92de7d..1c1c998ce7 100644 --- a/codex-rs/config/src/tui_keymap.rs +++ b/codex-rs/config/src/tui_keymap.rs @@ -269,6 +269,8 @@ pub struct TuiVimNormalKeymap { pub start_yank_operator: Option, /// Begin change operator; next keys select a text object. pub start_change_operator: Option, + /// Undo the last complete edit (`u`). + pub undo: Option, /// Cancel a pending operator and return to normal mode. pub cancel_operator: Option, } diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.json index 54415cd19d..11e20bd67e 100644 --- a/codex-rs/core/config.schema.json +++ b/codex-rs/core/config.schema.json @@ -3902,6 +3902,7 @@ "substitute_char": null, "till_backward": null, "till_forward": null, + "undo": null, "yank_line": null }, "vim_operator": { @@ -4728,6 +4729,7 @@ "substitute_char": null, "till_backward": null, "till_forward": null, + "undo": null, "yank_line": null } }, @@ -5246,6 +5248,14 @@ ], "description": "Stop before the next character on the current line (`t`)." }, + "undo": { + "allOf": [ + { + "$ref": "#/definitions/KeybindingsSpec" + } + ], + "description": "Undo the last complete edit (`u`)." + }, "yank_line": { "allOf": [ { diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs index 9df19ecda7..ae13d85a01 100644 --- a/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs +++ b/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs @@ -1446,7 +1446,7 @@ max_recent_non_user_entries = 8 .latest_scored_tool_call .load(Ordering::Acquire) == 0 - || metrics.0.lock().unwrap().len() < 10 + || metrics.0.lock().unwrap().len() < 14 { tokio::task::yield_now().await; } diff --git a/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs b/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs index 17cc593a79..2da167a445 100644 --- a/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs +++ b/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs @@ -24,6 +24,7 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv (Some(ThreadId::new()), true), ] { let (mut app, mut events, _) = make_test_app_with_channels().await; + app.keymap.app.open_agents = vec![crate::key_hint::alt(KeyCode::Char('a'))]; let child = ThreadId::new(); let child_recap = recap::RecapProgress { completed_turns: 3, diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rs index ee3bf5a038..e1456aa679 100644 --- a/codex-rs/tui/src/bottom_pane/chat_composer.rs +++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs @@ -63,6 +63,8 @@ //! `Ctrl+R` opens a reverse incremental search mode. The footer becomes the search input; once the //! query is non-empty, the composer body previews the current match. `Enter` accepts the preview as //! an editable draft and `Esc` restores the draft that was active when search started. +//! Vim undo snapshots the complete draft and groups direct edits with active Vim transactions. +//! Canceled history previews restore both; accepting another prompt resets undo history. //! Vim queries stay draft-local. //! //! Slash commands are staged for local history instead of being recorded immediately. Command @@ -303,6 +305,7 @@ mod history_search; mod popup_state; mod reconnect; mod slash_input; +mod vim_history; mod vim_search; use self::attachment_state::AttachmentState; @@ -316,6 +319,7 @@ use self::popup_state::PopupState; use self::slash_input::SlashInput; use self::slash_input::SlashValidation; use self::slash_input::SubmissionValidation; +use self::vim_history::VimHistory; use crate::app_event::AppEvent; use crate::app_event::ConnectorsSnapshot; use crate::app_event_sender::AppEventSender; @@ -535,6 +539,7 @@ pub(crate) struct ChatComposer { windows_degraded_sandbox_active: bool, side_conversation_active: bool, history_search: Option, + vim_history: VimHistory, submit_keys: Vec, queue_keys: Vec, toggle_shortcuts_keys: Vec, @@ -709,6 +714,7 @@ impl ChatComposer { windows_degraded_sandbox_active: false, side_conversation_active: false, history_search: None, + vim_history: VimHistory::default(), submit_keys: vec![key_hint::plain(KeyCode::Enter)], queue_keys: vec![key_hint::plain(KeyCode::Tab)], toggle_shortcuts_keys: vec![ @@ -1212,6 +1218,7 @@ impl ChatComposer { query.editor.insert_str(&pasted); return true; } + let started_vim_edit = self.begin_direct_vim_edit(); let char_count = pasted.chars().count(); if char_count > LARGE_PASTE_CHAR_THRESHOLD { let placeholder = self.next_large_paste_placeholder(char_count); @@ -1229,6 +1236,9 @@ impl ChatComposer { } self.draft.paste_burst.clear_after_explicit_paste(); self.sync_popups(); + if started_vim_edit { + self.finish_vim_edit(); + } true } @@ -1290,6 +1300,7 @@ impl ChatComposer { /// are renumbered to `[Image #M+1]..[Image #N]` (where `M` is the number of /// remote images). Cursor is placed at the end after rebuilding elements. pub(crate) fn apply_external_edit(&mut self, text: String) { + self.vim_history = VimHistory::default(); self.draft.pending_pastes.clear(); let (text, _) = self.imported_text_for_textarea(text, Vec::new()); @@ -1375,6 +1386,7 @@ impl ChatComposer { pub(crate) fn set_vim_enabled(&mut self, enabled: bool) { self.draft.textarea.enable_vim_search(); self.draft.textarea.set_vim_enabled(enabled); + self.vim_history = VimHistory::default(); self.draft.paste_burst.clear_after_explicit_paste(); self.footer.mode = reset_mode_after_activity(self.footer.mode); } @@ -1565,6 +1577,7 @@ impl ChatComposer { mention_bindings: Vec, ) { // Clear any existing content, placeholders, and attachments first. + self.vim_history = VimHistory::default(); self.draft.textarea.set_text_clearing_elements(""); self.draft.is_bash_mode = false; self.draft.pending_pastes.clear(); @@ -1833,8 +1846,12 @@ impl ChatComposer { /// Insert an attachment placeholder and track it for the next submission. pub fn attach_image(&mut self, path: PathBuf) { + let started_vim_edit = self.begin_direct_vim_edit(); self.attachments .attach_image(&mut self.draft.textarea, path); + if started_vim_edit { + self.finish_vim_edit(); + } } #[cfg(test)] @@ -1960,9 +1977,13 @@ impl ChatComposer { } pub(crate) fn insert_str(&mut self, text: &str) { + let started_vim_edit = self.begin_direct_vim_edit(); self.draft.textarea.insert_str(text); self.sync_bash_mode_from_text(); self.sync_popups(); + if started_vim_edit { + self.finish_vim_edit(); + } } /// Handle a key event coming from the main UI. @@ -1986,6 +2007,10 @@ impl ChatComposer { return self.handle_history_search_key(key_event); } + if self.handle_vim_history_key(key_event) { + return (InputResult::None, true); + } + if Self::is_history_search_key(&key_event, &self.history_search_previous_keys) { return self.begin_history_search(); } @@ -2491,6 +2516,7 @@ impl ChatComposer { } fn insert_selected_file_path(&mut self, token_range: Range, selected_path: &str) { + let started_vim_edit = self.begin_direct_vim_edit(); let token_range = self.separate_completion_from_adjacent_element(token_range); if Self::is_image_path(selected_path) { let path_buf = PathBuf::from(selected_path); @@ -2511,6 +2537,9 @@ impl ChatComposer { } else { self.insert_selected_path(token_range, selected_path); } + if started_vim_edit { + self.finish_vim_edit(); + } } fn trim_text_elements( @@ -3136,6 +3165,7 @@ impl ChatComposer { | InputResult::ServiceTierCommand(_) | InputResult::CommandWithArgs(_, _, _) ) { + self.vim_history = VimHistory::default(); self.draft.textarea.enter_vim_insert_mode(); } } @@ -3457,8 +3487,16 @@ impl ChatComposer { &mut self, key_event: &KeyEvent, ) -> Option<(InputResult, bool)> { - self.attachments - .handle_remote_image_selection_key(key_event, &mut self.draft.textarea) + let removes_remote_image = matches!(key_event.code, KeyCode::Delete | KeyCode::Backspace) + && self.attachments.selected_remote_image_index.is_some(); + let started_vim_edit = removes_remote_image && self.begin_direct_vim_edit(); + let result = self + .attachments + .handle_remote_image_selection_key(key_event, &mut self.draft.textarea); + if started_vim_edit { + self.finish_vim_edit(); + } + result } /// Handle key event when no popup is visible. @@ -3635,6 +3673,9 @@ impl ChatComposer { input: KeyEvent, now: Instant, ) -> (InputResult, bool) { + if !self.draft.textarea.is_vim_normal_mode() { + self.begin_vim_edit(input); + } // If we have a buffered non-bracketed paste burst and enough time has // elapsed since the last char, flush it before handling a new input. self.handle_paste_burst_flush(now); @@ -3744,16 +3785,22 @@ impl ChatComposer { && matches!(input.code, KeyCode::Backspace) && self.draft.textarea.cursor() == 0 { + let started_vim_edit = self.begin_direct_vim_edit(); self.draft.is_bash_mode = false; + if started_vim_edit { + self.finish_vim_edit(); + } return (InputResult::None, true); } + self.begin_vim_edit(input); self.draft.textarea.input(input); self.sync_bash_mode_from_text(); if let Some(elements_before) = elements_before { self.reconcile_deleted_elements(elements_before); } + self.finish_vim_edit(); // Update the paste-burst heuristic for text, shortcut, and non-char events. match input.code { @@ -10663,6 +10710,8 @@ mod tests { let (mut composer, _rx) = new_test_composer(); configure_bound_plugin_left_of_unbound_plugin(&mut composer); + composer.set_vim_enabled(/*enabled*/ true); + let before = composer.draft_snapshot(); composer.insert_selected_file_path( "@sample".len().."@sample@other".len(), image_path.to_str().expect("UTF-8 path"), @@ -10670,6 +10719,9 @@ mod tests { assert_eq!(composer.current_text(), "@sample [Image #1] "); assert_eq!(composer.local_image_paths(), vec![image_path]); + let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)); + let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE)); + assert_eq!(composer.draft_snapshot(), before); } #[test] diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/history_search.rs b/codex-rs/tui/src/bottom_pane/chat_composer/history_search.rs index a79a10a362..9072f9d4b6 100644 --- a/codex-rs/tui/src/bottom_pane/chat_composer/history_search.rs +++ b/codex-rs/tui/src/bottom_pane/chat_composer/history_search.rs @@ -1,9 +1,9 @@ //! Composer-side Ctrl+R reverse history search state and rendering helpers. //! //! The persistent and local history stores live in `chat_composer_history`, but the composer owns -//! the active search session because it has to snapshot/restore the editable draft, preview matches -//! in the textarea, and render the footer prompt while the footer line is acting as the search -//! input. +//! the active search session because it has to snapshot/restore the editable draft and Vim edit +//! state, preview matches in the textarea, and render the footer prompt while the footer line is +//! acting as the search input. //! //! This module is responsible for the UI-facing lifecycle of a search session: recognizing the //! keys that enter and drive search mode, keeping the footer query separate from the textarea @@ -35,10 +35,12 @@ use super::super::chat_composer_history::HistorySearchDirection; use super::super::chat_composer_history::HistorySearchResult; use super::super::footer::footer_height; use super::super::footer::reset_mode_after_activity; +use super::super::textarea::VimPersistentState; use super::ActivePopup; use super::ChatComposer; use super::ComposerDraft; use super::InputResult; +use super::vim_history::VimHistory; use crate::app_event::AppEvent; use crate::key_hint; use crate::key_hint::KeyBinding; @@ -49,12 +51,16 @@ use crate::ui_consts::FOOTER_INDENT_COLS; /// Active composer-owned state for one Ctrl+R search interaction. /// /// The session is created only by [`ChatComposer::begin_history_search`] and is cleared only by -/// accepting, canceling, or replacing the search mode. It stores the original draft separately from -/// the footer query so transient previews never destroy the user's in-progress composer content. -#[derive(Clone, Debug)] +/// accepting, canceling, or replacing the search mode. It stores the original draft and Vim edit +/// state separately from the footer query so transient previews never destroy in-progress content. +#[derive(Debug)] pub(super) struct HistorySearchSession { /// Draft to restore when search is canceled or a query has no match. original_draft: ComposerDraft, + /// Same-draft Vim edits to restore when a temporary preview is canceled. + original_vim_history: VimHistory, + /// Active and completed Vim commands suspended during temporary draft replacement. + original_vim_state: VimPersistentState, /// Footer-owned query text typed while Ctrl+R search is active. query: String, /// User-visible search status used to choose footer hints and composer preview behavior. @@ -114,8 +120,16 @@ impl ChatComposer { } self.popups.active = ActivePopup::None; self.attachments.clear_remote_image_selection(); + let original_draft = self.snapshot_draft(); + let original_vim_history = std::mem::take(&mut self.vim_history); + let mut original_vim_state = VimPersistentState::default(); + self.draft + .textarea + .swap_vim_persistent_state(&mut original_vim_state); self.history_search = Some(HistorySearchSession { - original_draft: self.snapshot_draft(), + original_draft, + original_vim_history, + original_vim_state, query: String::new(), status: HistorySearchStatus::Idle, }); @@ -292,12 +306,16 @@ impl ChatComposer { /// as Ctrl+C, should use the boolean result to consume the key without also clearing the /// restored draft or triggering quit/interrupt behavior. pub(crate) fn cancel_history_search(&mut self) -> bool { - let Some(search) = self.history_search.take() else { + let Some(mut search) = self.history_search.take() else { return false; }; self.history.reset_navigation(); self.footer.mode = reset_mode_after_activity(self.footer.mode); self.restore_draft(search.original_draft); + self.vim_history = search.original_vim_history; + self.draft + .textarea + .swap_vim_persistent_state(&mut search.original_vim_state); true } diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/vim_history.rs b/codex-rs/tui/src/bottom_pane/chat_composer/vim_history.rs new file mode 100644 index 0000000000..b750469b1f --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/chat_composer/vim_history.rs @@ -0,0 +1,198 @@ +//! Bounded Vim undo history for the complete composer-owned draft. +//! +//! A textarea does not own pending paste payloads, image attachments, or mention targets. Keeping +//! edit transactions here lets one snapshot restore those values together with visible text. Keys +//! and direct composer-owned changes share the same bounded transaction state. + +use std::collections::VecDeque; + +use super::super::textarea::VimPersistentState; +use super::ChatComposer; +use super::ComposerDraft; +use crate::key_hint::KeyBindingListExt; +use crossterm::event::KeyEvent; + +const MAX_VIM_UNDO_STEPS: usize = 64; +const MAX_VIM_UNDO_BYTES: usize = 1024 * 1024; + +#[derive(Debug, Default)] +pub(super) struct VimHistory { + undo: VecDeque, + pending: Option, +} + +impl ComposerDraft { + fn vim_history_bytes(&self) -> usize { + let mut bytes = self.text.len() + + self.text_elements.len() + * std::mem::size_of::(); + for path in &self.local_image_paths { + bytes += path.as_os_str().len(); + } + for url in &self.remote_image_urls { + bytes += url.len(); + } + for binding in &self.mention_bindings { + bytes += binding.mention.len() + binding.path.len(); + } + for (placeholder, pasted) in &self.pending_pastes { + bytes += placeholder.len() + pasted.len(); + } + bytes + } +} + +impl VimHistory { + fn trim(&mut self) { + while self.undo.len() > MAX_VIM_UNDO_STEPS + || self + .undo + .iter() + .chain(self.pending.iter()) + .map(ComposerDraft::vim_history_bytes) + .sum::() + > MAX_VIM_UNDO_BYTES + { + self.undo.pop_front(); + } + } +} + +impl ChatComposer { + /// Apply undo only before normal-mode commands begin. + pub(super) fn handle_vim_history_key(&mut self, event: KeyEvent) -> bool { + if !self.draft.textarea.is_vim_normal_mode() + || self.draft.textarea.is_vim_operator_pending() + || self.popups.active() + || !self.vim_normal_keymap.undo.is_pressed(event) + { + return false; + } + + if let Some(snapshot) = self.vim_history.undo.pop_back() { + let history = std::mem::take(&mut self.vim_history); + let mut vim_state = VimPersistentState::default(); + self.draft + .textarea + .swap_vim_persistent_state(&mut vim_state); + self.restore_draft(snapshot); + self.draft + .textarea + .swap_vim_persistent_state(&mut vim_state); + self.vim_history = history; + self.draft.textarea.enter_vim_normal_mode(); + self.vim_history.trim(); + } + true + } + + /// Snapshot only keys that can begin or complete a Vim edit transaction. + pub(super) fn begin_vim_edit(&mut self, event: KeyEvent) { + if !self.draft.textarea.is_vim_enabled() + || self.vim_history.pending.is_some() + || self.draft.textarea.is_vim_operator_pending() + { + return; + } + + if self.draft.textarea.is_vim_normal_mode() + && (self.vim_normal_keymap.move_left.is_pressed(event) + || self.vim_normal_keymap.move_right.is_pressed(event) + || self.vim_normal_keymap.move_up.is_pressed(event) + || self.vim_normal_keymap.move_down.is_pressed(event) + || self.vim_normal_keymap.move_word_forward.is_pressed(event) + || self.vim_normal_keymap.move_word_backward.is_pressed(event) + || self.vim_normal_keymap.move_word_end.is_pressed(event) + || self.vim_normal_keymap.move_line_start.is_pressed(event) + || self.vim_normal_keymap.move_line_end.is_pressed(event) + || self.vim_normal_keymap.find_forward.is_pressed(event) + || self.vim_normal_keymap.find_backward.is_pressed(event) + || self.vim_normal_keymap.jump_top.is_pressed(event) + || self.vim_normal_keymap.jump_bottom.is_pressed(event) + || self.draft.textarea.wants_vim_search_key(event) + || self.vim_normal_keymap.yank_line.is_pressed(event) + || self.vim_normal_keymap.start_yank_operator.is_pressed(event) + || self.vim_normal_keymap.cancel_operator.is_pressed(event)) + { + return; + } + + self.begin_vim_edit_transaction(); + } + + /// Start one standalone draft edit without splitting an active Vim command. + pub(super) fn begin_direct_vim_edit(&mut self) -> bool { + if !self.draft.textarea.is_vim_enabled() + || self.draft.textarea.is_vim_operator_pending() + || self.vim_history.pending.is_some() + || self.history_search.is_some() + { + return false; + } + + self.begin_vim_edit_transaction(); + if self.vim_history.pending.is_none() { + return false; + } + let mut vim_state = VimPersistentState::default(); + self.draft + .textarea + .swap_vim_persistent_state(&mut vim_state); + vim_state.commands.last_change.clear(); + self.draft + .textarea + .swap_vim_persistent_state(&mut vim_state); + true + } + + fn begin_vim_edit_transaction(&mut self) { + let visible_bytes = self.draft.textarea.text().len(); + let paste_bytes = self + .draft + .pending_pastes + .iter() + .map(|(placeholder, pasted)| placeholder.len() + pasted.len()) + .sum::(); + if visible_bytes.saturating_add(paste_bytes) > MAX_VIM_UNDO_BYTES { + self.vim_history = VimHistory::default(); + return; + } + + let snapshot = self.snapshot_draft(); + if snapshot.vim_history_bytes() <= MAX_VIM_UNDO_BYTES { + self.vim_history.pending = Some(snapshot); + self.vim_history.trim(); + } else { + self.vim_history = VimHistory::default(); + } + } + + /// Commit a complete normal-mode command or one insert-mode session. + pub(super) fn finish_vim_edit(&mut self) { + if !self.draft.textarea.is_vim_normal_mode() + || self.draft.textarea.is_vim_operator_pending() + { + return; + } + + let Some(snapshot) = self.vim_history.pending.take() else { + return; + }; + if snapshot.text == self.current_text() + && snapshot.text_elements == self.current_text_elements() + && snapshot.pending_pastes == self.draft.pending_pastes + && snapshot.local_image_paths == self.attachments.local_image_paths() + && snapshot.remote_image_urls == self.attachments.remote_image_urls() + && snapshot.mention_bindings == self.snapshot_mention_bindings() + { + return; + } + + self.vim_history.undo.push_back(snapshot); + self.vim_history.trim(); + } +} + +#[cfg(test)] +#[path = "vim_history_tests.rs"] +mod tests; diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/vim_history_tests.rs b/codex-rs/tui/src/bottom_pane/chat_composer/vim_history_tests.rs new file mode 100644 index 0000000000..d9696c4f90 --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/chat_composer/vim_history_tests.rs @@ -0,0 +1,372 @@ +//! Composer undo transactions preserve rich draft data and active Vim commands. + +use std::path::PathBuf; + +use codex_config::types::KeybindingSpec; +use codex_config::types::KeybindingsSpec; +use codex_config::types::TuiKeymap; +use crossterm::event::KeyCode; +use crossterm::event::KeyEvent; +use crossterm::event::KeyModifiers; +use pretty_assertions::assert_eq; + +use super::super::super::chat_composer_history::HistoryEntry; +use super::super::ChatComposer; +use super::super::InputResult; +use super::super::LARGE_PASTE_CHAR_THRESHOLD; +use super::super::tests::new_test_composer; +use crate::keymap::RuntimeKeymap; + +fn vim_composer(text: &str) -> ChatComposer { + let (mut composer, _receiver) = new_test_composer(); + composer.set_disable_paste_burst(/*disabled*/ true); + composer.set_text_content(text.to_owned(), Vec::new(), Vec::new()); + composer.set_vim_enabled(/*enabled*/ true); + composer.draft.textarea.set_cursor(/*pos*/ 0); + composer +} + +fn keys(composer: &mut ChatComposer, keys: &str) { + for key in keys.chars() { + let code = if key == '\n' { + KeyCode::Enter + } else { + KeyCode::Char(key) + }; + let _ = composer.handle_key_event(KeyEvent::new(code, KeyModifiers::NONE)); + } +} + +fn escape(composer: &mut ChatComposer) { + let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)); +} + +fn ctrl_r(composer: &mut ChatComposer) { + let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL)); +} + +#[test] +fn undo_groups_complete_vim_edits() { + for (original, command, edited) in [ + ("one two", "cwX", "X two"), + ("abc", "iXYZ", "XYZabc"), + ("", "i/review", "/review"), + ("one two", "c/two\nX", "Xtwo"), + ("one two", "d/two\n", "two"), + ("abc-def", "df-", "def"), + ("abc-def", "cf-X", "Xdef"), + ] { + let mut composer = vim_composer(original); + keys(&mut composer, command); + if composer.popups.active() { + escape(&mut composer); + } + escape(&mut composer); + assert_eq!(composer.current_text(), edited); + assert_eq!(composer.vim_history.undo.len(), 1); + + keys(&mut composer, "u"); + assert_eq!( + (composer.current_text(), composer.cursor()), + (original.to_owned(), 0) + ); + } +} + +#[test] +fn undo_preserves_repeat_and_pending_operator_bindings() { + let mut composer = vim_composer("alpha beta gamma"); + keys(&mut composer, "dw.u"); + assert_eq!(composer.current_text(), "beta gamma"); + keys(&mut composer, "u."); + assert_eq!(composer.current_text(), "beta gamma"); + + let mut composer = vim_composer("one two"); + let mut keymap = RuntimeKeymap::defaults(); + keymap.vim_operator.motion_word_forward = vec![crate::key_hint::plain(KeyCode::Char('u'))]; + composer.set_keymap_bindings(&keymap); + keys(&mut composer, "duu"); + assert_eq!(composer.current_text(), "one two"); +} + +#[test] +fn undo_preserves_confirmed_vim_search() { + let mut composer = vim_composer("alpha beta alpha"); + keys(&mut composer, "/alpha\n0xun"); + assert_eq!( + (composer.current_text(), composer.cursor()), + ("alpha beta alpha".to_owned(), 11) + ); + + keys(&mut composer, "0"); + composer.handle_paste("Z".to_owned()); + keys(&mut composer, "n"); + assert_eq!( + (composer.current_text(), composer.cursor()), + ("Zalpha beta alpha".to_owned(), 12) + ); +} + +#[test] +fn externally_canceled_search_operator_finishes_the_undo_transaction() { + let mut composer = vim_composer("abc"); + keys(&mut composer, "xd/"); + assert!(composer.cancel_vim_search()); + keys(&mut composer, "uxu"); + assert_eq!(composer.current_text(), "abc"); +} + +#[test] +fn normal_mode_explicit_paste_is_its_own_undoable_edit() { + let mut composer = vim_composer("abc"); + keys(&mut composer, "x"); + composer.handle_paste("Z".to_owned()); + assert_eq!(composer.current_text(), "Zbc"); + keys(&mut composer, "u"); + assert_eq!(composer.current_text(), "bc"); + keys(&mut composer, "u"); + assert_eq!(composer.current_text(), "abc"); +} + +#[test] +fn normal_mode_direct_insert_and_image_attachment_are_undoable() { + let mut composer = vim_composer("abc"); + composer.insert_str("Z"); + assert_eq!(composer.current_text(), "Zabc"); + keys(&mut composer, "u"); + assert_eq!(composer.current_text(), "abc"); + + let path = PathBuf::from("example.png"); + composer.attach_image(path.clone()); + assert_eq!(composer.local_image_paths(), vec![path]); + keys(&mut composer, "u"); + assert_eq!(composer.current_text(), "abc"); + assert!(composer.local_image_paths().is_empty()); + keys(&mut composer, "\nABC"); + assert_eq!(composer.current_text(), "ABC"); + escape(&mut composer); + keys(&mut composer, "u"); + assert!(composer.is_empty()); + keys(&mut composer, "u"); + assert!(composer.is_empty()); +} + +#[test] +fn deleting_a_selected_remote_image_is_one_undoable_vim_edit() { + for key in [KeyCode::Delete, KeyCode::Backspace] { + let mut composer = vim_composer("abc"); + let url = "https://example.com/remote.png".to_owned(); + composer.set_remote_image_urls(vec![url.clone()]); + let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE)); + assert!(composer.vim_history.pending.is_none()); + let _ = composer.handle_key_event(KeyEvent::new(key, KeyModifiers::NONE)); + assert!(composer.remote_image_urls().is_empty()); + keys(&mut composer, "u"); + assert_eq!(composer.remote_image_urls(), vec![url]); + assert_eq!(composer.current_text(), "abc"); + } +} + +#[test] +fn direct_edits_join_the_active_vim_insert_transaction() { + let mut composer = vim_composer("abc"); + composer.enable_vim_in_insert_mode(); + composer.handle_paste("ABC".to_owned()); + composer.attach_image(PathBuf::from("example.png")); + keys(&mut composer, "D"); + escape(&mut composer); + assert_eq!(composer.vim_history.undo.len(), 1); + keys(&mut composer, "u"); + assert_eq!(composer.current_text(), "abc"); + assert!(composer.local_image_paths().is_empty()); +} + +#[test] +fn removing_the_shell_prefix_is_its_own_undoable_edit() { + let mut composer = vim_composer(""); + keys(&mut composer, "!foo"); + escape(&mut composer); + keys(&mut composer, "0"); + let before = composer.draft_snapshot(); + let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE)); + assert_eq!(composer.current_text(), "foo"); + keys(&mut composer, "u"); + assert_eq!(composer.draft_snapshot(), before); +} + +#[test] +fn canceled_reverse_history_preview_preserves_vim_undo_and_repeat() { + let mut composer = vim_composer("alpha beta alpha"); + composer + .history + .record_local_submission(HistoryEntry::new("archived prompt".to_owned())); + keys(&mut composer, "/alpha\n0x"); + ctrl_r(&mut composer); + keys(&mut composer, "archive"); + assert_eq!(composer.current_text(), "archived prompt"); + escape(&mut composer); + assert_eq!(composer.current_text(), "lpha beta alpha"); + keys(&mut composer, "u"); + assert_eq!(composer.current_text(), "alpha beta alpha"); + keys(&mut composer, "."); + assert_eq!(composer.current_text(), "lpha beta alpha"); + keys(&mut composer, "n"); + assert_eq!(composer.cursor(), 10); +} + +#[test] +fn canceled_history_preview_preserves_active_vim_commands() { + for query in ["", "archive", "missing"] { + for (command, edited) in [("iX", "XYalpha beta"), ("cwX", "XY beta")] { + let mut composer = vim_composer("alpha beta"); + composer + .history + .record_local_submission(HistoryEntry::new("archived prompt".to_owned())); + keys(&mut composer, command); + ctrl_r(&mut composer); + keys(&mut composer, query); + escape(&mut composer); + keys(&mut composer, "Y"); + escape(&mut composer); + assert_eq!(composer.current_text(), edited); + keys(&mut composer, "u."); + assert_eq!(composer.current_text(), edited); + } + } +} + +#[test] +fn accepted_reverse_history_preview_starts_a_fresh_vim_edit_history() { + let mut composer = vim_composer("abc"); + composer + .history + .record_local_submission(HistoryEntry::new("archived prompt".to_owned())); + keys(&mut composer, "xiX"); + ctrl_r(&mut composer); + keys(&mut composer, "archive\n"); + assert_eq!(composer.current_text(), "archived prompt"); + assert!(!composer.history_search_active()); + escape(&mut composer); + keys(&mut composer, "u."); + assert_eq!(composer.current_text(), "archived prompt"); +} + +#[test] +fn undo_uses_configured_bindings_and_supports_unbinding() { + let mut composer = vim_composer("abc"); + let mut keymap = RuntimeKeymap::defaults(); + keymap.vim_normal.undo = vec![crate::key_hint::plain(KeyCode::Char('z'))]; + composer.set_keymap_bindings(&keymap); + keys(&mut composer, "xu"); + assert_eq!(composer.current_text(), "bc"); + keys(&mut composer, "z"); + assert_eq!(composer.current_text(), "abc"); + keymap.vim_normal.undo.clear(); + composer.set_keymap_bindings(&keymap); + keys(&mut composer, "xz"); + assert_eq!(composer.current_text(), "bc"); + + let mut config = TuiKeymap::default(); + config.composer.history_search_previous = + Some(KeybindingsSpec::One(KeybindingSpec("u".to_owned()))); + composer.set_keymap_bindings(&RuntimeKeymap::from_config(&config).unwrap()); + keys(&mut composer, "u"); + assert!(composer.history_search_active()); + escape(&mut composer); + config.vim_normal.undo = Some(KeybindingsSpec::One(KeybindingSpec("u".to_owned()))); + composer.set_keymap_bindings(&RuntimeKeymap::from_config(&config).unwrap()); + keys(&mut composer, "u"); + assert!(!composer.history_search_active()); + + let mut composer = vim_composer("abc"); + let mut config = TuiKeymap::default(); + config.composer.submit = Some(KeybindingsSpec::One(KeybindingSpec("u".to_owned()))); + composer.set_keymap_bindings(&RuntimeKeymap::from_config(&config).unwrap()); + assert_eq!( + composer + .handle_key_event(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE)) + .0, + InputResult::Submitted { + text: "abc".to_owned(), + text_elements: Vec::new() + } + ); +} + +#[test] +fn undo_restores_deleted_large_paste_payload() { + let mut composer = vim_composer("alpha "); + composer.draft.textarea.set_cursor("alpha ".len()); + keys(&mut composer, "i"); + let pasted = "x".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1); + composer.handle_paste(pasted.clone()); + escape(&mut composer); + let before = composer.draft_snapshot(); + keys(&mut composer, "x"); + assert_eq!(composer.current_text(), "alpha "); + assert!(composer.draft.pending_pastes.is_empty()); + keys(&mut composer, "u"); + assert_eq!(composer.draft_snapshot(), before); + assert_eq!( + composer.current_text_with_pending(), + format!("alpha {pasted}") + ); +} + +#[test] +fn undo_restores_deleted_image_attachment() { + let mut composer = vim_composer("alpha "); + composer.draft.textarea.set_cursor("alpha ".len()); + composer.attach_image(PathBuf::from("example.png")); + composer.draft.textarea.set_cursor("alpha ".len()); + let before = composer.draft_snapshot(); + keys(&mut composer, "x"); + assert_eq!(composer.current_text(), "alpha "); + assert!(composer.local_image_paths().is_empty()); + keys(&mut composer, "u"); + assert_eq!(composer.draft_snapshot(), before); +} + +#[test] +fn find_jump_and_search_navigation_never_snapshot_the_draft() { + let mut composer = vim_composer("alpha beta\nalpha gamma"); + for key in ['f', 'F', 'G', '/', '?', 'n', 'N'] { + composer.begin_vim_edit(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE)); + assert!( + composer.vim_history.pending.is_none(), + "navigation binding {key:?} snapshotted the draft" + ); + } + let (code, modifiers) = composer + .vim_normal_keymap + .jump_top + .first() + .expect("native jump-top chord") + .parts(); + composer.begin_vim_edit(KeyEvent::new(code, modifiers)); + assert!(composer.vim_history.pending.is_none()); + + for command in ["llwbh0$", "fb", "Fa", "G", "/beta\nnN", "?alpha\n"] { + let text = "alpha beta\nalpha gamma"; + let mut composer = vim_composer(text); + for key in command.chars() { + keys(&mut composer, &key.to_string()); + assert!( + composer.vim_history.pending.is_none(), + "navigation command {command:?} snapshotted the draft" + ); + assert!(composer.vim_history.undo.is_empty()); + } + assert_eq!(composer.current_text(), text); + } + composer + .history + .record_local_submission(HistoryEntry::new("alpha archived".to_owned())); + ctrl_r(&mut composer); + keys(&mut composer, "alpha"); + assert_eq!(composer.current_text(), "alpha archived"); + assert!(composer.vim_history.pending.is_none()); + assert!(composer.vim_history.undo.is_empty()); + escape(&mut composer); + assert_eq!(composer.current_text(), "alpha beta\nalpha gamma"); +} diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/vim_search.rs b/codex-rs/tui/src/bottom_pane/chat_composer/vim_search.rs index c6d0af5092..35d5a5d18d 100644 --- a/codex-rs/tui/src/bottom_pane/chat_composer/vim_search.rs +++ b/codex-rs/tui/src/bottom_pane/chat_composer/vim_search.rs @@ -6,7 +6,11 @@ use ratatui::layout::Rect; impl ChatComposer { pub(crate) fn cancel_vim_search(&mut self) -> bool { - self.draft.textarea.cancel_vim_search() + let canceled = self.draft.textarea.cancel_vim_search(); + if canceled { + self.finish_vim_edit(); + } + canceled } pub(super) fn vim_search_cursor_pos(&self, area: Rect) -> Option<(u16, u16)> { diff --git a/codex-rs/tui/src/bottom_pane/textarea.rs b/codex-rs/tui/src/bottom_pane/textarea.rs index 5e0d163233..8dd6d331be 100644 --- a/codex-rs/tui/src/bottom_pane/textarea.rs +++ b/codex-rs/tui/src/bottom_pane/textarea.rs @@ -63,6 +63,7 @@ use self::vim_commands::VimAction; use self::vim_commands::VimCommandState; use self::vim_commands::VimEditTarget; use self::vim_commands::VimInsertPosition; +pub(crate) use self::vim_commands::VimPersistentState; const WORD_SEPARATORS: &str = "`~!@#$%^&*()-=+[{]}\\|;:'\",.<>/?"; diff --git a/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs b/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs index 1e3e290f8d..42df694a76 100644 --- a/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs +++ b/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs @@ -26,6 +26,13 @@ pub(crate) enum VimEdit { Text(String), } +/// Vim command recording and searches preserved across same-draft restoration. +#[derive(Debug, Default)] +pub(crate) struct VimPersistentState { + pub(crate) commands: VimCommandState, + search: crate::vim_search::SearchQuery, +} + #[derive(Clone, Debug)] pub(crate) struct VimEditorEdit(VimAction); @@ -84,14 +91,19 @@ pub(super) enum VimAction { } #[derive(Debug, Default)] -pub(super) struct VimCommandState { +pub(crate) struct VimCommandState { pub(super) pending_change: Vec, - last_change: Vec, + pub(crate) last_change: Vec, changed: bool, pub(super) replaying: bool, } impl TextArea { + pub(crate) fn swap_vim_persistent_state(&mut self, state: &mut VimPersistentState) { + std::mem::swap(&mut self.vim_commands, &mut state.commands); + std::mem::swap(&mut self.vim_search.last, &mut state.search); + } + pub(crate) fn vim_repeat_actions(&self) -> Option> { (!self.vim_commands.last_change.is_empty()).then(|| self.vim_commands.last_change.clone()) } diff --git a/codex-rs/tui/src/bottom_pane/textarea/vim_search.rs b/codex-rs/tui/src/bottom_pane/textarea/vim_search.rs index 2091ede8cc..4bc7451eb3 100644 --- a/codex-rs/tui/src/bottom_pane/textarea/vim_search.rs +++ b/codex-rs/tui/src/bottom_pane/textarea/vim_search.rs @@ -26,7 +26,7 @@ use std::ops::Range; #[derive(Debug, Default)] pub(super) struct VimSearch { input: Option>, - last: SearchQuery, + pub(super) last: SearchQuery, } /// Footer query editor, boxed by its owning textarea to keep the draft and query independent. diff --git a/codex-rs/tui/src/keymap.rs b/codex-rs/tui/src/keymap.rs index 2f95913b21..9adc438438 100644 --- a/codex-rs/tui/src/keymap.rs +++ b/codex-rs/tui/src/keymap.rs @@ -210,6 +210,7 @@ pub(crate) struct VimNormalKeymap { pub(crate) start_delete_operator: Vec, pub(crate) start_yank_operator: Vec, pub(crate) start_change_operator: Vec, + pub(crate) undo: Vec, pub(crate) cancel_operator: Vec, } @@ -757,6 +758,7 @@ impl RuntimeKeymap { vim_normal, start_change_operator ), + undo: resolve_local!(keymap, defaults, vim_normal, undo), cancel_operator: resolve_local!(keymap, defaults, vim_normal, cancel_operator), }; @@ -889,6 +891,7 @@ impl RuntimeKeymap { keymap.vim_normal.start_change_operator.as_ref(), vim_normal.start_change_operator.as_slice(), ), + (keymap.vim_normal.undo.as_ref(), vim_normal.undo.as_slice()), ( keymap.vim_normal.cancel_operator.as_ref(), vim_normal.cancel_operator.as_slice(), @@ -959,7 +962,6 @@ impl RuntimeKeymap { }); } } - let mut vim_operator = VimOperatorKeymap { delete_line: resolve_local!(keymap, defaults, vim_operator, delete_line), yank_line: resolve_local!(keymap, defaults, vim_operator, yank_line), @@ -1350,7 +1352,12 @@ impl RuntimeKeymap { editor, vim_normal, vim_operator, - vim_search: VimSearchKeymap::default(), + vim_search: VimSearchKeymap { + forward: resolve_local!(keymap, defaults, vim_search, forward), + backward: resolve_local!(keymap, defaults, vim_search, backward), + next: resolve_local!(keymap, defaults, vim_search, next), + previous: resolve_local!(keymap, defaults, vim_search, previous), + }, vim_text_object, pager, list, @@ -1358,6 +1365,23 @@ impl RuntimeKeymap { approval, }; + if keymap.vim_normal.undo.is_none() { + let configured: Vec<_> = runtime_action_bindings(&resolved) + .filter(|action| { + action.id.context.overlaps(KeymapContext::VimNormal) + && bindings::configured_binding_for_action(keymap, action.id) + .is_some_and(Option::is_some) + }) + .flat_map(|action| action.bindings.iter().copied()) + .collect(); + resolved.vim_normal.undo.retain(|binding| { + !configured.contains(binding) + && !resolved.chords.bindings.iter().any(|chord| { + chord.action.context.overlaps(KeymapContext::VimNormal) + && chord.chord.prefix.parts() == binding.parts() + }) + }); + } resolved.configure_vim_search(keymap)?; resolved.validate_conflicts()?; chords::validate_chord_conflicts(&resolved)?; @@ -1534,6 +1558,7 @@ impl RuntimeKeymap { start_delete_operator: default_bindings![plain(KeyCode::Char('d'))], start_yank_operator: default_bindings![plain(KeyCode::Char('y'))], start_change_operator: default_bindings![plain(KeyCode::Char('c'))], + undo: default_bindings![plain(KeyCode::Char('u'))], cancel_operator: default_bindings![plain(KeyCode::Esc)], }, vim_search: VimSearchKeymap::default(), @@ -2955,6 +2980,47 @@ mod tests { })); } + #[test] + fn configured_legacy_bindings_prune_new_history_defaults() { + for (context, action, binding) in [ + ("vim_normal", "move_left", "u"), + ("vim_normal", "move_left", "u g"), + ("vim_search", "forward", "u"), + ("vim_search", "forward", "u g"), + ("composer", "submit", "u"), + ("global", "submit", "u"), + ("global", "queue", "u"), + ("global", "toggle_shortcuts", "u"), + ] { + let keymap = serde_json::from_value(serde_json::json!({ + (context): { (action): binding } + })) + .expect("config should deserialize"); + + let runtime = RuntimeKeymap::from_config(&keymap).expect("config should parse"); + + assert_eq!(runtime.vim_normal.undo, Vec::new()); + } + } + + #[test] + fn explicit_vim_history_bindings_still_conflict_with_legacy_bindings() { + let mut keymap = TuiKeymap::default(); + keymap.vim_normal.move_left = Some(one("u")); + keymap.vim_normal.undo = Some(one("u")); + expect_conflict(&keymap, "move_left", "undo"); + } + + #[test] + fn explicit_empty_arrays_unbind_vim_history_actions() { + let mut keymap = TuiKeymap::default(); + keymap.vim_normal.undo = Some(KeybindingsSpec::Many(vec![])); + + let runtime = RuntimeKeymap::from_config(&keymap).expect("config should parse"); + + assert!(runtime.vim_normal.undo.is_empty()); + } + #[test] fn configured_legacy_vim_operator_bindings_prune_new_text_object_defaults() { let mut keymap = TuiKeymap::default(); diff --git a/codex-rs/tui/src/keymap/bindings.rs b/codex-rs/tui/src/keymap/bindings.rs index 5d58c02dd3..ca83f16327 100644 --- a/codex-rs/tui/src/keymap/bindings.rs +++ b/codex-rs/tui/src/keymap/bindings.rs @@ -136,12 +136,21 @@ macro_rules! define_runtime_action_bindings { } } - /// Return the root-config slot for one runtime action. + /// Return the configured slot for one runtime action, including global fallbacks. pub(super) fn configured_binding_for_action( keymap: &TuiKeymap, action: KeymapActionId, ) -> Option<&Option> { match (action.context.config_name(), action.action) { + ("composer", "submit") if keymap.composer.submit.is_none() => { + Some(&keymap.global.submit) + } + ("composer", "queue") if keymap.composer.queue.is_none() => { + Some(&keymap.global.queue) + } + ("composer", "toggle_shortcuts") if keymap.composer.toggle_shortcuts.is_none() => { + Some(&keymap.global.toggle_shortcuts) + } $( $( ($context, stringify!($action)) => { @@ -310,6 +319,7 @@ define_runtime_action_bindings! { start_delete_operator, start_yank_operator, start_change_operator, + undo, cancel_operator, ], "vim_search" => VimSearch, vim_search, vim_search [forward, backward, next, previous], diff --git a/codex-rs/tui/src/keymap/vim_search.rs b/codex-rs/tui/src/keymap/vim_search.rs index c9d54ed050..da9ca862cc 100644 --- a/codex-rs/tui/src/keymap/vim_search.rs +++ b/codex-rs/tui/src/keymap/vim_search.rs @@ -45,7 +45,6 @@ impl RuntimeKeymap { ]; for (action, configured, bindings) in &mut actions { let path = format!("tui.keymap.vim_search.{action}"); - **bindings = resolve_bindings(configured.as_ref(), bindings, &path)?; if configured.is_none() { bindings.retain(|key| { !others.iter().any(|other| { diff --git a/codex-rs/tui/src/keymap_setup/actions.rs b/codex-rs/tui/src/keymap_setup/actions.rs index 1125c8349a..3ad272e0fd 100644 --- a/codex-rs/tui/src/keymap_setup/actions.rs +++ b/codex-rs/tui/src/keymap_setup/actions.rs @@ -153,6 +153,7 @@ pub(super) const KEYMAP_ACTIONS: &[KeymapActionDescriptor] = &[ action("vim_normal", "Vim normal", "start_delete_operator", "Begin a delete operator and wait for a motion."), action("vim_normal", "Vim normal", "start_yank_operator", "Begin a yank operator and wait for a motion."), action("vim_normal", "Vim normal", "start_change_operator", "Begin a change operator and wait for a motion or text object."), + action("vim_normal", "Vim normal", "undo", "Undo the last complete edit."), action("vim_normal", "Vim normal", "cancel_operator", "Cancel a pending Vim operator."), action("vim_search", "Vim search", "forward", "Search forward in the active buffer."), action("vim_search", "Vim search", "backward", "Search backward in the active buffer."), @@ -323,6 +324,7 @@ pub(super) fn binding_slot<'a>( ("vim_normal", "start_delete_operator") => Some(&mut keymap.vim_normal.start_delete_operator), ("vim_normal", "start_yank_operator") => Some(&mut keymap.vim_normal.start_yank_operator), ("vim_normal", "start_change_operator") => Some(&mut keymap.vim_normal.start_change_operator), + ("vim_normal", "undo") => Some(&mut keymap.vim_normal.undo), ("vim_normal", "cancel_operator") => Some(&mut keymap.vim_normal.cancel_operator), ("vim_search", "forward") => Some(&mut keymap.vim_search.forward), ("vim_search", "backward") => Some(&mut keymap.vim_search.backward), diff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_custom.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_custom.snap index 58432b15bd..b057c11c90 100644 --- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_custom.snap +++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_custom.snap @@ -5,7 +5,7 @@ expression: "render_picker(params, 120)" Keymap All configurable shortcuts. - 135 actions, 1 customized, 5 unbound. + 136 actions, 1 customized, 5 unbound. [All] Common Customized (1) Unbound (5) App Composer Editor Vim Navigation Agents Approval Debug diff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_fast_mode_enabled.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_fast_mode_enabled.snap index f95f620048..2c4456772d 100644 --- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_fast_mode_enabled.snap +++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_fast_mode_enabled.snap @@ -5,7 +5,7 @@ expression: "render_picker(params, 120)" Keymap All configurable shortcuts. - 136 actions, 0 customized, 6 unbound. + 137 actions, 0 customized, 6 unbound. [All] Common Customized (0) Unbound (6) App Composer Editor Vim Navigation Agents Approval Debug diff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_first_actions.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_first_actions.snap index 2696436fc0..cf2365caab 100644 --- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_first_actions.snap +++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_first_actions.snap @@ -2,14 +2,14 @@ source: tui/src/keymap_setup.rs expression: snapshot --- -tab: All (135 selectable) +tab: All (136 selectable) tab: Common (20 selectable) tab: Customized (0) (0 selectable) tab: Unbound (5) (5 selectable) tab: App (14 selectable) tab: Composer (5 selectable) tab: Editor (17 selectable) -tab: Vim (66 selectable) +tab: Vim (67 selectable) tab: Navigation (20 selectable) tab: Agents (5 selectable) tab: Approval (8 selectable) diff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_global_chord.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_global_chord.snap index d74a43b933..3eb29aff66 100644 --- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_global_chord.snap +++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_global_chord.snap @@ -5,7 +5,7 @@ expression: "render_picker(params, 120)" Keymap All configurable shortcuts. - 135 actions, 1 customized, 5 unbound. + 136 actions, 1 customized, 5 unbound. [All] Common Customized (1) Unbound (5) App Composer Editor Vim Navigation Agents Approval Debug diff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_narrow.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_narrow.snap index 4cd05f21d8..651dc681e0 100644 --- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_narrow.snap +++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_narrow.snap @@ -5,7 +5,7 @@ expression: "render_picker(params, 78)" Keymap All configurable shortcuts. - 135 actions, 0 customized, 5 unbound. + 136 actions, 0 customized, 5 unbound. [All] Common Customized (0) Unbound (5) App Composer Editor Vim Navigation Agents Approval Debug diff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_wide.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_wide.snap index 8450e8527b..35e7d5f991 100644 --- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_wide.snap +++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_wide.snap @@ -5,7 +5,7 @@ expression: "render_picker(params, 120)" Keymap All configurable shortcuts. - 135 actions, 0 customized, 5 unbound. + 136 actions, 0 customized, 5 unbound. [All] Common Customized (0) Unbound (5) App Composer Editor Vim Navigation Agents Approval Debug