feat(tui): support counted main-page movement

- add scoped numeric prefixes for repeated vertical movement on the main page in default/custom and vim keymaps
- clear pending counts when focus changes or modal surfaces take over so prefixes do not leak across interactions
- document the count shortcuts and add TUI regression coverage for counted moves and scope resets

Signed-off-by: Chao Liu <chao.liu.zevorn@gmail.com>

Author: zevorn

README-zh.md

@@ -198,6 +198,7 @@ criew tui
 
 - `:` 打开命令栏
 - 顶部状态栏会显示当前 keymap 方案：`default`、`vim` 或 `custom`
+- 数字前缀可重复垂直移动：`default/custom` 使用 `数字 + i/k`，`vim` 使用 `数字 + j/k`
 - `y` / `n` 启用或禁用当前订阅
 - `Enter` 打开当前 mailbox 或 thread，并自动切到 threads 或 preview pane
 - `a` apply 当前 patch series

README.md

@@ -211,6 +211,7 @@ Inside the TUI:
 
 - `:` opens the command palette
 - the header shows the active keymap scheme (`default`, `vim`, or `custom`)
+- a numeric prefix repeats vertical movement: `count+i/k` for `default`/`custom`, `count+j/k` for `vim`
 - `y` / `n` enable or disable the selected subscription
 - `Enter` opens the selected mailbox or thread and moves focus to threads or preview
 - `a` applies the current patch series

src/ui/tui.rs

