Lightweight coding agent that runs in your terminal
Rust
Add dot-repeat to Vim mode (#40521)
Benjamin Carlssonc1db22a3cd5b
diff --git a/codex-rs/config/src/tui_keymap.rs b/codex-rs/config/src/tui_keymap.rsindex 7fe6572586..fbd2fba603 100644--- a/codex-rs/config/src/tui_keymap.rs+++ b/codex-rs/config/src/tui_keymap.rs@@ -239,6 +239,8 @@ pub struct TuiVimNormalKeymap {pub delete_char: Option<KeybindingsSpec>,/// Replace the character under the cursor (`r`).pub replace_char: Option<KeybindingsSpec>,+ /// Repeat the last complete edit (`.`).+ pub repeat_last_change: Option<KeybindingsSpec>,/// Delete character under cursor and enter insert mode (`s`).pub substitute_char: Option<KeybindingsSpec>,/// Delete from cursor to end of line (`D`).diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.jsonindex 42b9991e9a..e934ad844a 100644--- a/codex-rs/core/config.schema.json+++ b/codex-rs/core/config.schema.json@@ -3801,6 +3801,7 @@"open_line_above": null,"open_line_below": null,"paste_after": null,+ "repeat_last_change": null,"replace_char": null,"start_change_operator": null,"start_delete_operator": null,@@ -4608,6 +4609,7 @@"open_line_above": null,"open_line_below": null,"paste_after": null,+ "repeat_last_change": null,"replace_char": null,"start_change_operator": null,"start_delete_operator": null,@@ -5016,6 +5018,14 @@],"description": "Paste after cursor (`p`)."},+ "repeat_last_change": {+ "allOf": [+ {+ "$ref": "#/definitions/KeybindingsSpec"+ }+ ],+ "description": "Repeat the last complete edit (`.`)."+ },"replace_char": {"allOf": [{diff --git a/codex-rs/tui/src/bottom_pane/textarea.rs b/codex-rs/tui/src/bottom_pane/textarea.rsindex 57b0278256..ba9ff40024 100644--- a/codex-rs/tui/src/bottom_pane/textarea.rs+++ b/codex-rs/tui/src/bottom_pane/textarea.rs@@ -51,7 +51,12 @@ use self::vim::VimMode;use self::vim::VimMotion;use self::vim::VimOperator;use self::vim::VimPending;+use self::vim::VimTextObject;use self::vim::VimTextObjectScope;+use self::vim_commands::VimAction;+use self::vim_commands::VimCommandState;+use self::vim_commands::VimEditTarget;+use self::vim_commands::VimInsertPosition;const WORD_SEPARATORS: &str = "`~!@#$%^&*()-=+[{]}\\|;:'\",.<>/?";@@ -131,6 +136,7 @@ pub(crate) struct TextArea {vim_enabled: bool,vim_mode: VimMode,vim_pending: VimPending,+ vim_commands: VimCommandState,editor_keymap: Arc<EditorKeymap>,vim_normal_keymap: VimNormalKeymap,vim_operator_keymap: VimOperatorKeymap,@@ -172,6 +178,7 @@ impl TextArea {vim_enabled: false,vim_mode: VimMode::Insert,vim_pending: VimPending::None,+ vim_commands: VimCommandState::default(),editor_keymap: defaults.editor,vim_normal_keymap: defaults.vim_normal,vim_operator_keymap: defaults.vim_operator,@@ -240,6 +247,8 @@ impl TextArea {self.cursor_pos = self.clamp_pos_to_nearest_boundary(self.cursor_pos);self.wrap_cache.replace(None);self.preferred_col = None;+ self.vim_pending = VimPending::None;+ self.vim_commands = VimCommandState::default();}/// Enable or disable modal Vim editing for the textarea.@@ -251,6 +260,7 @@ impl TextArea {pub(crate) fn set_vim_enabled(&mut self, enabled: bool) {self.vim_enabled = enabled;self.vim_pending = VimPending::None;+ self.vim_commands = VimCommandState::default();self.vim_mode = if enabled {VimMode::Normal} else {@@ -386,6 +396,7 @@ impl TextArea {}pub fn insert_str(&mut self, text: &str) {+ self.record_vim_inserted_text(text);self.insert_str_at(self.cursor_pos, text);}@@ -551,7 +562,7 @@ impl TextArea {}if keymap.delete_backward_word.is_pressed(event) {- self.delete_backward_word();+ self.apply_vim_insert_action(VimAction::DeleteBackwardWord);return;}@@ -569,27 +580,27 @@ impl TextArea {}if keymap.delete_backward.is_pressed(event) {- self.delete_backward(/*n*/ 1);+ self.apply_vim_insert_action(VimAction::DeleteBackward);return;}if keymap.delete_forward_word.is_pressed(event) {- self.delete_forward_word();+ self.apply_vim_insert_action(VimAction::DeleteForwardWord);return;}if keymap.delete_forward.is_pressed(event) {- self.delete_forward(/*n*/ 1);+ self.apply_vim_insert_action(VimAction::DeleteForward);return;}if keymap.kill_line_start.is_pressed(event) {- self.kill_to_beginning_of_line();+ self.apply_vim_insert_action(VimAction::KillLineStart);return;}if keymap.kill_whole_line.is_pressed(event) {- self.kill_current_line();+ self.apply_vim_insert_action(VimAction::KillLine);return;}if keymap.kill_line_end.is_pressed(event) {- self.kill_to_end_of_line();+ self.apply_vim_insert_action(VimAction::KillLineEnd);return;}if keymap.yank.is_pressed(event) {@@ -597,27 +608,27 @@ impl TextArea {return;}if keymap.move_word_left.is_pressed(event) {- self.set_cursor(self.beginning_of_previous_word());+ self.apply_vim_insert_action(VimAction::MoveWordLeft);return;}if keymap.move_word_right.is_pressed(event) {- self.set_cursor(self.end_of_next_word());+ self.apply_vim_insert_action(VimAction::MoveWordRight);return;}if keymap.move_left.is_pressed(event) {- self.move_cursor_left();+ self.apply_vim_insert_action(VimAction::MoveLeft);return;}if keymap.move_right.is_pressed(event) {- self.move_cursor_right();+ self.apply_vim_insert_action(VimAction::MoveRight);return;}if keymap.move_up.is_pressed(event) {- self.move_cursor_up();+ self.apply_vim_insert_action(VimAction::MoveUp);return;}if keymap.move_down.is_pressed(event) {- self.move_cursor_down();+ self.apply_vim_insert_action(VimAction::MoveDown);return;}if keymap.move_line_start.is_pressed(event) {@@ -629,7 +640,7 @@ impl TextArea {..});- self.move_cursor_to_beginning_of_line(move_up_at_bol);+ self.apply_vim_insert_action(VimAction::MoveLineStart { move_up_at_bol });return;}if keymap.move_line_end.is_pressed(event) {@@ -641,7 +652,7 @@ impl TextArea {..});- self.move_cursor_to_end_of_line(move_down_at_eol);+ self.apply_vim_insert_action(VimAction::MoveLineEnd { move_down_at_eol });return;}@@ -663,25 +674,33 @@ impl TextArea {}fn handle_vim_input(&mut self, event: KeyEvent) {+ let prior_mode = self.vim_mode;match self.vim_mode {VimMode::Insert => self.handle_vim_insert(event),VimMode::Normal => self.handle_vim_normal(event),}+ if prior_mode == VimMode::Insert && self.vim_mode == VimMode::Normal {+ self.finish_pending_vim_change();+ }}fn handle_vim_insert(&mut self, event: KeyEvent) {if matches!(event.code, KeyCode::Esc) {- let bol = self.beginning_of_current_line();- if self.cursor_pos > bol {- self.cursor_pos = self.prev_atomic_boundary(self.cursor_pos).max(bol);- }- self.enter_vim_normal_mode();+ self.leave_vim_insert_mode();return;}let keymap = self.editor_keymap.clone();self.input_with_keymap(event, &keymap);}+ fn leave_vim_insert_mode(&mut self) {+ let bol = self.beginning_of_current_line();+ if self.cursor_pos > bol {+ self.cursor_pos = self.prev_atomic_boundary(self.cursor_pos).max(bol);+ }+ self.enter_vim_normal_mode();+ }+fn handle_vim_normal(&mut self, event: KeyEvent) {let pending = std::mem::replace(&mut self.vim_pending, VimPending::None);match pending {@@ -701,44 +720,27 @@ impl TextArea {}if self.vim_normal_keymap.enter_insert.is_pressed(event) {- self.vim_mode = VimMode::Insert;+ self.start_vim_edit(VimAction::Insert(VimInsertPosition::Cursor));return;}if self.vim_normal_keymap.append_after_cursor.is_pressed(event) {- let next = self.next_atomic_boundary(self.cursor_pos);- self.set_cursor(next);- self.vim_mode = VimMode::Insert;+ self.start_vim_edit(VimAction::Insert(VimInsertPosition::AfterCursor));return;}if self.vim_normal_keymap.append_line_end.is_pressed(event) {- self.set_cursor(self.end_of_current_line());- self.vim_mode = VimMode::Insert;+ self.start_vim_edit(VimAction::Insert(VimInsertPosition::LineEnd));return;}if self.vim_normal_keymap.insert_line_start.is_pressed(event) {- self.set_cursor(self.first_non_blank_of_current_line());- self.vim_mode = VimMode::Insert;+ self.start_vim_edit(VimAction::Insert(VimInsertPosition::LineStart));return;}if self.vim_normal_keymap.open_line_below.is_pressed(event) {- let eol = self.end_of_current_line();- let old_len = self.text.len();- let insert_at = if eol < old_len { eol + 1 } else { eol };- self.insert_str_at(insert_at, "\n");- let cursor = if eol < old_len {- insert_at- } else {- insert_at + 1- };- self.set_cursor(cursor);- self.vim_mode = VimMode::Insert;+ self.start_vim_edit(VimAction::Insert(VimInsertPosition::OpenBelow));return;}if self.vim_normal_keymap.open_line_above.is_pressed(event) {- let bol = self.beginning_of_current_line();- self.insert_str_at(bol, "\n");- self.set_cursor(bol);- self.vim_mode = VimMode::Insert;+ self.start_vim_edit(VimAction::Insert(VimInsertPosition::OpenAbove));return;}if self.vim_normal_keymap.move_left.is_pressed(event) {@@ -778,23 +780,19 @@ impl TextArea {return;}if self.vim_normal_keymap.delete_char.is_pressed(event) {- self.delete_forward_kill(/*n*/ 1);+ self.start_vim_edit(VimAction::Delete(VimEditTarget::Character));return;}if self.vim_normal_keymap.substitute_char.is_pressed(event) {- if self.cursor_pos < self.end_of_current_line() {- self.delete_forward_kill(/*n*/ 1);- }- self.vim_mode = VimMode::Insert;+ self.start_vim_edit(VimAction::Change(VimEditTarget::Character));return;}if self.vim_normal_keymap.delete_to_line_end.is_pressed(event) {- self.vim_kill_to_end_of_line();+ self.start_vim_edit(VimAction::Delete(VimEditTarget::LineEnd));return;}if self.vim_normal_keymap.change_to_line_end.is_pressed(event) {- self.vim_kill_to_end_of_line();- self.vim_mode = VimMode::Insert;+ self.start_vim_edit(VimAction::Change(VimEditTarget::LineEnd));return;}if self.vim_normal_keymap.yank_line.is_pressed(event) {@@ -802,7 +800,7 @@ impl TextArea {return;}if self.vim_normal_keymap.paste_after.is_pressed(event) {- self.paste_after_cursor();+ self.start_vim_edit(VimAction::PasteAfter);return;}if self@@ -834,7 +832,7 @@ impl TextArea {fn handle_vim_operator(&mut self, op: VimOperator, event: KeyEvent) -> bool {if op == VimOperator::Delete && self.vim_operator_keymap.delete_line.is_pressed(event) {- self.kill_current_line();+ self.start_vim_edit(VimAction::Delete(VimEditTarget::Line));return true;}if op == VimOperator::Yank && self.vim_operator_keymap.yank_line.is_pressed(event) {@@ -853,7 +851,15 @@ impl TextArea {}if let Some(motion) = self.vim_motion_for_event(event) {- self.apply_vim_operator(op, motion);+ match op {+ VimOperator::Delete => {+ self.start_vim_edit(VimAction::Delete(VimEditTarget::Motion(motion)));+ }+ VimOperator::Change => {+ self.start_vim_edit(VimAction::Change(VimEditTarget::Motion(motion)));+ }+ VimOperator::Yank => self.apply_vim_operator(op, motion),+ }return true;}if op == VimOperator::Change@@ -862,9 +868,7 @@ impl TextArea {.start_change_operator.is_pressed(event){- let range = self.beginning_of_current_line()..self.end_of_current_line();- self.kill_line_range(range);- self.vim_mode = VimMode::Insert;+ self.start_vim_edit(VimAction::Change(VimEditTarget::Line));return true;}false@@ -882,8 +886,24 @@ impl TextArea {let Some(object) = self.vim_text_object_for_event(event) else {return false;};- if let Some(range) = self.text_object_range(object, scope) {- self.apply_vim_operator_to_range(op, range);+ match op {+ VimOperator::Delete => {+ self.start_vim_edit(VimAction::Delete(VimEditTarget::TextObject {+ scope,+ object,+ }));+ }+ VimOperator::Change => {+ self.start_vim_edit(VimAction::Change(VimEditTarget::TextObject {+ scope,+ object,+ }));+ }+ VimOperator::Yank => {+ if let Some(range) = self.text_object_range(object, scope) {+ self.apply_vim_operator_to_range(op, range);+ }+ }}true}diff --git a/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs b/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rsindex 0018c734df..1cee3b7b3b 100644--- a/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs+++ b/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs@@ -1,13 +1,293 @@-//! Pending Vim editing commands.+//! Semantic Vim editing transactions and complete-change replay.use super::TextArea;+use super::VimMode;+use super::VimMotion;+use super::VimOperator;use super::VimPending;+use super::VimTextObject;+use super::VimTextObjectScope;use crate::key_hint::KeyBindingListExt;use crossterm::event::KeyCode;use crossterm::event::KeyEvent;use crossterm::event::KeyModifiers;+#[derive(Clone, Debug)]+pub(crate) enum VimEdit {+ Editor(VimEditorEdit),+ Text(String),+}++#[derive(Clone, Debug)]+pub(crate) struct VimEditorEdit(VimAction);++#[derive(Clone, Copy, Debug)]+pub(super) enum VimInsertPosition {+ Cursor,+ AfterCursor,+ LineStart,+ LineEnd,+ OpenAbove,+ OpenBelow,+}++#[derive(Clone, Copy, Debug)]+pub(super) enum VimEditTarget {+ Character,+ Line,+ LineEnd,+ Motion(VimMotion),+ TextObject {+ scope: VimTextObjectScope,+ object: VimTextObject,+ },+}++#[derive(Clone, Copy, Debug)]+pub(super) enum VimAction {+ Insert(VimInsertPosition),+ Delete(VimEditTarget),+ Change(VimEditTarget),+ Replace(char),+ PasteAfter,+ DeleteBackward,+ DeleteForward,+ DeleteBackwardWord,+ DeleteForwardWord,+ KillLineStart,+ KillLine,+ KillLineEnd,+ MoveLeft,+ MoveRight,+ MoveUp,+ MoveDown,+ MoveWordLeft,+ MoveWordRight,+ MoveLineStart { move_up_at_bol: bool },+ MoveLineEnd { move_down_at_eol: bool },+}++#[derive(Debug, Default)]+pub(super) struct VimCommandState {+ pending_change: Vec<VimEdit>,+ last_change: Vec<VimEdit>,+ changed: bool,+ replaying: bool,+}+impl TextArea {+ pub(crate) fn vim_repeat_actions(&self) -> Option<Vec<VimEdit>> {+ (!self.vim_commands.last_change.is_empty()).then(|| self.vim_commands.last_change.clone())+ }++ pub(super) fn record_vim_inserted_text(&mut self, text: &str) {+ if !self.vim_enabled+ || self.vim_mode != VimMode::Insert+ || self.vim_commands.replaying+ || self.vim_commands.pending_change.is_empty()+ || text.is_empty()+ {+ return;+ }+ if let Some(VimEdit::Text(pending)) = self.vim_commands.pending_change.last_mut() {+ pending.push_str(text);+ } else {+ self.vim_commands+ .pending_change+ .push(VimEdit::Text(text.to_owned()));+ }+ self.vim_commands.changed = true;+ }++ pub(super) fn apply_vim_insert_action(&mut self, action: VimAction) {+ let recording = self.vim_enabled+ && self.vim_mode == VimMode::Insert+ && !self.vim_commands.replaying+ && !self.vim_commands.pending_change.is_empty();+ let prior_len = self.text.len();+ self.apply_vim_editor_action(action);+ let changed = self.text.len() != prior_len;+ let deletion = matches!(+ action,+ VimAction::DeleteBackward+ | VimAction::DeleteForward+ | VimAction::DeleteBackwardWord+ | VimAction::DeleteForwardWord+ | VimAction::KillLineStart+ | VimAction::KillLine+ | VimAction::KillLineEnd+ );+ if recording && (changed || !deletion) {+ self.vim_commands+ .pending_change+ .push(VimEdit::Editor(VimEditorEdit(action)));+ }+ self.vim_commands.changed |= recording && changed;+ }++ pub(super) fn start_vim_edit(&mut self, action: VimAction) -> bool {+ let prior_len = self.text.len();+ self.vim_commands.pending_change = vec![VimEdit::Editor(VimEditorEdit(action))];+ self.vim_commands.changed = false;+ if !self.apply_vim_editor_action(action) {+ self.vim_commands.pending_change.clear();+ return false;+ }+ self.vim_commands.changed =+ self.text.len() != prior_len || matches!(action, VimAction::Replace(_));+ if self.vim_mode == VimMode::Normal {+ self.finish_pending_vim_change();+ }+ true+ }++ pub(super) fn finish_pending_vim_change(&mut self) {+ if self.vim_commands.changed {+ self.vim_commands.last_change = std::mem::take(&mut self.vim_commands.pending_change);+ } else {+ self.vim_commands.pending_change.clear();+ }+ self.vim_commands.changed = false;+ }++ pub(crate) fn begin_vim_repeat(&mut self) -> Option<Vec<VimEdit>> {+ let edits = self.vim_repeat_actions()?;+ self.vim_commands.replaying = true;+ Some(edits)+ }++ pub(crate) fn finish_vim_repeat(&mut self) {+ if self.vim_mode == VimMode::Insert {+ self.leave_vim_insert_mode();+ }+ self.vim_pending = VimPending::None;+ self.vim_commands.replaying = false;+ }++ pub(crate) fn apply_vim_edit(&mut self, edit: &VimEdit) -> bool {+ match edit {+ VimEdit::Editor(VimEditorEdit(action)) => self.apply_vim_editor_action(*action),+ VimEdit::Text(text) => {+ if self.vim_mode != VimMode::Insert {+ return false;+ }+ self.insert_str(text);+ true+ }+ }+ }++ fn apply_vim_editor_action(&mut self, action: VimAction) -> bool {+ let prior_len = self.text.len();+ match action {+ VimAction::Insert(position) => {+ match position {+ VimInsertPosition::Cursor => {}+ VimInsertPosition::AfterCursor => {+ self.set_cursor(self.next_atomic_boundary(self.cursor_pos));+ }+ VimInsertPosition::LineStart => {+ self.set_cursor(self.first_non_blank_of_current_line());+ }+ VimInsertPosition::LineEnd => self.set_cursor(self.end_of_current_line()),+ VimInsertPosition::OpenAbove => {+ let bol = self.beginning_of_current_line();+ self.insert_str_at(bol, "\n");+ self.set_cursor(bol);+ }+ VimInsertPosition::OpenBelow => {+ let eol = self.end_of_current_line();+ let insert_at = if eol < prior_len { eol + 1 } else { eol };+ self.insert_str_at(insert_at, "\n");+ self.set_cursor(if eol < prior_len {+ insert_at+ } else {+ insert_at + 1+ });+ }+ }+ self.vim_mode = VimMode::Insert;+ }+ VimAction::Delete(target) | VimAction::Change(target) => {+ let operator = if matches!(action, VimAction::Delete(_)) {+ VimOperator::Delete+ } else {+ VimOperator::Change+ };+ match target {+ VimEditTarget::Character => {+ if self.cursor_pos < self.end_of_current_line() {+ self.delete_forward_kill(/*n*/ 1);+ }+ if operator == VimOperator::Change {+ self.vim_mode = VimMode::Insert;+ }+ }+ VimEditTarget::Line => {+ if operator == VimOperator::Delete {+ self.kill_current_line();+ } else {+ let range =+ self.beginning_of_current_line()..self.end_of_current_line();+ self.kill_line_range(range);+ self.vim_mode = VimMode::Insert;+ }+ }+ VimEditTarget::LineEnd => {+ self.vim_kill_to_end_of_line();+ if operator == VimOperator::Change {+ self.vim_mode = VimMode::Insert;+ }+ }+ VimEditTarget::Motion(motion) => self.apply_vim_operator(operator, motion),+ VimEditTarget::TextObject { scope, object } => {+ let Some(range) = self.text_object_range(object, scope) else {+ return false;+ };+ self.apply_vim_operator_to_range(operator, range);+ }+ }+ if operator == VimOperator::Change {+ return self.vim_mode == VimMode::Insert;+ }+ return self.text.len() != prior_len;+ }+ VimAction::Replace(ch) => {+ if self.cursor_pos >= self.end_of_current_line() {+ return false;+ }+ let start = self.cursor_pos;+ let end = self.next_atomic_boundary(start);+ self.replace_range(start..end, &ch.to_string());+ self.set_cursor(start + usize::from(ch == '\n'));+ }+ VimAction::PasteAfter => {+ self.paste_after_cursor();+ return self.text.len() != prior_len;+ }+ VimAction::DeleteBackward => self.delete_backward(/*n*/ 1),+ VimAction::DeleteForward => self.delete_forward(/*n*/ 1),+ VimAction::DeleteBackwardWord => self.delete_backward_word(),+ VimAction::DeleteForwardWord => self.delete_forward_word(),+ VimAction::KillLineStart => self.kill_to_beginning_of_line(),+ VimAction::KillLine => self.kill_current_line(),+ VimAction::KillLineEnd => self.kill_to_end_of_line(),+ VimAction::MoveLeft => self.move_cursor_left(),+ VimAction::MoveRight => self.move_cursor_right(),+ VimAction::MoveUp => self.move_cursor_up(),+ VimAction::MoveDown => self.move_cursor_down(),+ VimAction::MoveWordLeft => self.set_cursor(self.beginning_of_previous_word()),+ VimAction::MoveWordRight => self.set_cursor(self.end_of_next_word()),+ VimAction::MoveLineStart { move_up_at_bol } => {+ self.move_cursor_to_beginning_of_line(move_up_at_bol);+ }+ VimAction::MoveLineEnd { move_down_at_eol } => {+ self.move_cursor_to_end_of_line(move_down_at_eol);+ }+ }+ true+ }+pub(super) fn handle_vim_extra_command(&mut self, event: KeyEvent) -> bool {if self.vim_normal_keymap.replace_char.is_pressed(event)&& self.cursor_pos < self.end_of_current_line()@@ -15,6 +295,17 @@ impl TextArea {self.vim_pending = VimPending::Replace;return true;}+ if self.vim_normal_keymap.repeat_last_change.is_pressed(event) {+ if let Some(edits) = self.begin_vim_repeat() {+ for edit in edits {+ if !self.apply_vim_edit(&edit) {+ break;+ }+ }+ self.finish_vim_repeat();+ }+ return true;+ }false}@@ -22,10 +313,7 @@ impl TextArea {match pending {VimPending::Replace => {if let Some(ch) = vim_command_char(event) {- let start = self.cursor_pos;- let end = self.next_atomic_boundary(start);- self.replace_range(start..end, &ch.to_string());- self.set_cursor(start + usize::from(ch == '\n'));+ self.start_vim_edit(VimAction::Replace(ch));}}VimPending::None | VimPending::Operator(_) | VimPending::TextObject { .. } => {}diff --git a/codex-rs/tui/src/bottom_pane/textarea/vim_commands_tests.rs b/codex-rs/tui/src/bottom_pane/textarea/vim_commands_tests.rsindex a8dc524e49..512cbd7aa9 100644--- a/codex-rs/tui/src/bottom_pane/textarea/vim_commands_tests.rs+++ b/codex-rs/tui/src/bottom_pane/textarea/vim_commands_tests.rs@@ -1,4 +1,5 @@use super::super::TextArea;+use super::VimAction;use crossterm::event::KeyCode;use crossterm::event::KeyEvent;use crossterm::event::KeyModifiers;@@ -58,6 +59,181 @@ fn replace_character_preserves_normal_mode_and_grapheme_boundaries() {}}+#[test]+fn repeat_replays_delete_replace_and_complete_change() {+ let mut textarea = vim_textarea("alpha beta gamma", /*cursor*/ 0);+ keys(&mut textarea, "dw.");+ assert_eq!(textarea.text(), "gamma");++ let mut textarea = vim_textarea("abc", /*cursor*/ 0);+ keys(&mut textarea, "rXl.");+ assert_eq!(textarea.text(), "XXc");++ let mut textarea = vim_textarea("one two three", /*cursor*/ 0);+ keys(&mut textarea, "cwX");+ escape(&mut textarea);+ keys(&mut textarea, "w.");+ assert_eq!(textarea.text(), "X X three");+ assert_eq!(textarea.vim_mode_label(), Some("Normal"));+}++#[test]+fn repeat_records_pasted_insertions_and_survives_keymap_changes() {+ let mut textarea = vim_textarea("", /*cursor*/ 0);+ keys(&mut textarea, "i");+ textarea.insert_str("foo");+ escape(&mut textarea);+ keys(&mut textarea, ".");+ assert_eq!(textarea.text(), "fofooo");++ let mut textarea = vim_textarea("one two three", /*cursor*/ 0);+ keys(&mut textarea, "dw");+ let mut keymap = crate::keymap::RuntimeKeymap::defaults();+ keymap.vim_normal.start_delete_operator = vec![crate::key_hint::plain(KeyCode::Char('z'))];+ textarea.set_keymap_bindings(&keymap);+ keys(&mut textarea, ".");+ assert_eq!(textarea.text(), "three");+}++#[test]+fn repeat_aborts_when_change_motion_cannot_start() {+ let mut textarea = vim_textarea("one\ntwo\nthree", /*cursor*/ 0);+ keys(&mut textarea, "cjfoo");+ escape(&mut textarea);+ keys(&mut textarea, "j");+ let original = (textarea.text().to_owned(), textarea.cursor());++ keys(&mut textarea, ".");++ assert_eq!(+ (textarea.text(), textarea.cursor()),+ (original.0.as_str(), original.1)+ );+ assert_eq!(textarea.vim_mode_label(), Some("Normal"));+}++#[test]+fn repeat_distinguishes_insert_mode_deletions_from_noops() {+ let mut textarea = vim_textarea("abcd", /*cursor*/ 3);+ keys(&mut textarea, "i");+ textarea.input(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));+ escape(&mut textarea);+ keys(&mut textarea, "l.");+ assert_eq!(textarea.text(), "ad");++ let mut textarea = vim_textarea("abc", /*cursor*/ 0);+ keys(&mut textarea, "xi");+ textarea.input(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));+ escape(&mut textarea);+ keys(&mut textarea, ".");+ assert_eq!(textarea.text(), "c");++ let mut textarea = vim_textarea("one two", /*cursor*/ 0);+ keys(&mut textarea, "i");+ textarea.input(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));+ keys(&mut textarea, "X");+ escape(&mut textarea);+ keys(&mut textarea, "w.");+ assert_eq!(textarea.text(), "Xone Xtwo");+}++#[test]+fn repeat_omits_ineffective_deletions_before_inserted_text() {+ for (action, cursor, repeat_cursor, expected) in [+ (VimAction::DeleteBackward, 0, 5, "Xone Xtwo\n"),+ (VimAction::DeleteBackwardWord, 0, 5, "Xone Xtwo\n"),+ (VimAction::KillLineStart, 0, 5, "Xone Xtwo\n"),+ (VimAction::DeleteForward, 8, 4, "one Xtwo\nX"),+ (VimAction::DeleteForwardWord, 8, 4, "one Xtwo\nX"),+ (VimAction::KillLineEnd, 8, 4, "one Xtwo\nX"),+ (VimAction::KillLine, 8, 4, "one Xtwo\nX"),+ ] {+ let mut textarea = vim_textarea("one two\n", cursor);+ keys(&mut textarea, "i");+ textarea.apply_vim_insert_action(action);+ keys(&mut textarea, "X");+ escape(&mut textarea);+ textarea.set_cursor(repeat_cursor);++ keys(&mut textarea, ".");++ assert_eq!(textarea.text(), expected, "{action:?}");+ }+}++#[test]+fn repeat_replays_resolved_insert_actions_after_editor_keymap_changes() {+ let mut textarea = vim_textarea("abc", /*cursor*/ 0);+ keys(&mut textarea, "ix");+ textarea.input(KeyEvent::new(KeyCode::Left, KeyModifiers::NONE));+ keys(&mut textarea, "y");+ escape(&mut textarea);++ let mut keymap = crate::keymap::RuntimeKeymap::defaults();+ std::sync::Arc::make_mut(&mut keymap.editor).move_left =+ vec![crate::key_hint::plain(KeyCode::Char('z'))];+ textarea.set_keymap_bindings(&keymap);+ keys(&mut textarea, ".");++ assert_eq!(textarea.text(), "yxyxabc");+}++#[test]+fn repeat_replays_literal_tab_insertions() {+ let mut textarea = vim_textarea("", /*cursor*/ 0);+ keys(&mut textarea, "i");+ textarea.insert_str("\t");+ escape(&mut textarea);++ keys(&mut textarea, ".");++ assert_eq!(textarea.text(), "\t\t");+}++#[test]+fn repeat_replays_literal_newlines_with_custom_editor_bindings() {+ let mut textarea = vim_textarea("", /*cursor*/ 0);+ std::sync::Arc::make_mut(&mut textarea.editor_keymap).insert_newline =+ vec![crate::key_hint::plain(KeyCode::Char('n'))];+ keys(&mut textarea, "i");+ textarea.insert_str("\n");+ escape(&mut textarea);++ keys(&mut textarea, ".");++ assert_eq!(textarea.text(), "\n\n");+}++#[test]+fn repeat_uses_configured_binding_and_supports_unbinding() {+ let mut textarea = vim_textarea("one two three", /*cursor*/ 0);+ let mut keymap = crate::keymap::RuntimeKeymap::defaults();+ keymap.vim_normal.repeat_last_change = vec![crate::key_hint::plain(KeyCode::Char('z'))];+ textarea.set_keymap_bindings(&keymap);++ keys(&mut textarea, "dwz");+ assert_eq!(textarea.text(), "three");++ keymap.vim_normal.repeat_last_change.clear();+ textarea.set_keymap_bindings(&keymap);+ keys(&mut textarea, "z");+ assert_eq!(textarea.text(), "three");+}++#[test]+fn replacing_the_buffer_discards_incomplete_dot_repeat_history() {+ let mut textarea = vim_textarea("", /*cursor*/ 0);+ keys(&mut textarea, "iold");+ textarea.set_text_clearing_elements("");+ textarea.enter_vim_normal_mode();++ keys(&mut textarea, "iX");+ escape(&mut textarea);+ keys(&mut textarea, ".");++ assert_eq!(textarea.text(), "XX");+}+#[test]fn replace_character_uses_configured_binding_and_supports_unbinding() {let mut textarea = vim_textarea("abc", /*cursor*/ 0);@@ -157,3 +333,24 @@ fn editor_commands_have_visual_snapshot_coverage() {^"###);}++#[test]+fn dot_repeat_has_visual_snapshot_coverage() {+ let mut textarea = vim_textarea("alpha beta\ngamma delta", /*cursor*/ 0);+ let mut states = Vec::new();+ for command in ["dw", "."] {+ keys(&mut textarea, command);+ states.push(format!(+ "{command}: {}\n{}^",+ textarea.text().replace('\n', "\\n"),+ " ".repeat(textarea.cursor())+ ));+ }+ insta::assert_snapshot!(states.join("\n\n"), @r###"+ dw: beta\ngamma delta+ ^++ .: gamma delta+ ^+ "###);+}diff --git a/codex-rs/tui/src/keymap.rs b/codex-rs/tui/src/keymap.rsindex 193d048e75..6c7edf7e3e 100644--- a/codex-rs/tui/src/keymap.rs+++ b/codex-rs/tui/src/keymap.rs@@ -188,6 +188,7 @@ pub(crate) struct VimNormalKeymap {pub(crate) move_line_end: Vec<KeyBinding>,pub(crate) delete_char: Vec<KeyBinding>,pub(crate) replace_char: Vec<KeyBinding>,+ pub(crate) repeat_last_change: Vec<KeyBinding>,pub(crate) substitute_char: Vec<KeyBinding>,pub(crate) delete_to_line_end: Vec<KeyBinding>,pub(crate) change_to_line_end: Vec<KeyBinding>,@@ -717,6 +718,7 @@ impl RuntimeKeymap {move_line_end: resolve_local!(keymap, defaults, vim_normal, move_line_end),delete_char: resolve_local!(keymap, defaults, vim_normal, delete_char),replace_char: resolve_local!(keymap, defaults, vim_normal, replace_char),+ repeat_last_change: resolve_local!(keymap, defaults, vim_normal, repeat_last_change),substitute_char: resolve_local!(keymap, defaults, vim_normal, substitute_char),delete_to_line_end: resolve_local!(keymap, defaults, vim_normal, delete_to_line_end),change_to_line_end: resolve_local!(keymap, defaults, vim_normal, change_to_line_end),@@ -811,6 +813,10 @@ impl RuntimeKeymap {keymap.vim_normal.substitute_char.as_ref(),vim_normal.substitute_char.as_slice(),),+ (+ keymap.vim_normal.repeat_last_change.as_ref(),+ vim_normal.repeat_last_change.as_slice(),+ ),(keymap.vim_normal.change_to_line_end.as_ref(),vim_normal.change_to_line_end.as_slice(),@@ -864,6 +870,15 @@ impl RuntimeKeymap {})});}+ if keymap.vim_normal.repeat_last_change.is_none() {+ vim_normal.repeat_last_change.retain(|binding| {+ !configured_vim_normal_bindings_to_preserve.contains(binding)+ && !chords.bindings.iter().any(|chord| {+ chord.action.context == KeymapContext::VimNormal+ && chord.chord.prefix.parts() == binding.parts()+ })+ });+ }let mut vim_operator = VimOperatorKeymap {delete_line: resolve_local!(keymap, defaults, vim_operator, delete_line),@@ -1327,6 +1342,7 @@ impl RuntimeKeymap {],delete_char: default_bindings![plain(KeyCode::Char('x'))],replace_char: default_bindings![plain(KeyCode::Char('r'))],+ repeat_last_change: default_bindings![plain(KeyCode::Char('.'))],substitute_char: default_bindings![plain(KeyCode::Char('s'))],delete_to_line_end: default_bindings![shift(KeyCode::Char('d')),@@ -1861,6 +1877,10 @@ impl RuntimeKeymap {("move_line_end", self.vim_normal.move_line_end.as_slice()),("delete_char", self.vim_normal.delete_char.as_slice()),("replace_char", self.vim_normal.replace_char.as_slice()),+ (+ "repeat_last_change",+ self.vim_normal.repeat_last_change.as_slice(),+ ),("substitute_char",self.vim_normal.substitute_char.as_slice(),@@ -2958,6 +2978,30 @@ mod tests {expect_conflict(&keymap, "move_left", "replace_char");}+ #[test]+ fn configured_legacy_vim_normal_bindings_prune_new_repeat_default() {+ let mut keymap = TuiKeymap::default();+ keymap.vim_normal.move_left = Some(one("."));++ let runtime = RuntimeKeymap::from_config(&keymap).expect("config should parse");++ assert_eq!(runtime.vim_normal.repeat_last_change, Vec::new());+ }++ #[test]+ fn configured_vim_normal_chord_prefix_prunes_new_repeat_default() {+ let mut keymap = TuiKeymap::default();+ keymap.vim_normal.move_line_start = Some(one(". g"));++ let runtime = RuntimeKeymap::from_config(&keymap).expect("config should parse");++ assert!(runtime.vim_normal.repeat_last_change.is_empty());+ assert!(runtime.chords.bindings.iter().any(|binding| {+ binding.action.context == KeymapContext::VimNormal+ && binding.chord.prefix == key_hint::plain(KeyCode::Char('.'))+ }));+ }+#[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.rsindex 003af4dfb1..ab57dc0c89 100644--- a/codex-rs/tui/src/keymap/bindings.rs+++ b/codex-rs/tui/src/keymap/bindings.rs@@ -287,6 +287,7 @@ define_runtime_action_bindings! {move_line_end,delete_char,replace_char,+ repeat_last_change,substitute_char,delete_to_line_end,change_to_line_end,diff --git a/codex-rs/tui/src/keymap_setup.rs b/codex-rs/tui/src/keymap_setup.rsindex 70a0c29215..ed9ce919e9 100644--- a/codex-rs/tui/src/keymap_setup.rs+++ b/codex-rs/tui/src/keymap_setup.rs@@ -1099,6 +1099,24 @@ mod tests {);}+ #[test]+ fn picker_repeat_last_change_render_snapshot() {+ let runtime = RuntimeKeymap::defaults();+ let params = build_keymap_picker_params_for_selected_action(+ &runtime,+ &TuiKeymap::default(),+ "vim_normal",+ "repeat_last_change",+ );+ let rendered = render_picker(params, /*width*/ 120);+ let repeat_row = rendered+ .lines()+ .find(|line| line.contains("Repeat Last Change"))+ .expect("repeat-last-change row should render");++ assert_snapshot!("keymap_picker_repeat_last_change", repeat_row);+ }+#[test]fn picker_all_tab_items_remain_searchable() {let runtime = RuntimeKeymap::defaults();diff --git a/codex-rs/tui/src/keymap_setup/actions.rs b/codex-rs/tui/src/keymap_setup/actions.rsindex 707777e7bf..741a321348 100644--- a/codex-rs/tui/src/keymap_setup/actions.rs+++ b/codex-rs/tui/src/keymap_setup/actions.rs@@ -138,6 +138,7 @@ pub(super) const KEYMAP_ACTIONS: &[KeymapActionDescriptor] = &[action("vim_normal", "Vim normal", "move_line_end", "Move to the end of the line."),action("vim_normal", "Vim normal", "delete_char", "Delete the character under the cursor."),action("vim_normal", "Vim normal", "replace_char", "Replace the character under the cursor."),+ action("vim_normal", "Vim normal", "repeat_last_change", "Repeat the last complete edit."),action("vim_normal", "Vim normal", "substitute_char", "Delete the character under the cursor and enter insert mode."),action("vim_normal", "Vim normal", "delete_to_line_end", "Delete from cursor to end of line."),action("vim_normal", "Vim normal", "change_to_line_end", "Change from cursor to end of line and enter insert mode."),@@ -291,6 +292,7 @@ pub(super) fn binding_slot<'a>(("vim_normal", "move_line_end") => Some(&mut keymap.vim_normal.move_line_end),("vim_normal", "delete_char") => Some(&mut keymap.vim_normal.delete_char),("vim_normal", "replace_char") => Some(&mut keymap.vim_normal.replace_char),+ ("vim_normal", "repeat_last_change") => Some(&mut keymap.vim_normal.repeat_last_change),("vim_normal", "substitute_char") => Some(&mut keymap.vim_normal.substitute_char),("vim_normal", "delete_to_line_end") => Some(&mut keymap.vim_normal.delete_to_line_end),("vim_normal", "change_to_line_end") => Some(&mut keymap.vim_normal.change_to_line_end),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.snapindex 6719125553..bb447df146 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)"KeymapAll configurable shortcuts.- 118 actions, 1 customized, 4 unbound.+ 119 actions, 1 customized, 4 unbound.[All] Common Customized (1) Unbound (4) App Composer Editor Vim Navigation Agents Approval Debugdiff --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.snapindex 6f4db88d71..c9ee971bda 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)"KeymapAll configurable shortcuts.- 119 actions, 0 customized, 5 unbound.+ 120 actions, 0 customized, 5 unbound.[All] Common Customized (0) Unbound (5) App Composer Editor Vim Navigation Agents Approval Debugdiff --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.snapindex 04247dff62..56d5133a95 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.rsexpression: snapshot----tab: All (118 selectable)+tab: All (119 selectable)tab: Common (20 selectable)tab: Customized (0) (0 selectable)tab: Unbound (4) (4 selectable)tab: App (14 selectable)tab: Composer (5 selectable)tab: Editor (17 selectable)-tab: Vim (49 selectable)+tab: Vim (50 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.snapindex cc7cdd49cd..d09404301d 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)"KeymapAll configurable shortcuts.- 118 actions, 1 customized, 4 unbound.+ 119 actions, 1 customized, 4 unbound.[All] Common Customized (1) Unbound (4) App Composer Editor Vim Navigation Agents Approval Debugdiff --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.snapindex 20655b315d..43c77e183d 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)"KeymapAll configurable shortcuts.- 118 actions, 0 customized, 4 unbound.+ 119 actions, 0 customized, 4 unbound.[All] Common Customized (0) Unbound (4) App Composer Editor VimNavigation Agents Approval Debugdiff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_repeat_last_change.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_repeat_last_change.snapnew file mode 100644index 0000000000..21b7419bcb--- /dev/null+++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_repeat_last_change.snap@@ -0,0 +1,5 @@+---+source: tui/src/keymap_setup.rs+expression: repeat_row+---+› Vim normal Repeat Last Change .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.snapindex f1f656b82c..33eba8b0ee 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)"KeymapAll configurable shortcuts.- 118 actions, 0 customized, 4 unbound.+ 119 actions, 0 customized, 4 unbound.[All] Common Customized (0) Unbound (4) App Composer Editor Vim Navigation Agents Approval Debug