vtcode_tui/core_tui/session/

slash.rs

use ratatui::crossterm::event::{KeyCode, KeyEvent};
use ratatui::{
    prelude::*,
    widgets::{Clear, Paragraph, Wrap},
};

use crate::config::constants::ui;
use crate::ui::search::fuzzy_score;

use super::super::types::InlineTextStyle;
use super::inline_list::{InlineListRow, render_inline_list};
use super::{
    Session, ratatui_color_from_ansi, ratatui_style_from_inline,
    slash_palette::{self, SlashPaletteUpdate, command_prefix, command_range},
};

pub(crate) fn split_inline_slash_area(session: &mut Session, area: Rect) -> (Rect, Option<Rect>) {
    if area.height == 0
        || area.width == 0
        || session.modal.is_some()
        || session.file_palette_active
        || session.history_picker_state.active
    {
        session.slash_palette.clear_visible_rows();
        return (area, None);
    }

    let suggestions = session.slash_palette.suggestions();
    if suggestions.is_empty() {
        session.slash_palette.clear_visible_rows();
        return (area, None);
    }

    let instruction_rows = slash_palette_instructions(session)
        .len()
        .min(u16::MAX as usize) as u16;
    let desired_list_rows = suggestions
        .len()
        .min(ui::INLINE_LIST_MAX_ROWS)
        .min(u16::MAX as usize) as u16;
    let desired_height = instruction_rows.saturating_add(desired_list_rows.max(1));
    let max_panel_height = area.height.saturating_sub(1);
    if max_panel_height <= instruction_rows {
        session.slash_palette.clear_visible_rows();
        return (area, None);
    }

    let panel_height = desired_height.min(max_panel_height);
    let chunks =
        Layout::vertical([Constraint::Min(1), Constraint::Length(panel_height)]).split(area);
    (chunks[0], Some(chunks[1]))
}

pub fn render_slash_palette(session: &mut Session, frame: &mut Frame<'_>, area: Rect) {
    if area.height == 0 || area.width == 0 || session.modal.is_some() {
        session.slash_palette.clear_visible_rows();
        return;
    }
    let suggestions = session.slash_palette.suggestions();
    if suggestions.is_empty() {
        session.slash_palette.clear_visible_rows();
        return;
    }

    frame.render_widget(Clear, area);

    let instructions = slash_palette_instructions(session);
    let instruction_rows = instructions.len().min(u16::MAX as usize) as u16;
    let layout = if instruction_rows == 0 {
        Layout::vertical([Constraint::Min(1)]).split(area)
    } else {
        Layout::vertical([Constraint::Length(instruction_rows), Constraint::Min(1)]).split(area)
    };

    if layout.is_empty() {
        session.slash_palette.clear_visible_rows();
        return;
    }

    let list_area = if instruction_rows == 0 {
        layout[0]
    } else {
        let text_area = layout[0];
        let paragraph = Paragraph::new(instructions).wrap(Wrap { trim: true });
        frame.render_widget(paragraph, text_area);
        if layout.len() < 2 {
            session.slash_palette.clear_visible_rows();
            return;
        }
        layout[1]
    };

    if list_area.height == 0 || list_area.width == 0 {
        session.slash_palette.clear_visible_rows();
        return;
    }

    session
        .slash_palette
        .set_visible_rows((list_area.height as usize).min(ui::INLINE_LIST_MAX_ROWS));

    let rows = slash_rows(session);
    let item_count = rows.len();
    let default_style = session.styles.default_style();
    let highlight_style = slash_highlight_style(session);
    let name_style = slash_name_style(session);
    let description_style = slash_description_style(session);
    let prefix = " ".repeat(ui::MODAL_LIST_HIGHLIGHT_FULL.chars().count());

    let rendered_rows = rows
        .into_iter()
        .map(|row| {
            (
                InlineListRow::single(
                    Line::from(vec![
                        Span::styled(prefix.clone(), default_style),
                        Span::styled(format!("/{}", row.name), name_style),
                        Span::raw(" "),
                        Span::styled(row.description, description_style),
                    ]),
                    default_style,
                ),
                1_u16,
            )
        })
        .collect::<Vec<_>>();

    let selected = session
        .slash_palette
        .list_state_mut()
        .selected()
        .filter(|index| *index < item_count);
    let widget_state = render_inline_list(
        frame,
        list_area,
        rendered_rows,
        selected,
        Some(highlight_style),
    );
    let selected_index = widget_state.selected;

    let list_state = session.slash_palette.list_state_mut();
    list_state.select(selected_index);
    *list_state.offset_mut() = widget_state.scroll_offset_index();
}

