Lightweight coding agent that runs in your terminal
Rust
Add Vim character find and till motions (#40785)
Benjamin Carlsson98ee29c7cd3f
diff --git a/codex-rs/config/src/tui_keymap.rs b/codex-rs/config/src/tui_keymap.rsindex fbd2fba603..8e6f430b32 100644--- a/codex-rs/config/src/tui_keymap.rs+++ b/codex-rs/config/src/tui_keymap.rs@@ -235,6 +235,14 @@ pub struct TuiVimNormalKeymap {pub move_line_start: Option<KeybindingsSpec>,/// Move cursor to end of line (`$`).pub move_line_end: Option<KeybindingsSpec>,+ /// Find the next character on the current line (`f`).+ pub find_forward: Option<KeybindingsSpec>,+ /// Find the previous character on the current line (`F`).+ pub find_backward: Option<KeybindingsSpec>,+ /// Stop before the next character on the current line (`t`).+ pub till_forward: Option<KeybindingsSpec>,+ /// Stop after the previous character on the current line (`T`).+ pub till_backward: Option<KeybindingsSpec>,/// Delete character under cursor (`x`).pub delete_char: Option<KeybindingsSpec>,/// Replace the character under the cursor (`r`).@@ -292,6 +300,14 @@ pub struct TuiVimOperatorKeymap {pub motion_line_start: Option<KeybindingsSpec>,/// Motion: to end of line (`$`).pub motion_line_end: Option<KeybindingsSpec>,+ /// Motion: find the next character on the current line (`f`).+ pub motion_find_forward: Option<KeybindingsSpec>,+ /// Motion: find the previous character on the current line (`F`).+ pub motion_find_backward: Option<KeybindingsSpec>,+ /// Motion: stop before the next character on the current line (`t`).+ pub motion_till_forward: Option<KeybindingsSpec>,+ /// Motion: stop after the previous character on the current line (`T`).+ pub motion_till_backward: Option<KeybindingsSpec>,/// Select an inner text object after an operator.pub select_inner_text_object: Option<KeybindingsSpec>,/// Select an around text object after an operator.diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.jsonindex bc51420f1a..cc80ed561a 100644--- a/codex-rs/core/config.schema.json+++ b/codex-rs/core/config.schema.json@@ -3807,6 +3807,8 @@"delete_char": null,"delete_to_line_end": null,"enter_insert": null,+ "find_backward": null,+ "find_forward": null,"insert_line_start": null,"move_down": null,"move_left": null,@@ -3826,16 +3828,22 @@"start_delete_operator": null,"start_yank_operator": null,"substitute_char": null,+ "till_backward": null,+ "till_forward": null,"yank_line": null},"vim_operator": {"cancel": null,"delete_line": null,"motion_down": null,+ "motion_find_backward": null,+ "motion_find_forward": null,"motion_left": null,"motion_line_end": null,"motion_line_start": null,"motion_right": null,+ "motion_till_backward": null,+ "motion_till_forward": null,"motion_up": null,"motion_word_backward": null,"motion_word_end": null,@@ -4615,6 +4623,8 @@"delete_char": null,"delete_to_line_end": null,"enter_insert": null,+ "find_backward": null,+ "find_forward": null,"insert_line_start": null,"move_down": null,"move_left": null,@@ -4634,6 +4644,8 @@"start_delete_operator": null,"start_yank_operator": null,"substitute_char": null,+ "till_backward": null,+ "till_forward": null,"yank_line": null}},@@ -4647,10 +4659,14 @@"cancel": null,"delete_line": null,"motion_down": null,+ "motion_find_backward": null,+ "motion_find_forward": null,"motion_left": null,"motion_line_end": null,"motion_line_start": null,"motion_right": null,+ "motion_till_backward": null,+ "motion_till_forward": null,"motion_up": null,"motion_word_backward": null,"motion_word_end": null,@@ -4933,6 +4949,22 @@],"description": "Enter insert mode at cursor (`i`)."},+ "find_backward": {+ "allOf": [+ {+ "$ref": "#/definitions/KeybindingsSpec"+ }+ ],+ "description": "Find the previous character on the current line (`F`)."+ },+ "find_forward": {+ "allOf": [+ {+ "$ref": "#/definitions/KeybindingsSpec"+ }+ ],+ "description": "Find the next character on the current line (`f`)."+ },"insert_line_start": {"allOf": [{@@ -5085,6 +5117,22 @@],"description": "Delete character under cursor and enter insert mode (`s`)."},+ "till_backward": {+ "allOf": [+ {+ "$ref": "#/definitions/KeybindingsSpec"+ }+ ],+ "description": "Stop after the previous character on the current line (`T`)."+ },+ "till_forward": {+ "allOf": [+ {+ "$ref": "#/definitions/KeybindingsSpec"+ }+ ],+ "description": "Stop before the next character on the current line (`t`)."+ },"yank_line": {"allOf": [{@@ -5124,6 +5172,22 @@],"description": "Motion: down one line (`j`)."},+ "motion_find_backward": {+ "allOf": [+ {+ "$ref": "#/definitions/KeybindingsSpec"+ }+ ],+ "description": "Motion: find the previous character on the current line (`F`)."+ },+ "motion_find_forward": {+ "allOf": [+ {+ "$ref": "#/definitions/KeybindingsSpec"+ }+ ],+ "description": "Motion: find the next character on the current line (`f`)."+ },"motion_left": {"allOf": [{@@ -5156,6 +5220,22 @@],"description": "Motion: right (`l`)."},+ "motion_till_backward": {+ "allOf": [+ {+ "$ref": "#/definitions/KeybindingsSpec"+ }+ ],+ "description": "Motion: stop after the previous character on the current line (`T`)."+ },+ "motion_till_forward": {+ "allOf": [+ {+ "$ref": "#/definitions/KeybindingsSpec"+ }+ ],+ "description": "Motion: stop before the next character on the current line (`t`)."+ },"motion_up": {"allOf": [{diff --git a/codex-rs/tui/src/bottom_pane/textarea.rs b/codex-rs/tui/src/bottom_pane/textarea.rsindex 3749001040..aaebb46889 100644--- a/codex-rs/tui/src/bottom_pane/textarea.rs+++ b/codex-rs/tui/src/bottom_pane/textarea.rs@@ -311,7 +311,7 @@ impl TextArea {}match self.vim_pending {VimPending::None => KeymapContext::VimNormal,- VimPending::Replace => KeymapContext::Editor,+ VimPending::Replace | VimPending::Find { .. } => KeymapContext::Editor,VimPending::Operator(_) => KeymapContext::VimOperator,VimPending::TextObject { .. } => KeymapContext::VimTextObject,}@@ -718,7 +718,7 @@ impl TextArea {self.handle_vim_text_object(operator, scope, event);return;}- VimPending::Replace => {+ VimPending::Replace | VimPending::Find { .. } => {self.handle_vim_pending_command(pending, event);return;}@@ -876,7 +876,7 @@ impl TextArea {self.start_vim_edit(VimAction::Change(VimEditTarget::Line));return true;}- false+ self.handle_vim_operator_command(op, event)}fn handle_vim_text_object(diff --git a/codex-rs/tui/src/bottom_pane/textarea/vim.rs b/codex-rs/tui/src/bottom_pane/textarea/vim.rsindex 50b24ebc8a..8573831398 100644--- a/codex-rs/tui/src/bottom_pane/textarea/vim.rs+++ b/codex-rs/tui/src/bottom_pane/textarea/vim.rs@@ -28,6 +28,19 @@ pub(super) enum VimPending {scope: VimTextObjectScope,},Replace,+ Find {+ motion: VimFindMotion,+ operator: Option<VimOperator>,+ },+}++/// Line-local character motions shared by navigation, operators, and dot replay.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub(super) enum VimFindMotion {+ Forward,+ Backward,+ TillForward,+ TillBackward,}#[derive(Debug, Clone, Copy, PartialEq, Eq)]diff --git a/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs b/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rsindex 1cee3b7b3b..284933e096 100644--- a/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs+++ b/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs@@ -1,4 +1,8 @@-//! Semantic Vim editing transactions and complete-change replay.+//! Semantic Vim editing transactions, character find/till motions, and complete-change replay.+//!+//! `f`/`F` land on a matching grapheme; `t`/`T` stop just before/after it. Forward operator+//! motions include the destination, while backward motions exclude the original cursor.+//! All four motions share these boundaries for navigation, `c`/`d`/`y`, and semantic `.` replay.use super::TextArea;use super::VimMode;@@ -7,10 +11,13 @@ use super::VimOperator;use super::VimPending;use super::VimTextObject;use super::VimTextObjectScope;+use super::vim::VimFindMotion;use crate::key_hint::KeyBindingListExt;use crossterm::event::KeyCode;use crossterm::event::KeyEvent;use crossterm::event::KeyModifiers;+use unicode_segmentation::GraphemeCursor;+use unicode_segmentation::UnicodeSegmentation;#[derive(Clone, Debug)]pub(crate) enum VimEdit {@@ -41,6 +48,10 @@ pub(super) enum VimEditTarget {scope: VimTextObjectScope,object: VimTextObject,},+ Find {+ motion: VimFindMotion,+ target: char,+ },}#[derive(Clone, Copy, Debug)]@@ -246,6 +257,11 @@ impl TextArea {};self.apply_vim_operator_to_range(operator, range);}+ VimEditTarget::Find { motion, target } => {+ if !self.find_vim_character(motion, Some(operator), target) {+ return false;+ }+ }}if operator == VimOperator::Change {return self.vim_mode == VimMode::Insert;@@ -306,7 +322,53 @@ impl TextArea {}return true;}- false+ if self.vim_normal_keymap.find_forward.is_pressed(event) {+ self.start_vim_find(VimFindMotion::Forward, /*operator*/ None);+ } else if self.vim_normal_keymap.find_backward.is_pressed(event) {+ self.start_vim_find(VimFindMotion::Backward, /*operator*/ None);+ } else if self.vim_normal_keymap.till_forward.is_pressed(event) {+ self.start_vim_find(VimFindMotion::TillForward, /*operator*/ None);+ } else if self.vim_normal_keymap.till_backward.is_pressed(event) {+ self.start_vim_find(VimFindMotion::TillBackward, /*operator*/ None);+ } else {+ return false;+ }+ true+ }++ pub(super) fn handle_vim_operator_command(+ &mut self,+ operator: VimOperator,+ event: KeyEvent,+ ) -> bool {+ if self+ .vim_operator_keymap+ .motion_find_forward+ .is_pressed(event)+ {+ self.start_vim_find(VimFindMotion::Forward, Some(operator));+ } else if self+ .vim_operator_keymap+ .motion_find_backward+ .is_pressed(event)+ {+ self.start_vim_find(VimFindMotion::Backward, Some(operator));+ } else if self+ .vim_operator_keymap+ .motion_till_forward+ .is_pressed(event)+ {+ self.start_vim_find(VimFindMotion::TillForward, Some(operator));+ } else if self+ .vim_operator_keymap+ .motion_till_backward+ .is_pressed(event)+ {+ self.start_vim_find(VimFindMotion::TillBackward, Some(operator));+ } else {+ return false;+ }+ true}pub(super) fn handle_vim_pending_command(&mut self, pending: VimPending, event: KeyEvent) {@@ -316,9 +378,112 @@ impl TextArea {self.start_vim_edit(VimAction::Replace(ch));}}+ VimPending::Find { motion, operator } => {+ if let Some(ch) = vim_command_char(event) {+ match operator {+ Some(VimOperator::Delete) => {+ self.start_vim_edit(VimAction::Delete(VimEditTarget::Find {+ motion,+ target: ch,+ }));+ }+ Some(VimOperator::Change) => {+ self.start_vim_edit(VimAction::Change(VimEditTarget::Find {+ motion,+ target: ch,+ }));+ }+ Some(VimOperator::Yank) | None => {+ self.find_vim_character(motion, operator, ch);+ }+ }+ }+ }VimPending::None | VimPending::Operator(_) | VimPending::TextObject { .. } => {}}}++ fn start_vim_find(&mut self, motion: VimFindMotion, operator: Option<VimOperator>) {+ self.vim_pending = VimPending::Find { motion, operator };+ }++ fn find_vim_character(+ &mut self,+ motion: VimFindMotion,+ operator: Option<VimOperator>,+ target: char,+ ) -> bool {+ let origin = self.cursor_pos;+ let found = match motion {+ VimFindMotion::Forward | VimFindMotion::TillForward => {+ let line_end = self.end_of_current_line();+ if origin >= line_end {+ return false;+ }+ let start = self.next_atomic_boundary(origin);+ self.text[start..line_end]+ .grapheme_indices(/*is_extended*/ true)+ .find(|(offset, grapheme)| {+ grapheme.starts_with(target) && self.is_vim_command_target(start + offset)+ })+ .map(|(offset, grapheme)| start + offset..start + offset + grapheme.len())+ }+ VimFindMotion::Backward | VimFindMotion::TillBackward => {+ let line_start = self.beginning_of_current_line();+ self.text[line_start..origin]+ .grapheme_indices(/*is_extended*/ true)+ .rev()+ .find(|(offset, grapheme)| {+ grapheme.starts_with(target)+ && self.is_vim_command_target(line_start + offset)+ })+ .map(|(offset, grapheme)| {+ let start = line_start + offset;+ start..start + grapheme.len()+ })+ }+ };+ let Some(position) = found else {+ return false;+ };+ if let Some(operator) = operator {+ let range = match motion {+ VimFindMotion::Forward => origin..position.end,+ VimFindMotion::Backward => position.start..origin,+ VimFindMotion::TillForward => origin..position.start,+ VimFindMotion::TillBackward => position.end..origin,+ };+ if operator == VimOperator::Yank {+ self.set_cursor(range.start);+ }+ self.apply_vim_operator_to_range(operator, range);+ } else {+ let destination = match motion {+ VimFindMotion::Forward | VimFindMotion::Backward => position.start,+ VimFindMotion::TillForward => {+ let previous = self.text[..position.start]+ .grapheme_indices(/*is_extended*/ true)+ .next_back()+ .map_or(origin, |(offset, _)| offset);+ self.find_element_containing(previous)+ .map_or(previous, |idx| self.elements[idx].range.start)+ }+ VimFindMotion::TillBackward => position.end,+ };+ self.set_cursor(destination);+ }+ true+ }++ fn is_vim_command_target(&self, position: usize) -> bool {+ !self+ .elements+ .iter()+ .any(|element| element.range.contains(&position))+ && GraphemeCursor::new(position, self.text.len(), /*is_extended*/ true)+ .is_boundary(&self.text, /*chunk_start*/ 0)+ .unwrap_or(false)+ }}fn vim_command_char(event: KeyEvent) -> Option<char> {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 512cbd7aa9..868a0127df 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@@ -300,6 +300,186 @@ fn change_accepts_word_line_and_repeated_operator_motions() {assert_eq!(textarea.text(), " world");}+#[test]+fn character_find_is_line_local_and_works_as_operator_motion() {+ let mut textarea = vim_textarea("alpha beta\nbeta", /*cursor*/ 0);+ keys(&mut textarea, "fb");+ assert_eq!(textarea.cursor(), "alpha ".len());+ keys(&mut textarea, "Fa");+ assert_eq!(textarea.cursor(), "alpha".len() - 1);+ keys(&mut textarea, "fz");+ assert_eq!(textarea.cursor(), "alpha".len() - 1);++ for (motion, cursor, destination, range) in [+ ("fr", 0, 3, 0..4),+ ("tr", 0, 2, 0..3),+ ("Fb", 3, 1, 1..3),+ ("Tb", 3, 2, 2..3),+ ] {+ let text = "abcrdef";+ let mut textarea = vim_textarea(text, cursor);+ keys(&mut textarea, motion);+ assert_eq!((textarea.text(), textarea.cursor()), (text, destination));+ for operator in ['c', 'd', 'y'] {+ let mut textarea = vim_textarea(text, cursor);+ keys(&mut textarea, &format!("{operator}{motion}"));+ let expected = if operator == 'y' {+ text.to_owned()+ } else {+ format!("{}{}", &text[..range.start], &text[range.end..])+ };+ let mode = if operator == 'c' { "Insert" } else { "Normal" };+ assert_eq!(+ (+ textarea.text(),+ textarea.cursor(),+ textarea.vim_mode_label(),+ textarea.kill_buffer.as_str()+ ),+ (+ expected.as_str(),+ range.start,+ Some(mode),+ &text[range.clone()]+ ),+ "{operator}{motion}",+ );+ }+ }++ let mut textarea = vim_textarea("\nabc", /*cursor*/ 0);+ keys(&mut textarea, "fx");+ assert_eq!(textarea.text(), "\nabc");+ assert_eq!(textarea.cursor(), 0);+}++#[test]+fn find_and_till_handle_missing_cancelled_and_adjacent_targets() {+ for motion in ['f', 'F', 't', 'T'] {+ for operator in ["", "c", "d", "y"] {+ let mut textarea = vim_textarea("abc\nz", /*cursor*/ 1);+ keys(&mut textarea, &format!("{operator}{motion}z"));+ assert_eq!(+ (+ textarea.text(),+ textarea.cursor(),+ textarea.vim_mode_label()+ ),+ ("abc\nz", 1, Some("Normal"))+ );+ keys(&mut textarea, &format!("{operator}{motion}"));+ escape(&mut textarea);+ assert!(!textarea.is_vim_operator_pending());+ }+ }+ for (cursor, command, expected) in [(0, "ctb", "bc"), (2, "cTb", "abc")] {+ let mut textarea = vim_textarea("abc", cursor);+ keys(&mut textarea, command);+ assert_eq!(+ (textarea.text(), textarea.vim_mode_label()),+ (expected, Some("Insert"))+ );+ }+}++#[test]+fn dot_repeat_replays_character_find_operators() {+ let mut textarea = vim_textarea("one:two:three", /*cursor*/ 0);+ keys(&mut textarea, "df:.");+ assert_eq!(textarea.text(), "three");++ for (cursor, command, repeat, expected) in [+ (0, "cfrX", "w.", "X X"),+ (0, "ctrX", "w.", "Xr Xr"),+ (3, "cFbX", concat!("w", "lll."), "aXr aXr"),+ (3, "cTbX", concat!("w", "lll."), "abXr abXr"),+ ] {+ let mut textarea = vim_textarea("abcr abcr", cursor);+ keys(&mut textarea, command);+ escape(&mut textarea);+ keys(&mut textarea, repeat);+ assert_eq!(+ (textarea.text(), textarea.vim_mode_label()),+ (expected, Some("Normal"))+ );+ }+}++#[test]+fn character_find_never_splits_extended_graphemes() {+ let mut textarea = vim_textarea("a👩💻z", /*cursor*/ 0);+ keys(&mut textarea, "f💻");+ assert_eq!(textarea.cursor(), 0);+ keys(&mut textarea, "f👩rX");+ assert_eq!(textarea.text(), "aXz");+ for (text, command, expected, cursor) in [+ ("a👩💻r", "tr", "a👩💻r", 1),+ ("aहिr", "tr", "aहिr", 1),+ ("aहिr", "dfह", "r", 0),+ ] {+ let mut textarea = vim_textarea(text, /*cursor*/ 0);+ keys(&mut textarea, command);+ assert_eq!((textarea.text(), textarea.cursor()), (expected, cursor));+ }+ let mut textarea = vim_textarea("a", /*cursor*/ 0);+ textarea.set_cursor(/*pos*/ 1);+ textarea.insert_element("[image]");+ textarea.insert_str("r");+ textarea.set_cursor(/*pos*/ 0);+ keys(&mut textarea, "t]");+ assert_eq!(textarea.cursor(), 0);+ keys(&mut textarea, "tr");+ assert_eq!(textarea.cursor(), 1);+ textarea.set_cursor(/*pos*/ 0);+ keys(&mut textarea, "ctr");+ assert_eq!((textarea.text(), textarea.elements.len()), ("r", 0));++ let prefix = "earlier line\na";+ for (command, cursor) in [("Fa", prefix.len() - 1), ("Ta", prefix.len())] {+ let mut textarea = vim_textarea(prefix, /*cursor*/ 0);+ textarea.set_cursor(prefix.len());+ textarea.insert_element("[aaaa]");+ textarea.insert_str("z");+ textarea.set_cursor(textarea.text().len() - 1);+ keys(&mut textarea, command);+ assert_eq!(+ (textarea.text(), textarea.cursor()),+ ("earlier line\na[aaaa]z", cursor)+ );+ }+}++#[test]+fn character_find_and_operator_motion_use_configured_bindings() {+ let mut keymap = crate::keymap::RuntimeKeymap::defaults();+ keymap.vim_normal.find_forward = vec![crate::key_hint::plain(KeyCode::Char('z'))];+ keymap.vim_operator.motion_find_forward = vec![crate::key_hint::plain(KeyCode::Char('z'))];+ keymap.vim_normal.till_forward = vec![crate::key_hint::plain(KeyCode::Char('q'))];+ keymap.vim_operator.motion_till_forward = vec![crate::key_hint::plain(KeyCode::Char('q'))];+ for (motion, cursor, expected) in [("zb", 6, "eta gamma"), ("qb", 5, "beta gamma")] {+ let mut textarea = vim_textarea("alpha beta gamma", /*cursor*/ 0);+ textarea.set_keymap_bindings(&keymap);+ keys(&mut textarea, motion);+ assert_eq!(textarea.cursor(), cursor);+ textarea.set_cursor(/*pos*/ 0);+ keys(&mut textarea, &format!("d{motion}"));+ assert_eq!(textarea.text(), expected);+ }+}++#[test]+fn uppercase_commands_accept_shift_only_terminal_events() {+ let mut textarea = vim_textarea("alpha\nbeta", /*cursor*/ 0);+ textarea.set_cursor("alpha\nbe".len());+ textarea.input(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::SHIFT));+ keys(&mut textarea, "b");+ assert_eq!(textarea.cursor(), "alpha\n".len());+ textarea.set_cursor("alpha\nbe".len());+ textarea.input(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::SHIFT));+ keys(&mut textarea, "b");+ assert_eq!(textarea.cursor(), "alpha\nb".len());+}+#[test]fn pending_replacement_owns_escape_before_turn_interruption() {let mut textarea = vim_textarea("alpha", /*cursor*/ 0);@@ -354,3 +534,31 @@ fn dot_repeat_has_visual_snapshot_coverage() {^"###);}++#[test]+fn find_and_navigation_have_visual_snapshot_coverage() {+ let mut textarea = vim_textarea("alpha beta\ngamma delta", /*cursor*/ 0);+ let mut states = Vec::new();+ for command in ["tb", "fb", "Ta", "Fa"] {+ 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###"+ tb: alpha beta\ngamma delta+ ^++ fb: alpha beta\ngamma delta+ ^++ Ta: alpha beta\ngamma delta+ ^++ Fa: alpha beta\ngamma delta+ ^++ "###);+}diff --git a/codex-rs/tui/src/keymap.rs b/codex-rs/tui/src/keymap.rsindex 6c7edf7e3e..25da976a15 100644--- a/codex-rs/tui/src/keymap.rs+++ b/codex-rs/tui/src/keymap.rs@@ -186,6 +186,10 @@ pub(crate) struct VimNormalKeymap {pub(crate) move_word_end: Vec<KeyBinding>,pub(crate) move_line_start: Vec<KeyBinding>,pub(crate) move_line_end: Vec<KeyBinding>,+ pub(crate) find_forward: Vec<KeyBinding>,+ pub(crate) find_backward: Vec<KeyBinding>,+ pub(crate) till_forward: Vec<KeyBinding>,+ pub(crate) till_backward: Vec<KeyBinding>,pub(crate) delete_char: Vec<KeyBinding>,pub(crate) replace_char: Vec<KeyBinding>,pub(crate) repeat_last_change: Vec<KeyBinding>,@@ -219,6 +223,10 @@ pub(crate) struct VimOperatorKeymap {pub(crate) motion_word_end: Vec<KeyBinding>,pub(crate) motion_line_start: Vec<KeyBinding>,pub(crate) motion_line_end: Vec<KeyBinding>,+ pub(crate) motion_find_forward: Vec<KeyBinding>,+ pub(crate) motion_find_backward: Vec<KeyBinding>,+ pub(crate) motion_till_forward: Vec<KeyBinding>,+ pub(crate) motion_till_backward: Vec<KeyBinding>,pub(crate) select_inner_text_object: Vec<KeyBinding>,pub(crate) select_around_text_object: Vec<KeyBinding>,pub(crate) cancel: Vec<KeyBinding>,@@ -716,6 +724,10 @@ impl RuntimeKeymap {move_word_end: resolve_local!(keymap, defaults, vim_normal, move_word_end),move_line_start: resolve_local!(keymap, defaults, vim_normal, move_line_start),move_line_end: resolve_local!(keymap, defaults, vim_normal, move_line_end),+ find_forward: resolve_local!(keymap, defaults, vim_normal, find_forward),+ find_backward: resolve_local!(keymap, defaults, vim_normal, find_backward),+ till_forward: resolve_local!(keymap, defaults, vim_normal, till_forward),+ till_backward: resolve_local!(keymap, defaults, vim_normal, till_backward),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),@@ -801,6 +813,22 @@ impl RuntimeKeymap {keymap.vim_normal.move_line_end.as_ref(),vim_normal.move_line_end.as_slice(),),+ (+ keymap.vim_normal.find_forward.as_ref(),+ vim_normal.find_forward.as_slice(),+ ),+ (+ keymap.vim_normal.find_backward.as_ref(),+ vim_normal.find_backward.as_slice(),+ ),+ (+ keymap.vim_normal.till_forward.as_ref(),+ vim_normal.till_forward.as_slice(),+ ),+ (+ keymap.vim_normal.till_backward.as_ref(),+ vim_normal.till_backward.as_slice(),+ ),(keymap.vim_normal.delete_char.as_ref(),vim_normal.delete_char.as_slice(),@@ -879,6 +907,34 @@ impl RuntimeKeymap {})});}+ for (configured, bindings) in [+ (+ keymap.vim_normal.find_forward.as_ref(),+ &mut vim_normal.find_forward,+ ),+ (+ keymap.vim_normal.find_backward.as_ref(),+ &mut vim_normal.find_backward,+ ),+ (+ keymap.vim_normal.till_forward.as_ref(),+ &mut vim_normal.till_forward,+ ),+ (+ keymap.vim_normal.till_backward.as_ref(),+ &mut vim_normal.till_backward,+ ),+ ] {+ if configured.is_none() {+ bindings.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),@@ -902,6 +958,30 @@ impl RuntimeKeymap {motion_word_end: resolve_local!(keymap, defaults, vim_operator, motion_word_end),motion_line_start: resolve_local!(keymap, defaults, vim_operator, motion_line_start),motion_line_end: resolve_local!(keymap, defaults, vim_operator, motion_line_end),+ motion_find_forward: resolve_local!(+ keymap,+ defaults,+ vim_operator,+ motion_find_forward+ ),+ motion_find_backward: resolve_local!(+ keymap,+ defaults,+ vim_operator,+ motion_find_backward+ ),+ motion_till_forward: resolve_local!(+ keymap,+ defaults,+ vim_operator,+ motion_till_forward+ ),+ motion_till_backward: resolve_local!(+ keymap,+ defaults,+ vim_operator,+ motion_till_backward+ ),select_inner_text_object: resolve_local!(keymap,defaults,@@ -962,6 +1042,22 @@ impl RuntimeKeymap {keymap.vim_operator.motion_line_end.as_ref(),vim_operator.motion_line_end.as_slice(),),+ (+ keymap.vim_operator.motion_find_forward.as_ref(),+ vim_operator.motion_find_forward.as_slice(),+ ),+ (+ keymap.vim_operator.motion_find_backward.as_ref(),+ vim_operator.motion_find_backward.as_slice(),+ ),+ (+ keymap.vim_operator.motion_till_forward.as_ref(),+ vim_operator.motion_till_forward.as_slice(),+ ),+ (+ keymap.vim_operator.motion_till_backward.as_ref(),+ vim_operator.motion_till_backward.as_slice(),+ ),(keymap.vim_operator.cancel.as_ref(),vim_operator.cancel.as_slice(),@@ -978,6 +1074,34 @@ impl RuntimeKeymap {.select_around_text_object.retain(|binding| !configured_vim_operator_bindings_to_preserve.contains(binding));}+ for (configured, bindings) in [+ (+ keymap.vim_operator.motion_find_forward.as_ref(),+ &mut vim_operator.motion_find_forward,+ ),+ (+ keymap.vim_operator.motion_find_backward.as_ref(),+ &mut vim_operator.motion_find_backward,+ ),+ (+ keymap.vim_operator.motion_till_forward.as_ref(),+ &mut vim_operator.motion_till_forward,+ ),+ (+ keymap.vim_operator.motion_till_backward.as_ref(),+ &mut vim_operator.motion_till_backward,+ ),+ ] {+ if configured.is_none() {+ bindings.retain(|binding| {+ !configured_vim_operator_bindings_to_preserve.contains(binding)+ && !chords.bindings.iter().any(|chord| {+ chord.action.context == KeymapContext::VimOperator+ && chord.chord.prefix.parts() == binding.parts()+ })+ });+ }+ }let vim_text_object = VimTextObjectKeymap {word: resolve_local!(keymap, defaults, vim_text_object, word),@@ -1340,6 +1464,10 @@ impl RuntimeKeymap {plain(KeyCode::Char('$')),shift(KeyCode::Char('$'))],+ find_forward: default_bindings![plain(KeyCode::Char('f'))],+ find_backward: default_bindings![shift(KeyCode::Char('f'))],+ till_forward: default_bindings![plain(KeyCode::Char('t'))],+ till_backward: default_bindings![shift(KeyCode::Char('t'))],delete_char: default_bindings![plain(KeyCode::Char('x'))],replace_char: default_bindings![plain(KeyCode::Char('r'))],repeat_last_change: default_bindings![plain(KeyCode::Char('.'))],@@ -1374,6 +1502,10 @@ impl RuntimeKeymap {plain(KeyCode::Char('$')),shift(KeyCode::Char('$'))],+ motion_find_forward: default_bindings![plain(KeyCode::Char('f'))],+ motion_find_backward: default_bindings![shift(KeyCode::Char('f'))],+ motion_till_forward: default_bindings![plain(KeyCode::Char('t'))],+ motion_till_backward: default_bindings![shift(KeyCode::Char('t'))],select_inner_text_object: default_bindings![plain(KeyCode::Char('i'))],select_around_text_object: default_bindings![plain(KeyCode::Char('a'))],cancel: default_bindings![plain(KeyCode::Esc)],@@ -1875,6 +2007,10 @@ impl RuntimeKeymap {self.vim_normal.move_line_start.as_slice(),),("move_line_end", self.vim_normal.move_line_end.as_slice()),+ ("find_forward", self.vim_normal.find_forward.as_slice()),+ ("find_backward", self.vim_normal.find_backward.as_slice()),+ ("till_forward", self.vim_normal.till_forward.as_slice()),+ ("till_backward", self.vim_normal.till_backward.as_slice()),("delete_char", self.vim_normal.delete_char.as_slice()),("replace_char", self.vim_normal.replace_char.as_slice()),(@@ -1943,6 +2079,22 @@ impl RuntimeKeymap {"motion_line_end",self.vim_operator.motion_line_end.as_slice(),),+ (+ "motion_find_forward",+ self.vim_operator.motion_find_forward.as_slice(),+ ),+ (+ "motion_find_backward",+ self.vim_operator.motion_find_backward.as_slice(),+ ),+ (+ "motion_till_forward",+ self.vim_operator.motion_till_forward.as_slice(),+ ),+ (+ "motion_till_backward",+ self.vim_operator.motion_till_backward.as_slice(),+ ),("select_inner_text_object",self.vim_operator.select_inner_text_object.as_slice(),@@ -2988,6 +3140,38 @@ mod tests {assert_eq!(runtime.vim_normal.repeat_last_change, Vec::new());}+ #[test]+ fn configured_legacy_vim_bindings_prune_new_navigation_defaults() {+ let mut keymap = TuiKeymap::default();+ keymap.vim_normal.move_left = Some(one("f"));+ keymap.vim_normal.move_right = Some(one("t"));+ keymap.vim_normal.move_up = Some(one("shift-f"));+ keymap.vim_operator.motion_right = Some(one("shift-t"));++ let runtime = RuntimeKeymap::from_config(&keymap).expect("config should parse");++ assert_eq!(runtime.vim_normal.find_forward, Vec::new());+ assert_eq!(runtime.vim_normal.find_backward, Vec::new());+ assert_eq!(runtime.vim_normal.till_forward, Vec::new());+ assert_eq!(runtime.vim_operator.motion_till_backward, Vec::new());+ }++ #[test]+ fn explicit_vim_navigation_binding_still_conflicts_with_legacy_binding() {+ for key in ["f", "t"] {+ let mut keymap = TuiKeymap::default();+ keymap.vim_normal.move_left = Some(one(key));+ let action = if key == "f" {+ keymap.vim_normal.find_forward = Some(one(key));+ "find_forward"+ } else {+ keymap.vim_normal.till_forward = Some(one(key));+ "till_forward"+ };+ expect_conflict(&keymap, "move_left", action);+ }+ }+#[test]fn configured_vim_normal_chord_prefix_prunes_new_repeat_default() {let mut keymap = TuiKeymap::default();diff --git a/codex-rs/tui/src/keymap/bindings.rs b/codex-rs/tui/src/keymap/bindings.rsindex ab57dc0c89..91796d2e5d 100644--- a/codex-rs/tui/src/keymap/bindings.rs+++ b/codex-rs/tui/src/keymap/bindings.rs@@ -285,6 +285,10 @@ define_runtime_action_bindings! {move_word_end,move_line_start,move_line_end,+ find_forward,+ find_backward,+ till_forward,+ till_backward,delete_char,replace_char,repeat_last_change,@@ -310,6 +314,10 @@ define_runtime_action_bindings! {motion_word_end,motion_line_start,motion_line_end,+ motion_find_forward,+ motion_find_backward,+ motion_till_forward,+ motion_till_backward,select_inner_text_object,select_around_text_object,cancel,diff --git a/codex-rs/tui/src/keymap/chords.rs b/codex-rs/tui/src/keymap/chords.rsindex 35e4105dd9..61749ac6d2 100644--- a/codex-rs/tui/src/keymap/chords.rs+++ b/codex-rs/tui/src/keymap/chords.rs@@ -25,7 +25,7 @@ use crossterm::event::KeyModifiers;use std::time::Duration;use tokio::time::Instant;-const FIRST_DISPATCH_FUNCTION_KEY: u8 = 128;+const FIRST_DISPATCH_FUNCTION_KEY: u8 = codex_config::types::MAX_FUNCTION_KEY + 1;const LAST_DISPATCH_FUNCTION_KEY: u8 = u8::MAX;const LIST_RESERVED_BINDINGS: &[(&str, KeyBinding)] = &[("cancel", ctrl(KeyCode::Char('c'))),diff --git a/codex-rs/tui/src/keymap_setup/actions.rs b/codex-rs/tui/src/keymap_setup/actions.rsindex 741a321348..b4adbc3c52 100644--- a/codex-rs/tui/src/keymap_setup/actions.rs+++ b/codex-rs/tui/src/keymap_setup/actions.rs@@ -136,6 +136,10 @@ pub(super) const KEYMAP_ACTIONS: &[KeymapActionDescriptor] = &[action("vim_normal", "Vim normal", "move_word_end", "Move to the end of the current or next word."),action("vim_normal", "Vim normal", "move_line_start", "Move to the start of the line."),action("vim_normal", "Vim normal", "move_line_end", "Move to the end of the line."),+ action("vim_normal", "Vim normal", "find_forward", "Find the next character on the current line."),+ action("vim_normal", "Vim normal", "find_backward", "Find the previous character on the current line."),+ action("vim_normal", "Vim normal", "till_forward", "Stop before the next character on the current line."),+ action("vim_normal", "Vim normal", "till_backward", "Stop after the previous character on the current 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."),@@ -159,6 +163,10 @@ pub(super) const KEYMAP_ACTIONS: &[KeymapActionDescriptor] = &[action("vim_operator", "Vim operator", "motion_word_end", "Operator motion to end of word."),action("vim_operator", "Vim operator", "motion_line_start", "Operator motion to line start."),action("vim_operator", "Vim operator", "motion_line_end", "Operator motion to line end."),+ action("vim_operator", "Vim operator", "motion_find_forward", "Operator motion to the next character on the current line."),+ action("vim_operator", "Vim operator", "motion_find_backward", "Operator motion to the previous character on the current line."),+ action("vim_operator", "Vim operator", "motion_till_forward", "Stop before the next character on the current line."),+ action("vim_operator", "Vim operator", "motion_till_backward", "Stop after the previous character on the current line."),action("vim_operator", "Vim operator", "select_inner_text_object", "Select an inner text object."),action("vim_operator", "Vim operator", "select_around_text_object", "Select an around text object."),action("vim_operator", "Vim operator", "cancel", "Cancel the pending operator."),@@ -290,6 +298,10 @@ pub(super) fn binding_slot<'a>(("vim_normal", "move_word_end") => Some(&mut keymap.vim_normal.move_word_end),("vim_normal", "move_line_start") => Some(&mut keymap.vim_normal.move_line_start),("vim_normal", "move_line_end") => Some(&mut keymap.vim_normal.move_line_end),+ ("vim_normal", "find_forward") => Some(&mut keymap.vim_normal.find_forward),+ ("vim_normal", "find_backward") => Some(&mut keymap.vim_normal.find_backward),+ ("vim_normal", "till_forward") => Some(&mut keymap.vim_normal.till_forward),+ ("vim_normal", "till_backward") => Some(&mut keymap.vim_normal.till_backward),("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),@@ -313,6 +325,10 @@ pub(super) fn binding_slot<'a>(("vim_operator", "motion_word_end") => Some(&mut keymap.vim_operator.motion_word_end),("vim_operator", "motion_line_start") => Some(&mut keymap.vim_operator.motion_line_start),("vim_operator", "motion_line_end") => Some(&mut keymap.vim_operator.motion_line_end),+ ("vim_operator", "motion_find_forward") => Some(&mut keymap.vim_operator.motion_find_forward),+ ("vim_operator", "motion_find_backward") => Some(&mut keymap.vim_operator.motion_find_backward),+ ("vim_operator", "motion_till_forward") => Some(&mut keymap.vim_operator.motion_till_forward),+ ("vim_operator", "motion_till_backward") => Some(&mut keymap.vim_operator.motion_till_backward),("vim_operator", "select_inner_text_object") => Some(&mut keymap.vim_operator.select_inner_text_object),("vim_operator", "select_around_text_object") => Some(&mut keymap.vim_operator.select_around_text_object),("vim_operator", "cancel") => Some(&mut keymap.vim_operator.cancel),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 bb447df146..fbc49b6b84 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.- 119 actions, 1 customized, 4 unbound.+ 127 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 c9ee971bda..b04c78abd4 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.- 120 actions, 0 customized, 5 unbound.+ 128 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 56d5133a95..a63f05b418 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 (119 selectable)+tab: All (127 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 (50 selectable)+tab: Vim (58 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 d09404301d..9ef42945c9 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.- 119 actions, 1 customized, 4 unbound.+ 127 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 43c77e183d..0f060d2baa 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.- 119 actions, 0 customized, 4 unbound.+ 127 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_wide.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_wide.snapindex 33eba8b0ee..127df665a2 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.- 119 actions, 0 customized, 4 unbound.+ 127 actions, 0 customized, 4 unbound.[All] Common Customized (0) Unbound (4) App Composer Editor Vim Navigation Agents Approval Debug