vtcode_tui/core_tui/session/

slash.rs

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

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

use super::super::types::InlineTextStyle;
use super::inline_list::{InlineListRow, selection_padding};
use super::list_panel::{
    SharedListPanelSections, SharedListPanelStyles, StaticRowsListPanelModel, fixed_section_rows,
    render_shared_list_panel, rows_to_u16, split_bottom_list_panel,
};
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.inline_lists_visible()
        || 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 info_rows = slash_palette_instructions(session).len();
    let has_search_row = command_prefix(
        session.input_manager.content(),
        session.input_manager.cursor(),
    )
    .is_some();
    let fixed_rows = fixed_section_rows(1, info_rows, has_search_row);
    let desired_list_rows = rows_to_u16(suggestions.len().min(ui::INLINE_LIST_MAX_ROWS));
    let (transcript_area, panel_area) =
        split_bottom_list_panel(area, fixed_rows, desired_list_rows);
    if panel_area.is_none() {
        session.slash_palette.clear_visible_rows();
        return (transcript_area, None);
    }
    (transcript_area, panel_area)
}

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.inline_lists_visible()
    {
        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 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 = selection_padding();

    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, offset) = {
        let list_state = session.slash_palette.list_state_mut();
        (
            list_state.selected().filter(|index| *index < item_count),
            list_state.offset(),
        )
    };
    let search_line = command_prefix(
        session.input_manager.content(),
        session.input_manager.cursor(),
    )
    .map(|prefix| {
        let filter = prefix.trim_start_matches('/');
        if filter.is_empty() {
            "Filter: (type to narrow commands)".to_owned()
        } else {
            format!("Filter: {}", filter)
        }
    });
    let sections = SharedListPanelSections {
        header: vec![Line::from(Span::styled(
            "Slash Commands".to_owned(),
            default_style,
        ))],
        info: slash_palette_instructions(session),
        search: search_line.map(|value| Line::from(Span::styled(value, default_style))),
    };
    let mut model = StaticRowsListPanelModel {
        rows: rendered_rows,
        selected,
        offset,
        visible_rows: 0,
    };
    render_shared_list_panel(
        frame,
        area,
        sections,
        SharedListPanelStyles {
            base_style: default_style,
            selected_style: Some(highlight_style),
            text_style: default_style,
        },
        &mut model,
    );

    session
        .slash_palette
        .set_visible_rows(model.visible_rows.min(ui::INLINE_LIST_MAX_ROWS));

    let list_state = session.slash_palette.list_state_mut();
    list_state.select(model.selected);
    *list_state.offset_mut() = model.offset;
}

fn slash_palette_instructions(session: &Session) -> Vec<Line<'static>> {
    vec![Line::from(Span::styled(
        "Navigation: ↑/↓ select • Enter apply • Esc dismiss".to_owned(),
        session.styles.default_style(),
    ))]
}

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;
    };
    session.ensure_inline_lists_visible_for_trigger();

    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.inline_lists_visible()
        && !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"
            | "/mcp"
            | "/skills"
            | "/new"
            | "/git"
            | "/docs"
            | "/copy"
            | "/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));

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

        session.set_input("/skills".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));
    }

    #[test]
    fn slash_palette_instructions_hide_filter_hint_row() {
        let session = Session::new(InlineTheme::default(), None, 20);
        let instructions = slash_palette_instructions(&session);

        assert_eq!(instructions.len(), 1);
        let text: String = instructions[0]
            .spans
            .iter()
            .map(|span| span.content.clone().into_owned())
            .collect();
        assert!(text.contains("Navigation:"));
        assert!(!text.contains("Type to filter slash commands"));
    }
}