fn slash_palette_instructions(session: &Session) -> Vec<Line<'static>> {
    vec![
        Line::from(Span::styled(
            ui::SLASH_PALETTE_HINT_PRIMARY.to_owned(),
            session.styles.default_style(),
        )),
        Line::from(Span::styled(
            ui::SLASH_PALETTE_HINT_SECONDARY.to_owned(),
            session.styles.default_style().add_modifier(Modifier::DIM),
        )),
    ]
}

pub(super) fn handle_slash_palette_change(session: &mut Session) {
    crate::ui::tui::session::render::recalculate_transcript_rows(session);
    session.enforce_scroll_bounds();
    session.mark_dirty();
}

pub(super) fn clear_slash_suggestions(session: &mut Session) {
    if session.slash_palette.clear() {
        handle_slash_palette_change(session);
    }
}

pub(super) fn update_slash_suggestions(session: &mut Session) {
    if !session.input_enabled {
        clear_slash_suggestions(session);
        return;
    }

    let Some(prefix) = command_prefix(
        session.input_manager.content(),
        session.input_manager.cursor(),
    ) else {
        clear_slash_suggestions(session);
        return;
    };

    match session
        .slash_palette
        .update(Some(&prefix), ui::SLASH_SUGGESTION_LIMIT)
    {
        SlashPaletteUpdate::NoChange => {}
        SlashPaletteUpdate::Cleared | SlashPaletteUpdate::Changed { .. } => {
            handle_slash_palette_change(session);
        }
    }
}

pub(crate) fn slash_navigation_available(session: &Session) -> bool {
    let has_prefix = command_prefix(
        session.input_manager.content(),
        session.input_manager.cursor(),
    )
    .is_some();
    session.input_enabled
        && !session.slash_palette.is_empty()
        && has_prefix
        && session.modal.is_none()
        && !session.file_palette_active
        && !session.history_picker_state.active
}

pub(super) fn move_slash_selection_up(session: &mut Session) -> bool {
    let changed = session.slash_palette.move_up();
    handle_slash_selection_change(session, changed)
}

pub(super) fn move_slash_selection_down(session: &mut Session) -> bool {
    let changed = session.slash_palette.move_down();
    handle_slash_selection_change(session, changed)
}

pub(super) fn select_first_slash_suggestion(session: &mut Session) -> bool {
    let changed = session.slash_palette.select_first();
    handle_slash_selection_change(session, changed)
}

pub(super) fn select_last_slash_suggestion(session: &mut Session) -> bool {
    let changed = session.slash_palette.select_last();
    handle_slash_selection_change(session, changed)
}

pub(super) fn page_up_slash_suggestion(session: &mut Session) -> bool {
    let changed = session.slash_palette.page_up();
    handle_slash_selection_change(session, changed)
}

pub(super) fn page_down_slash_suggestion(session: &mut Session) -> bool {
    let changed = session.slash_palette.page_down();
    handle_slash_selection_change(session, changed)
}

pub(super) fn handle_slash_selection_change(session: &mut Session, changed: bool) -> bool {
    if changed {
        preview_selected_slash_suggestion(session);
        crate::ui::tui::session::render::recalculate_transcript_rows(session);
        session.enforce_scroll_bounds();
        session.mark_dirty();
        true
    } else {
        false
    }
}

