mirror of
https://github.com/openai/codex.git
synced 2026-11-17 22:10:37 +00:00
## Why Interrupting an active turn is currently fixed to `Esc`, which is easy to hit accidentally and cannot be customized through `/keymap`. This gives users a less accidental binding while preserving the existing default. ## What Changed - Adds `tui.keymap.chat.interrupt_turn` to `/keymap`, defaulting to `esc` and supporting remapping or unbinding. - Uses the configured interrupt binding for running-turn status, queued steer interruption, and `request_user_input`, including the visible hints. - Preserves local `Esc` behavior for popups, Vim insert mode, and `/agent` editing while validating conflicts with fixed/backtrack and request-input navigation bindings. - Adds behavior and snapshot coverage for remapped interruption paths. ## How to Test 1. Run Codex and open `/keymap`, then set **Interrupt Turn** to `f12`. 2. Start a turn and confirm `Esc` no longer interrupts it while `f12` does; the running hint should display `f12 to interrupt`. 3. Queue a steer while a turn is running and confirm the preview displays `f12`; pressing it should interrupt and submit the steer immediately. 4. Trigger a `request_user_input` prompt and confirm its footer uses `f12`; with notes open, `Esc` should still clear notes while `f12` interrupts the turn. 5. Clear the Interrupt Turn binding and confirm the key-specific interrupt hint is removed while `Ctrl+C` remains available. Targeted validation: - `just write-config-schema` - `just fix -p codex-config` - `just fix -p codex-tui` - `just fmt` - `just argument-comment-lint-from-source -p codex-config -p codex-tui` - `just test -p codex-config` - `cargo insta pending-snapshots --manifest-path tui/Cargo.toml` - `just test -p codex-tui keymap_setup::tests` - `just test -p codex-tui` (fails in two pre-existing guardian feature-flag tests unrelated to this diff; the intentional picker snapshot updates were reviewed and accepted)
480 lines
15 KiB
Rust
480 lines
15 KiB
Rust
//! Shortcut picker construction for `/keymap`.
|
|
|
|
use codex_config::types::TuiKeymap;
|
|
use ratatui::style::Styled;
|
|
use ratatui::style::Stylize;
|
|
use ratatui::text::Line;
|
|
use ratatui::text::Span;
|
|
use unicode_width::UnicodeWidthStr;
|
|
|
|
use crate::app_event::AppEvent;
|
|
use crate::bottom_pane::ColumnWidthMode;
|
|
use crate::bottom_pane::SelectionItem;
|
|
use crate::bottom_pane::SelectionRowDisplay;
|
|
use crate::bottom_pane::SelectionTab;
|
|
use crate::bottom_pane::SelectionViewParams;
|
|
use crate::keymap::RuntimeKeymap;
|
|
use crate::render::renderable::ColumnRenderable;
|
|
use crate::render::renderable::Renderable;
|
|
use crate::style::accent_style;
|
|
|
|
use super::actions::KEYMAP_ACTIONS;
|
|
use super::actions::KeymapActionFilter;
|
|
use super::actions::action_label;
|
|
use super::actions::bindings_for_action;
|
|
use super::actions::format_binding_summary;
|
|
use super::has_custom_binding;
|
|
|
|
pub(crate) const KEYMAP_PICKER_VIEW_ID: &str = "keymap-picker";
|
|
pub(super) const KEYMAP_ALL_TAB_ID: &str = "all-shortcuts";
|
|
pub(super) const KEYMAP_COMMON_TAB_ID: &str = "common-shortcuts";
|
|
pub(super) const KEYMAP_CUSTOM_TAB_ID: &str = "custom-shortcuts";
|
|
pub(super) const KEYMAP_UNBOUND_TAB_ID: &str = "unbound-shortcuts";
|
|
pub(super) const KEYMAP_DEBUG_TAB_ID: &str = "debug-shortcuts";
|
|
const KEYMAP_CONTEXT_LABEL_WIDTH: usize = 12;
|
|
const KEYMAP_ROW_PREFIX_WIDTH: usize = KEYMAP_CONTEXT_LABEL_WIDTH + 3;
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct KeymapActionRow {
|
|
context: &'static str,
|
|
context_label: &'static str,
|
|
action: &'static str,
|
|
label: String,
|
|
description: &'static str,
|
|
binding_summary: String,
|
|
custom_binding: bool,
|
|
}
|
|
|
|
impl KeymapActionRow {
|
|
fn is_unbound(&self) -> bool {
|
|
self.binding_summary == "unbound"
|
|
}
|
|
}
|
|
|
|
struct KeymapContextTab {
|
|
id: &'static str,
|
|
label: &'static str,
|
|
description: &'static str,
|
|
contexts: &'static [&'static str],
|
|
}
|
|
|
|
const KEYMAP_COMMON_ACTIONS: &[(&str, &str)] = &[
|
|
("composer", "submit"),
|
|
("chat", "interrupt_turn"),
|
|
("editor", "insert_newline"),
|
|
("composer", "queue"),
|
|
("global", "toggle_fast_mode"),
|
|
("global", "open_external_editor"),
|
|
("global", "copy"),
|
|
("global", "toggle_vim_mode"),
|
|
("editor", "delete_backward_word"),
|
|
("editor", "delete_forward_word"),
|
|
("editor", "move_word_left"),
|
|
("editor", "move_word_right"),
|
|
("global", "open_transcript"),
|
|
("pager", "close"),
|
|
("pager", "page_up"),
|
|
("pager", "page_down"),
|
|
("approval", "open_fullscreen"),
|
|
("approval", "approve"),
|
|
("approval", "approve_for_session"),
|
|
("approval", "decline"),
|
|
("approval", "cancel"),
|
|
];
|
|
|
|
const KEYMAP_CONTEXT_TABS: &[KeymapContextTab] = &[
|
|
KeymapContextTab {
|
|
id: "app-shortcuts",
|
|
label: "App",
|
|
description: "Global and chat-level shortcuts.",
|
|
contexts: &["global", "chat"],
|
|
},
|
|
KeymapContextTab {
|
|
id: "composer-shortcuts",
|
|
label: "Composer",
|
|
description: "Composer submission and queue shortcuts.",
|
|
contexts: &["composer"],
|
|
},
|
|
KeymapContextTab {
|
|
id: "editor-shortcuts",
|
|
label: "Editor",
|
|
description: "Inline editor movement and editing shortcuts.",
|
|
contexts: &["editor"],
|
|
},
|
|
KeymapContextTab {
|
|
id: "vim-shortcuts",
|
|
label: "Vim",
|
|
description: "Vim normal-mode and operator shortcuts.",
|
|
contexts: &["vim_normal", "vim_operator", "vim_text_object"],
|
|
},
|
|
KeymapContextTab {
|
|
id: "navigation-shortcuts",
|
|
label: "Navigation",
|
|
description: "Pager and selection-list navigation shortcuts.",
|
|
contexts: &["pager", "list"],
|
|
},
|
|
KeymapContextTab {
|
|
id: "approval-shortcuts",
|
|
label: "Approval",
|
|
description: "Approval prompt shortcuts.",
|
|
contexts: &["approval"],
|
|
},
|
|
];
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn build_keymap_picker_params(
|
|
runtime_keymap: &RuntimeKeymap,
|
|
keymap_config: &TuiKeymap,
|
|
) -> SelectionViewParams {
|
|
build_keymap_picker_params_with_filter(
|
|
runtime_keymap,
|
|
keymap_config,
|
|
KeymapActionFilter::default(),
|
|
)
|
|
}
|
|
|
|
pub(crate) fn build_keymap_picker_params_with_filter(
|
|
runtime_keymap: &RuntimeKeymap,
|
|
keymap_config: &TuiKeymap,
|
|
action_filter: KeymapActionFilter,
|
|
) -> SelectionViewParams {
|
|
build_keymap_picker_params_for_action(
|
|
runtime_keymap,
|
|
keymap_config,
|
|
action_filter,
|
|
/*selected_action*/ None,
|
|
)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn build_keymap_picker_params_for_selected_action(
|
|
runtime_keymap: &RuntimeKeymap,
|
|
keymap_config: &TuiKeymap,
|
|
context: &str,
|
|
action: &str,
|
|
) -> SelectionViewParams {
|
|
build_keymap_picker_params_for_selected_action_with_filter(
|
|
runtime_keymap,
|
|
keymap_config,
|
|
KeymapActionFilter::default(),
|
|
context,
|
|
action,
|
|
)
|
|
}
|
|
|
|
pub(crate) fn build_keymap_picker_params_for_selected_action_with_filter(
|
|
runtime_keymap: &RuntimeKeymap,
|
|
keymap_config: &TuiKeymap,
|
|
action_filter: KeymapActionFilter,
|
|
context: &str,
|
|
action: &str,
|
|
) -> SelectionViewParams {
|
|
build_keymap_picker_params_for_action(
|
|
runtime_keymap,
|
|
keymap_config,
|
|
action_filter,
|
|
Some((context, action)),
|
|
)
|
|
}
|
|
|
|
fn build_keymap_picker_params_for_action(
|
|
runtime_keymap: &RuntimeKeymap,
|
|
keymap_config: &TuiKeymap,
|
|
action_filter: KeymapActionFilter,
|
|
selected_action: Option<(&str, &str)>,
|
|
) -> SelectionViewParams {
|
|
let rows = build_keymap_rows(runtime_keymap, keymap_config, action_filter);
|
|
let total = rows.len();
|
|
let custom_count = rows.iter().filter(|row| row.custom_binding).count();
|
|
let unbound_count = rows.iter().filter(|row| row.is_unbound()).count();
|
|
let initial_selected_idx = selected_action.and_then(|(context, action)| {
|
|
rows.iter()
|
|
.position(|row| row.context == context && row.action == action)
|
|
});
|
|
let name_column_width = rows
|
|
.iter()
|
|
.map(|row| KEYMAP_ROW_PREFIX_WIDTH + UnicodeWidthStr::width(row.label.as_str()))
|
|
.max();
|
|
|
|
let mut tabs = Vec::new();
|
|
tabs.push(SelectionTab {
|
|
id: KEYMAP_ALL_TAB_ID.to_string(),
|
|
label: "All".to_string(),
|
|
header: keymap_header(
|
|
"All configurable shortcuts.".to_string(),
|
|
format!("{total} actions, {custom_count} customized, {unbound_count} unbound."),
|
|
),
|
|
items: keymap_selection_items(
|
|
rows.iter(),
|
|
"No shortcuts available",
|
|
"No configurable shortcuts are available.",
|
|
),
|
|
});
|
|
|
|
let common_rows = keymap_common_rows(&rows);
|
|
let common_count = common_rows.len();
|
|
tabs.push(SelectionTab {
|
|
id: KEYMAP_COMMON_TAB_ID.to_string(),
|
|
label: "Common".to_string(),
|
|
header: keymap_header(
|
|
"Frequently customized shortcuts.".to_string(),
|
|
action_count_line(common_count),
|
|
),
|
|
items: keymap_selection_items(
|
|
common_rows,
|
|
"No common shortcuts",
|
|
"No common shortcut actions are available.",
|
|
),
|
|
});
|
|
|
|
let custom_rows = rows
|
|
.iter()
|
|
.filter(|row| row.custom_binding)
|
|
.collect::<Vec<_>>();
|
|
tabs.push(SelectionTab {
|
|
id: KEYMAP_CUSTOM_TAB_ID.to_string(),
|
|
label: format!("Customized ({custom_count})"),
|
|
header: keymap_header(
|
|
"Root-level shortcut overrides.".to_string(),
|
|
action_count_line(custom_count),
|
|
),
|
|
items: keymap_selection_items(
|
|
custom_rows,
|
|
"No customized shortcuts",
|
|
"No root-level keymap overrides have been configured.",
|
|
),
|
|
});
|
|
|
|
let unbound_rows = rows
|
|
.iter()
|
|
.filter(|row| row.is_unbound())
|
|
.collect::<Vec<_>>();
|
|
tabs.push(SelectionTab {
|
|
id: KEYMAP_UNBOUND_TAB_ID.to_string(),
|
|
label: format!("Unbound ({unbound_count})"),
|
|
header: keymap_header(
|
|
"Actions without an active shortcut.".to_string(),
|
|
action_count_line(unbound_count),
|
|
),
|
|
items: keymap_selection_items(
|
|
unbound_rows,
|
|
"No unbound shortcuts",
|
|
"Every configurable action currently has a shortcut.",
|
|
),
|
|
});
|
|
|
|
for tab in KEYMAP_CONTEXT_TABS {
|
|
let tab_rows = rows
|
|
.iter()
|
|
.filter(|row| tab.contexts.contains(&row.context))
|
|
.collect::<Vec<_>>();
|
|
let count = tab_rows.len();
|
|
tabs.push(SelectionTab {
|
|
id: tab.id.to_string(),
|
|
label: tab.label.to_string(),
|
|
header: keymap_header(tab.description.to_string(), action_count_line(count)),
|
|
items: keymap_selection_items(
|
|
tab_rows,
|
|
"No shortcuts in this group",
|
|
"No configurable actions are available in this group.",
|
|
),
|
|
});
|
|
}
|
|
tabs.push(keymap_debug_tab());
|
|
|
|
SelectionViewParams {
|
|
view_id: Some(KEYMAP_PICKER_VIEW_ID),
|
|
header: Box::new(()),
|
|
footer_hint: Some(keymap_picker_hint_line()),
|
|
tab_footer_hints: vec![(KEYMAP_DEBUG_TAB_ID.to_string(), keymap_debug_hint_line())],
|
|
tabs,
|
|
initial_tab_id: Some(KEYMAP_ALL_TAB_ID.to_string()),
|
|
is_searchable: true,
|
|
search_placeholder: Some("Type to search shortcuts".to_string()),
|
|
col_width_mode: ColumnWidthMode::AutoAllRows,
|
|
row_display: SelectionRowDisplay::SingleLine,
|
|
name_column_width,
|
|
initial_selected_idx,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
fn keymap_debug_tab() -> SelectionTab {
|
|
SelectionTab {
|
|
id: KEYMAP_DEBUG_TAB_ID.to_string(),
|
|
label: "Debug".to_string(),
|
|
header: keymap_header(
|
|
"Inspect keypresses from your terminal.".to_string(),
|
|
"See the key Codex detects and any shortcuts assigned to it.".to_string(),
|
|
),
|
|
items: vec![SelectionItem {
|
|
name: "Inspect keypresses".to_string(),
|
|
description: Some(
|
|
"Press Enter to start. Then press any key to inspect it; Ctrl+C exits."
|
|
.to_string(),
|
|
),
|
|
selected_description: Some(
|
|
"Open a live inspector that shows the detected key, config key, and matching actions."
|
|
.to_string(),
|
|
),
|
|
actions: vec![Box::new(|tx| {
|
|
tx.send(AppEvent::OpenKeymapDebug);
|
|
})],
|
|
search_value: Some("debug inspect keypress key terminal detected actions".to_string()),
|
|
..Default::default()
|
|
}],
|
|
}
|
|
}
|
|
|
|
fn build_keymap_rows(
|
|
runtime_keymap: &RuntimeKeymap,
|
|
keymap_config: &TuiKeymap,
|
|
action_filter: KeymapActionFilter,
|
|
) -> Vec<KeymapActionRow> {
|
|
KEYMAP_ACTIONS
|
|
.iter()
|
|
.copied()
|
|
.filter(|descriptor| descriptor.is_visible(action_filter))
|
|
.map(|descriptor| {
|
|
let bindings =
|
|
bindings_for_action(runtime_keymap, descriptor.context, descriptor.action)
|
|
.unwrap_or(&[]);
|
|
KeymapActionRow {
|
|
context: descriptor.context,
|
|
context_label: descriptor.context_label,
|
|
action: descriptor.action,
|
|
label: action_label(descriptor.action),
|
|
description: descriptor.description,
|
|
binding_summary: format_binding_summary(bindings),
|
|
custom_binding: has_custom_binding(
|
|
keymap_config,
|
|
descriptor.context,
|
|
descriptor.action,
|
|
)
|
|
.unwrap_or(false),
|
|
}
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn keymap_common_rows(rows: &[KeymapActionRow]) -> Vec<&KeymapActionRow> {
|
|
KEYMAP_COMMON_ACTIONS
|
|
.iter()
|
|
.filter_map(|(context, action)| {
|
|
rows.iter()
|
|
.find(|row| row.context == *context && row.action == *action)
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn keymap_selection_items<'a>(
|
|
rows: impl IntoIterator<Item = &'a KeymapActionRow>,
|
|
empty_name: &str,
|
|
empty_description: &str,
|
|
) -> Vec<SelectionItem> {
|
|
let items = rows
|
|
.into_iter()
|
|
.map(keymap_selection_item)
|
|
.collect::<Vec<_>>();
|
|
if items.is_empty() {
|
|
return vec![SelectionItem {
|
|
name: empty_name.to_string(),
|
|
description: Some(empty_description.to_string()),
|
|
is_disabled: true,
|
|
..Default::default()
|
|
}];
|
|
}
|
|
|
|
items
|
|
}
|
|
|
|
fn keymap_selection_item(row: &KeymapActionRow) -> SelectionItem {
|
|
let context = row.context.to_string();
|
|
let action = row.action.to_string();
|
|
let source = if row.custom_binding {
|
|
"Custom"
|
|
} else {
|
|
"Default"
|
|
};
|
|
let search_value = format!(
|
|
"{} {} {} {} {} {}",
|
|
row.context_label, row.action, row.label, row.description, row.binding_summary, source
|
|
);
|
|
|
|
SelectionItem {
|
|
name: row.label.clone(),
|
|
name_prefix_spans: keymap_row_prefix(row),
|
|
description: Some(row.binding_summary.clone()),
|
|
actions: vec![Box::new(move |tx| {
|
|
tx.send(AppEvent::OpenKeymapActionMenu {
|
|
context: context.clone(),
|
|
action: action.clone(),
|
|
});
|
|
})],
|
|
search_value: Some(search_value),
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
fn keymap_row_prefix(row: &KeymapActionRow) -> Vec<Span<'static>> {
|
|
let indicator = if row.custom_binding {
|
|
"*".set_style(accent_style())
|
|
} else if row.is_unbound() {
|
|
"-".dim()
|
|
} else {
|
|
" ".into()
|
|
};
|
|
|
|
vec![
|
|
format!(
|
|
"{:<width$} ",
|
|
row.context_label,
|
|
width = KEYMAP_CONTEXT_LABEL_WIDTH
|
|
)
|
|
.dim(),
|
|
indicator,
|
|
" ".dim(),
|
|
]
|
|
}
|
|
|
|
fn keymap_header(description: String, summary: String) -> Box<dyn Renderable> {
|
|
let mut header = ColumnRenderable::new();
|
|
header.push(Line::from("Keymap".bold()));
|
|
header.push(Line::from(description.dim()));
|
|
header.push(Line::from(summary.dim()));
|
|
Box::new(header)
|
|
}
|
|
|
|
fn action_count_line(count: usize) -> String {
|
|
match count {
|
|
1 => "1 action.".to_string(),
|
|
_ => format!("{count} actions."),
|
|
}
|
|
}
|
|
|
|
fn keymap_picker_hint_line() -> Line<'static> {
|
|
let style = accent_style();
|
|
Line::from(vec![
|
|
"left/right".set_style(style),
|
|
" group · ".dim(),
|
|
"enter".set_style(style),
|
|
" edit shortcut · ".dim(),
|
|
"*".set_style(style),
|
|
" custom · ".dim(),
|
|
"-".set_style(style),
|
|
" unbound · ".dim(),
|
|
"esc".set_style(style),
|
|
" close".dim(),
|
|
])
|
|
}
|
|
|
|
fn keymap_debug_hint_line() -> Line<'static> {
|
|
let style = accent_style();
|
|
Line::from(vec![
|
|
"enter".set_style(style),
|
|
" start inspector · ".dim(),
|
|
"esc".set_style(style),
|
|
" close".dim(),
|
|
])
|
|
}
|