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 selection_anchor: Option<usize>,
    pub suggestions_set_for_input: Option<String>,
    pub sync_input_on_navigate: bool,
}

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

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).

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( 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 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 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 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 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::Command);
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.