@@ -231,7 +231,7 @@ const CONFIG_EDITOR_FIELDS: &[ConfigEditorField] = &[
     },
     ConfigEditorField {
         key: "ui.keymap",
-        description: "Main-page navigation scheme. default=j/l+i/k, vim=h/l+j/k+gg/G+qq, custom=default fallback with custom label.",
+        description: "Main-page navigation scheme. default=j/l+i/k+count, vim=h/l+j/k+count+gg/G+qq, custom=default fallback with custom label.",
     },
     ConfigEditorField {
         key: "ui.inbox_auto_sync_interval_secs",
@@ -353,6 +353,14 @@ struct PendingMainPageChordState {
     code_focus: CodePaneFocus,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct PendingMainPageCountState {
+    count: u16,
+    ui_page: UiPage,
+    focus: Pane,
+    code_focus: CodePaneFocus,
+}
+
 #[derive(Debug, Clone)]
 enum StartupSyncEvent {
     MailboxStarted {
@@ -1249,6 +1257,7 @@ struct AppState {
     manual_sync: Option<ManualSyncState>,
     subscription_auto_sync: Option<SubscriptionAutoSyncState>,
     pending_main_page_chord: Option<PendingMainPageChordState>,
+    pending_main_page_count: Option<PendingMainPageCountState>,
 }
 
 impl AppState {
@@ -1365,6 +1374,7 @@ impl AppState {
             manual_sync: None,
             subscription_auto_sync: None,
             pending_main_page_chord: None,
+            pending_main_page_count: None,
         };
         if state.runtime.imap.is_complete() {
             state.imap_defaults_initialized = true;
@@ -3809,6 +3819,53 @@ impl AppState {
         }
     }
 
+    fn pending_main_page_count_state(&self, count: u16) -> PendingMainPageCountState {
+        PendingMainPageCountState {
+            count,
+            ui_page: self.ui_page,
+            focus: self.focus,
+            code_focus: self.code_focus,
+        }
+    }
+
+    fn clear_pending_main_page_inputs(&mut self) {
+        self.pending_main_page_chord = None;
+        self.pending_main_page_count = None;
+    }
+
+    fn clear_pending_main_page_count(&mut self) {
+        self.pending_main_page_count = None;
+    }
+
+    fn has_pending_main_page_count(&self) -> bool {
+        self.pending_main_page_count.is_some_and(|state| {
+            state.ui_page == self.ui_page
+                && state.focus == self.focus
+                && state.code_focus == self.code_focus
+        })
+    }
+
+    fn push_pending_main_page_count_digit(&mut self, digit: u16) {
+        let next_count = self
+            .pending_main_page_count
+            .filter(|state| {
+                state.ui_page == self.ui_page
+                    && state.focus == self.focus
+                    && state.code_focus == self.code_focus
+            })
+            .map(|state| state.count.saturating_mul(10).saturating_add(digit))
+            .unwrap_or(digit);
+        self.pending_main_page_count = Some(self.pending_main_page_count_state(next_count));
+    }
+
+    fn take_pending_main_page_count(&mut self) -> Option<u16> {
+        let pending_state = self.pending_main_page_count.take()?;
+        let same_scope = pending_state.ui_page == self.ui_page
+            && pending_state.focus == self.focus
+            && pending_state.code_focus == self.code_focus;
+        same_scope.then_some(pending_state.count)
+    }
+
     fn close_search(&mut self) {
         self.search.active = false;
         self.search.input.clear();

src/ui/tui/input.rs

@@ -19,49 +19,91 @@ pub(super) enum LoopAction {
     Restart,
 }
 
+fn pending_main_page_move_count(state: &mut AppState) -> u16 {
+    state.take_pending_main_page_count().unwrap_or(1)
+}
+
 fn handle_main_page_navigation_key(state: &mut AppState, key: KeyEvent) -> bool {
     match state.runtime.ui_keymap {
         UiKeymap::Default | UiKeymap::Custom => match key.code {
             KeyCode::Char('j') => {
+                state.clear_pending_main_page_count();
                 state.move_focus_previous();
                 true
             }
             KeyCode::Char('l') => {
+                state.clear_pending_main_page_count();
                 state.move_focus_next();
                 true
             }
             KeyCode::Char('i') => {
-                state.move_up();
+                for _ in 0..pending_main_page_move_count(state) {
+                    state.move_up();
+                }
                 true
             }
             KeyCode::Char('k') => {
-                state.move_down();
+                for _ in 0..pending_main_page_move_count(state) {
+                    state.move_down();
+                }
                 true
             }
             _ => false,
         },
         UiKeymap::Vim => match key.code {
             KeyCode::Char('h') => {
+                state.clear_pending_main_page_count();
                 state.move_focus_previous();
                 true
             }
             KeyCode::Char('l') => {
+                state.clear_pending_main_page_count();
                 state.move_focus_next();
                 true
             }
             KeyCode::Char('k') => {
-                state.move_up();
+                for _ in 0..pending_main_page_move_count(state) {
+                    state.move_up();
+                }
                 true
             }
             KeyCode::Char('j') => {
-                state.move_down();
+                for _ in 0..pending_main_page_move_count(state) {
+                    state.move_down();
+                }
                 true
             }
             _ => false,
         },
     }
 }
 
+fn handle_main_page_count_prefix(state: &mut AppState, key: KeyEvent) -> bool {
+    if key
+        .modifiers
+        .intersects(KeyModifiers::CONTROL | KeyModifiers::ALT | KeyModifiers::SUPER)
+    {
+        state.clear_pending_main_page_count();
+        return false;
+    }
+
+    let KeyCode::Char(character) = key.code else {
+        return false;
+    };
+    if !character.is_ascii_digit() {
+        return false;
+    }
+    if character == '0' && !state.has_pending_main_page_count() {
+        return false;
+    }
+
+    let digit = character
+        .to_digit(10)
+        .expect("ascii digit should convert to decimal") as u16;
+    state.push_pending_main_page_count_digit(digit);
+    true
+}
+
 fn handle_vim_main_page_chord(state: &mut AppState, key: KeyEvent) -> Option<LoopAction> {
     if !matches!(state.runtime.ui_keymap, UiKeymap::Vim) {
         state.pending_main_page_chord = None;
@@ -72,7 +114,7 @@ fn handle_vim_main_page_chord(state: &mut AppState, key: KeyEvent) -> Option<Loo
         .modifiers
         .intersects(KeyModifiers::CONTROL | KeyModifiers::ALT | KeyModifiers::SUPER)
     {
-        state.pending_main_page_chord = None;
+        state.clear_pending_main_page_inputs();
         return None;
     }
 
@@ -96,15 +138,18 @@ fn handle_vim_main_page_chord(state: &mut AppState, key: KeyEvent) -> Option<Loo
 
     match key.code {
         KeyCode::Char('g') => {
+            state.clear_pending_main_page_count();
             state.pending_main_page_chord =
                 Some(state.pending_main_page_chord_state(PendingMainPageChord::VimGoToFirstLine));
             Some(LoopAction::Continue)
         }
         KeyCode::Char('G') => {
+            state.clear_pending_main_page_count();
             state.jump_current_pane_to_end();
             Some(LoopAction::Continue)
         }
         KeyCode::Char('q') => {
+            state.clear_pending_main_page_count();
             state.pending_main_page_chord =
                 Some(state.pending_main_page_chord_state(PendingMainPageChord::VimQuit));
             state.status = "press qq to quit or use command palette quit/exit".to_string();
@@ -130,12 +175,12 @@ pub(super) fn handle_key_event(state: &mut AppState, key: KeyEvent) -> LoopActio
     // Modal UI surfaces take precedence over the base page shortcuts so keys
     // keep local meaning while a dialog, editor, or search interaction is open.
     if state.config_editor.open {
-        state.pending_main_page_chord = None;
+        state.clear_pending_main_page_inputs();
         return handle_config_editor_key_event(state, key);
     }
 
     if state.palette.open {
-        state.pending_main_page_chord = None;
+        state.clear_pending_main_page_inputs();
         if is_palette_toggle(key) {
             state.close_palette();
             return LoopAction::Continue;
@@ -144,25 +189,30 @@ pub(super) fn handle_key_event(state: &mut AppState, key: KeyEvent) -> LoopActio
     }
 
     if state.search.active {
-        state.pending_main_page_chord = None;
+        state.clear_pending_main_page_inputs();
         return handle_search_key_event(state, key);
     }
 
     if state.reply_panel.is_some() {
-        state.pending_main_page_chord = None;
+        state.clear_pending_main_page_inputs();
         return handle_reply_key_event(state, key);
     }
 
     if state.is_code_edit_active() {
-        state.pending_main_page_chord = None;
+        state.clear_pending_main_page_inputs();
         return handle_code_edit_key_event(state, key);
     }
 
     if let Some(action) = handle_vim_main_page_chord(state, key) {
         return action;
     }
 
+    if handle_main_page_count_prefix(state, key) {
+        return LoopAction::Continue;
+    }
+
     if is_palette_open_shortcut(key) {
+        state.clear_pending_main_page_count();
         state.toggle_palette();
         return LoopAction::Continue;
     }
@@ -171,6 +221,8 @@ pub(super) fn handle_key_event(state: &mut AppState, key: KeyEvent) -> LoopActio
         return LoopAction::Continue;
     }
 
+    state.clear_pending_main_page_count();
+
     match key.code {
         KeyCode::Char('/') => {
             if matches!(state.ui_page, UiPage::Mail) {