fn preview_selected_slash_suggestion(session: &mut Session) {
    let Some(command) = session.slash_palette.selected_command() else {
        return;
    };
    let Some(range) = command_range(
        session.input_manager.content(),
        session.input_manager.cursor(),
    ) else {
        return;
    };

    let current_input = session.input_manager.content().to_owned();
    let prefix = &current_input[..range.start];
    let suffix = &current_input[range.end..];

    let mut new_input = String::new();
    new_input.push_str(prefix);
    new_input.push('/');
    new_input.push_str(command.name.as_str());
    let cursor_position = new_input.len();

    if !suffix.is_empty() {
        if !suffix.chars().next().is_some_and(char::is_whitespace) {
            new_input.push(' ');
        }
        new_input.push_str(suffix);
    }

    session.input_manager.set_content(new_input.clone());
    session
        .input_manager
        .set_cursor(cursor_position.min(new_input.len()));
    session.mark_dirty();
}

pub(super) fn apply_selected_slash_suggestion(session: &mut Session) -> bool {
    let Some(command) = session.slash_palette.selected_command() else {
        return false;
    };

    let command_name = command.name.to_owned();

    let input_content = session.input_manager.content();
    let cursor_pos = session.input_manager.cursor();
    let Some(range) = command_range(input_content, cursor_pos) else {
        return false;
    };

    let suffix = input_content[range.end..].to_owned();
    let mut new_input = format!("/{}", command_name);

    let cursor_position = if suffix.is_empty() {
        new_input.push(' ');
        new_input.len()
    } else {
        if !suffix.chars().next().is_some_and(char::is_whitespace) {
            new_input.push(' ');
        }
        let position = new_input.len();
        new_input.push_str(&suffix);
        position
    };

    session.input_manager.set_content(new_input);
    session.input_manager.set_cursor(cursor_position);

    clear_slash_suggestions(session);
    session.mark_dirty();

    true
}

pub(super) fn autocomplete_slash_suggestion(session: &mut Session) -> bool {
    let input_content = session.input_manager.content();
    let cursor_pos = session.input_manager.cursor();

    let Some(range) = command_range(input_content, cursor_pos) else {
        return false;
    };

    let prefix_text = command_prefix(input_content, cursor_pos).unwrap_or_default();

    if prefix_text.is_empty() {
        return false;
    }

    let suggestions = session.slash_palette.suggestions();
    if suggestions.is_empty() {
        return false;
    }

    // Find the best fuzzy match from all suggestions
    let mut best_match: Option<(usize, u32, String)> = None;

    for (idx, suggestion) in suggestions.iter().enumerate() {
        let command_name = match suggestion {
            slash_palette::SlashPaletteSuggestion::Static(cmd) => cmd.name.to_string(),
        };

        if let Some(score) = fuzzy_score(&prefix_text, &command_name) {
            if let Some((_, best_score, _)) = &best_match {
                if score > *best_score {
                    best_match = Some((idx, score, command_name));
                }
            } else {
                best_match = Some((idx, score, command_name));
            }
        }
    }

    let Some((_, _, best_command)) = best_match else {
        return false;
    };

    // Handle static command
    let suffix = &input_content[range.end..];
    let mut new_input = format!("/{}", best_command);

    let cursor_position = if suffix.is_empty() {
        new_input.push(' ');
        new_input.len()
    } else {
        if !suffix.chars().next().is_some_and(char::is_whitespace) {
            new_input.push(' ');
        }
        let position = new_input.len();
        new_input.push_str(suffix);
        position
    };

    session.input_manager.set_content(new_input);
    session.input_manager.set_cursor(cursor_position);

    clear_slash_suggestions(session);
    session.mark_dirty();
    true
}

