Struct Prompt 

pub struct Prompt {

    pub message: String,
    pub input: String,
    pub cursor_pos: usize,
    pub prompt_type: PromptType,
    pub suggestions: Vec<Suggestion>,
    pub original_suggestions: Option<Vec<Suggestion>>,
    pub selected_suggestion: Option<usize>,
    pub scroll_offset: usize,
    pub manual_scroll: bool,
    pub selection_anchor: Option<usize>,
    pub suggestions_set_for_input: Option<String>,
    pub sync_input_on_navigate: bool,
    pub overlay: bool,
    pub title: Vec<StyledText>,
    pub footer: Vec<StyledText>,
    pub toolbar_widget: Option<WidgetSpec>,
    pub toolbar_focus: Option<String>,
    pub status: String,
    /* private fields */
}

Prompt state for the minibuffer

Fields

message: String

The prompt message (e.g., “Find file: “)

input: String

User’s current input

cursor_pos: usize

Cursor position in the input

prompt_type: PromptType

What to do when user confirms

suggestions: Vec<Suggestion>

Autocomplete suggestions (filtered)

original_suggestions: Option<Vec<Suggestion>>

Original unfiltered suggestions (for prompts that filter client-side like SwitchToTab)

selected_suggestion: Option<usize>

Currently selected suggestion index

scroll_offset: usize

Index of the first suggestion shown in the popup viewport. Updated minimally by the renderer to keep selected_suggestion visible — selection changes inside the viewport never scroll (issue #1660).

manual_scroll: bool

When true, the user has scrolled the result list with the mouse wheel, so the renderer must NOT pull scroll_offset back to keep the selection in view (issue #2119). Reset whenever the selection moves by keyboard or the suggestion list is rebuilt, so normal navigation re-engages the keep-selection-visible behaviour.

selection_anchor: Option<usize>

Selection anchor position (for Shift+Arrow selection) When Some(pos), there’s a selection from anchor to cursor_pos

suggestions_set_for_input: Option<String>

Tracks the input value when suggestions were last set by a plugin. Used to skip Rust-side filtering when plugin has already filtered for this input.

sync_input_on_navigate: bool

When true, navigating suggestions updates the input text (selected) to match. Used by plugin prompts that want picker-like behavior (e.g. compose width).

overlay: bool

When true, the renderer draws the prompt inside a centred floating overlay (PopupPosition::CenteredOverlay) instead of the bottom minibuffer row. Set by the live-grep plugin via the floatingOverlay flag on editor.startPrompt(...). The flag is rendering-only — confirm/cancel/hooks behave identically to a non-overlay prompt of the same prompt_type.

title: Vec<StyledText>

Title shown in the overlay’s frame header as styled segments. An empty vec falls back to the prompt_type- specific default. Plugin-controlled via editor.setPromptTitle(segments). Has no effect on non-overlay prompts.

footer: Vec<StyledText>

Optional footer chrome shown along the bottom of the floating overlay’s results pane (above the frame border). Plugin-controlled via editor.setPromptFooter(segments). Orchestrator uses this for hotkey-hint rows (e.g. “ [n] new [d] dive [k] kill [Esc] close“). Empty by default; has no effect on non-overlay prompts. Implements the chrome-region piece of Primitive #2 in docs/internal/orchestrator-sessions-design.md (the session_preview delegate region was already provided by Primitive #1 — editor.previewWindowInRect).

toolbar_widget: Option<WidgetSpec>

Optional toolbar for the overlay’s header band, as real widgets (Toggle/Button in a Row/Col). When Some, it is rendered via the widget engine in place of the styled-text title, so the controls are themed and clickable. Plugin-controlled via editor.setPromptToolbar(spec). No effect on non-overlay prompts.

toolbar_focus: Option<String>

Overlay focus ring position: None = the query input is focused (typing edits the query, the caret shows there); Some(key) = that toolbar control is focused (Space/Enter toggles it, it renders highlighted). Tab/Shift+Tab cycle input → toggles → input.

status: String

Short status shown right-aligned on the input row, just left of the selected / total count (e.g. “Searching…”, “No matches”). Plugin- controlled via editor.setPromptStatus(text); overlay-only.

Implementations

impl Prompt

pub fn new(message: String, prompt_type: PromptType) -> Self

Create a new prompt

pub fn with_suggestions( message: String, prompt_type: PromptType, suggestions: Vec<Suggestion>, ) -> Self

Create a new prompt with suggestions

The suggestions are stored both as the current filtered list and as the original unfiltered list (for prompts that filter client-side like SwitchToTab).

pub fn with_initial_text_for_edit( message: String, prompt_type: PromptType, initial_text: String, ) -> Self

Create a new prompt with initial text, cursor at end, ready for incremental editing (no selection). Use for rename-style flows where the user typically keeps most of the prefilled name and only appends or tweaks a suffix.

pub fn with_initial_text( message: String, prompt_type: PromptType, initial_text: String, ) -> Self

Create a new prompt with initial text (selected so typing replaces it)

pub fn cursor_left(&mut self)

Move cursor left (to previous grapheme cluster boundary)

Uses grapheme cluster boundaries for proper handling of combining characters like Thai diacritics, emoji with modifiers, etc.

pub fn cursor_right(&mut self)

Move cursor right (to next grapheme cluster boundary)

Uses grapheme cluster boundaries for proper handling of combining characters like Thai diacritics, emoji with modifiers, etc.

pub fn undo_input(&mut self) -> bool

Undo the last input edit. Returns true if the input changed.

pub fn redo_input(&mut self) -> bool

Redo the last undone input edit. Returns true if the input changed.

pub fn insert_char(&mut self, ch: char)

Insert a character at the cursor position

pub fn backspace(&mut self)

Delete one code point before cursor (backspace)

Deletes one Unicode code point at a time, allowing layer-by-layer deletion of combining characters. For Thai text, this means you can delete just the tone mark without removing the base consonant.

pub fn delete(&mut self)

Delete grapheme cluster at cursor (delete key)

Deletes the entire grapheme cluster, handling combining characters properly.

pub fn move_to_start(&mut self)

Move to start of input

pub fn move_to_end(&mut self)

Move to end of input

pub fn set_input(&mut self, text: String)

Set the input text and cursor position

Used for history navigation - replaces the entire input with a new value and moves cursor to the end.

Example

let mut prompt = Prompt::new("Search: ".to_string(), PromptType::Search);
prompt.input = "current".to_string();
prompt.cursor_pos = 7;

prompt.set_input("from history".to_string());
assert_eq!(prompt.input, "from history");
assert_eq!(prompt.cursor_pos, 12); // At end

pub fn select_next_suggestion(&mut self)

Select next suggestion

pub fn select_prev_suggestion(&mut self)

Select previous suggestion

pub fn scroll_results(&mut self, delta: i32, visible: usize)

Scroll the result list by delta rows without moving the selection (mouse wheel over the Live Grep overlay results pane, issue #2119). visible is the number of result rows currently on screen, used to clamp the offset so it can’t scroll past the end of the list.

pub fn selected_value(&self) -> Option<String>

Get the currently selected suggestion value

pub fn get_final_input(&self) -> String

Get the final input (use selected suggestion if available, otherwise raw input)

pub fn filter_suggestions(&mut self, match_description: bool)

Apply fuzzy filtering to suggestions based on current input

If match_description is true, also matches against suggestion descriptions. Updates suggestions with filtered and sorted results.

pub fn ensure_selected_visible(&mut self)

Adjust scroll_offset so that selected_suggestion is inside the viewport, scrolling the minimum amount required. A selection that’s already on-screen leaves the viewport untouched — this is what stops a click on a near-bottom item from snapping the list upward and recentering under the cursor (issue #1660).

Uses the bottom-popup default cap (MAX_VISIBLE_SUGGESTIONS). Callers rendering into a different-sized area (e.g. the floating Live Grep overlay, where the suggestion list can be 30+ rows tall) should call [ensure_selected_visible_within] with the actual height instead — otherwise the scroll moves prematurely once the selection passes the 10th row even though the rest of the list is still visible on-screen.

pub fn ensure_selected_visible_within(&mut self, visible_count: usize)

Like [ensure_selected_visible] but with an explicit visible_count argument, so renderers in differently-sized frames don’t all share the bottom-popup MAX_VISIBLE_SUGGESTIONS assumption.

pub fn delete_word_forward(&mut self)

Delete from cursor to end of word (Ctrl+Delete).

Deletes from the current cursor position to the end of the current word. If the cursor is at a non-word character, skips to the next word and deletes to its end.

Example

let mut prompt = Prompt::new("Find: ".to_string(), PromptType::OpenFile);
prompt.input = "hello world".to_string();
prompt.cursor_pos = 0; // At start of "hello"
prompt.delete_word_forward();
assert_eq!(prompt.input, " world");
assert_eq!(prompt.cursor_pos, 0);

pub fn delete_word_backward(&mut self)

Delete from start of word to cursor (Ctrl+Backspace).

Deletes from the start of the current word to the cursor position. If the cursor is after a non-word character, deletes the previous word.

Example

let mut prompt = Prompt::new("Find: ".to_string(), PromptType::OpenFile);
prompt.input = "hello world".to_string();
prompt.cursor_pos = 5; // After "hello"
prompt.delete_word_backward();
assert_eq!(prompt.input, " world");
assert_eq!(prompt.cursor_pos, 0);

pub fn delete_to_end(&mut self)

Delete from cursor to end of line (Ctrl+K).

Deletes all text from the cursor position to the end of the input.

Example

let mut prompt = Prompt::new("Find: ".to_string(), PromptType::OpenFile);
prompt.input = "hello world".to_string();
prompt.cursor_pos = 5; // After "hello"
prompt.delete_to_end();
assert_eq!(prompt.input, "hello");
assert_eq!(prompt.cursor_pos, 5);

pub fn delete_to_start(&mut self)

Delete from the cursor back to the start of the line (Ctrl+U).

Mirrors the standard readline kill-to-start behavior so the command palette can be cleared without holding Backspace.

pub fn get_text(&self) -> String

Get the current input text (for copy operation).

Returns a copy of the entire input. In future, this could be extended to support selection ranges for copying only selected text.

Example

let mut prompt = Prompt::new("Search: ".to_string(), PromptType::Search);
prompt.input = "test query".to_string();
assert_eq!(prompt.get_text(), "test query");

pub fn clear(&mut self)

Clear the input (used for cut operation).

Removes all text from the input and resets cursor to start.

Example

let mut prompt = Prompt::new("Find: ".to_string(), PromptType::OpenFile);
prompt.input = "some text".to_string();
prompt.cursor_pos = 9;
prompt.clear();
assert_eq!(prompt.input, "");
assert_eq!(prompt.cursor_pos, 0);

pub fn insert_str(&mut self, text: &str)

Insert text at cursor position (used for paste operation).

Inserts the given text at the current cursor position and moves the cursor to the end of the inserted text.

Example

let mut prompt = Prompt::new("Command: ".to_string(), PromptType::QuickOpen);
prompt.input = "save".to_string();
prompt.cursor_pos = 4;
prompt.insert_str(" file");
assert_eq!(prompt.input, "save file");
assert_eq!(prompt.cursor_pos, 9);

pub fn has_selection(&self) -> bool

Check if there’s an active selection

pub fn selection_range(&self) -> Option<(usize, usize)>

Get the selection range (start, end) where start <= end

pub fn selected_text(&self) -> Option<String>

Get the selected text

pub fn delete_selection(&mut self) -> Option<String>

Delete the current selection and return the deleted text

pub fn clear_selection(&mut self)

Clear selection without deleting text

pub fn move_left_selecting(&mut self)

Move cursor left with selection (by grapheme cluster)

pub fn move_right_selecting(&mut self)

Move cursor right with selection (by grapheme cluster)

pub fn move_home_selecting(&mut self)

Move to start of input with selection

pub fn move_end_selecting(&mut self)

Move to end of input with selection

pub fn move_word_left_selecting(&mut self)

Move to start of previous word with selection Mimics Buffer’s find_word_start_left behavior

pub fn move_word_right_selecting(&mut self)

Move to end of next word with selection For selection, we want to select whole words, so move to word END, not word START

pub fn move_word_left(&mut self)

Move to start of previous word (without selection) Mimics Buffer’s find_word_start_left behavior

pub fn move_word_right(&mut self)

Move to start of next word (without selection) Mimics Buffer’s find_word_start_right behavior

Trait Implementations

impl Clone for Prompt

fn clone(&self) -> Prompt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Prompt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl InputHandler for Prompt

fn handle_key_event( &mut self, event: &KeyEvent, ctx: &mut InputContext, ) -> InputResult

Handle a key event. Returns whether the event was consumed.

fn is_modal(&self) -> bool

Whether this handler is modal (consumes all unhandled input).

fn focused_child(&self) -> Option<&dyn InputHandler>

Get the currently focused child handler, if any.

fn focused_child_mut(&mut self) -> Option<&mut dyn InputHandler>

Get the currently focused child handler mutably, if any.

fn dispatch_input( &mut self, event: &KeyEvent, ctx: &mut InputContext, ) -> InputResult

Dispatch input through this handler and its children. This is the main entry point - it handles the bubble-up logic.