pub(super) fn try_handle_slash_navigation(
    session: &mut Session,
    key: &KeyEvent,
    has_control: bool,
    has_alt: bool,
    has_command: bool,
) -> bool {
    if !slash_navigation_available(session) {
        return false;
    }

    // Block Control modifier
    if has_control {
        return false;
    }

    // Block Alt unless combined with Command for Up/Down navigation
    if has_alt && !matches!(key.code, KeyCode::Up | KeyCode::Down) {
        return false;
    }

    let handled = match key.code {
        KeyCode::Up => {
            if has_alt && !has_command {
                return false;
            }
            if has_command {
                select_first_slash_suggestion(session)
            } else {
                move_slash_selection_up(session)
            }
        }
        KeyCode::Down => {
            if has_alt && !has_command {
                return false;
            }
            if has_command {
                select_last_slash_suggestion(session)
            } else {
                move_slash_selection_down(session)
            }
        }
        KeyCode::PageUp => page_up_slash_suggestion(session),
        KeyCode::PageDown => page_down_slash_suggestion(session),
        KeyCode::Tab => autocomplete_slash_suggestion(session),
        KeyCode::BackTab => move_slash_selection_up(session),
        KeyCode::Enter => {
            let applied = apply_selected_slash_suggestion(session);
            if !applied {
                return false;
            }

            let should_submit_now = should_submit_immediately_from_palette(session);

            if should_submit_now {
                return false;
            }

            true
        }
        _ => return false,
    };

    if handled {
        session.mark_dirty();
    }

    handled
}

fn should_submit_immediately_from_palette(session: &Session) -> bool {
    let Some(command) = session.input_manager.content().split_whitespace().next() else {
        return false;
    };

    matches!(
        command,
        "/files"
            | "/status"
            | "/doctor"
            | "/model"
            | "/new"
            | "/git"
            | "/docs"
            | "/copy"
            | "/config"
            | "/settings"
            | "/help"
            | "/clear"
            | "/history"
            | "/exit"
    )
}

#[derive(Clone)]
struct SlashRow {
    name: String,
    description: String,
}

fn slash_rows(session: &Session) -> Vec<SlashRow> {
    session
        .slash_palette
        .suggestions()
        .iter()
        .map(|suggestion| match suggestion {
            slash_palette::SlashPaletteSuggestion::Static(command) => SlashRow {
                name: command.name.to_owned(),
                description: command.description.to_owned(),
            },
        })
        .collect()
}

fn slash_highlight_style(session: &Session) -> Style {
    let mut style = Style::default().add_modifier(Modifier::REVERSED | Modifier::BOLD);
    if let Some(primary) = session.theme.primary.or(session.theme.secondary) {
        style = style.fg(ratatui_color_from_ansi(primary));
    }
    style
}

fn slash_name_style(session: &Session) -> Style {
    let style = InlineTextStyle::default()
        .bold()
        .with_color(session.theme.primary.or(session.theme.foreground));
    ratatui_style_from_inline(&style, session.theme.foreground)
}

fn slash_description_style(session: &Session) -> Style {
    session.styles.default_style().add_modifier(Modifier::DIM)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ui::tui::InlineTheme;

    #[test]
    fn immediate_submit_matcher_accepts_immediate_commands() {
        let mut session = Session::new(InlineTheme::default(), None, 20);
        session.set_input("/files".to_string());
        assert!(should_submit_immediately_from_palette(&session));

        session.set_input("   /status   ".to_string());
        assert!(should_submit_immediately_from_palette(&session));

        session.set_input("/history".to_string());
        assert!(should_submit_immediately_from_palette(&session));
    }

    #[test]
    fn immediate_submit_matcher_rejects_argument_driven_commands() {
        let mut session = Session::new(InlineTheme::default(), None, 20);
        session.set_input("/command echo hello".to_string());
        assert!(!should_submit_immediately_from_palette(&session));

        session.set_input("/add-dir ~/tmp".to_string());
        assert!(!should_submit_immediately_from_palette(&session));
    }
}