Skip to main content

infinity_agent_cli/
choice_picker.rs

1use crate::component::{Component, KeyResult, is_cancel};
2use ratatui::{
3    buffer::Buffer,
4    crossterm::event::{KeyCode, KeyEvent},
5    layout::Rect,
6    style::{Color, Modifier, Style},
7    widgets::Widget,
8};
9
10pub enum ChoicePickerResult {
11    Selected(usize),
12}
13
14pub struct ChoicePicker {
15    pub prompt: String,
16    pub choices: Vec<String>,
17    pub default: usize,
18    pub selected: usize,
19    result: Option<ChoicePickerResult>,
20}
21
22impl ChoicePicker {
23    pub fn new(prompt: String, choices: Vec<String>, default: usize) -> Self {
24        Self {
25            selected: default,
26            prompt,
27            choices,
28            default,
29            result: None,
30        }
31    }
32
33    pub fn take_result(&mut self) -> Option<ChoicePickerResult> {
34        self.result.take()
35    }
36
37    pub fn preferred_height(&self) -> u16 {
38        1 + self.choices.len() as u16
39    }
40
41    pub fn render(&self, area: Rect, buf: &mut Buffer) {
42        if area.height == 0 || area.width == 0 {
43            return;
44        }
45
46        // Render prompt on first line
47        let prompt = format!(" {}", self.prompt);
48        for (col, ch) in prompt.chars().enumerate() {
49            let x = area.x + col as u16;
50            if x >= area.right() {
51                break;
52            }
53            buf[(x, area.y)]
54                .set_char(ch)
55                .set_fg(Color::Yellow)
56                .set_style(Style::default().add_modifier(Modifier::BOLD));
57        }
58
59        // Render choices
60        for (i, choice) in self.choices.iter().enumerate() {
61            let y = area.y + 1 + i as u16;
62            if y >= area.bottom() {
63                break;
64            }
65
66            let is_selected = i == self.selected;
67            let is_default = i == self.default;
68
69            let default_tag = if is_default { " (default)" } else { "" };
70            let marker = if is_selected { "▸" } else { " " };
71            let line = format!(" {} {}{}", marker, choice, default_tag);
72
73            let (fg, bg, modifier) = if is_selected {
74                (Color::Black, Color::White, Modifier::BOLD)
75            } else {
76                (Color::DarkGray, Color::Reset, Modifier::empty())
77            };
78
79            for x in area.x..area.right() {
80                buf[(x, y)].set_char(' ').set_bg(bg);
81            }
82            for (col, ch) in line.chars().enumerate() {
83                let x = area.x + col as u16;
84                if x >= area.right() {
85                    break;
86                }
87                buf[(x, y)]
88                    .set_char(ch)
89                    .set_fg(fg)
90                    .set_bg(bg)
91                    .set_style(Style::default().add_modifier(modifier));
92            }
93        }
94    }
95}
96
97impl Component for ChoicePicker {
98    fn handle_keystroke(&mut self, key: KeyEvent) -> KeyResult {
99        match key.code {
100            KeyCode::Up if self.selected > 0 => {
101                self.selected -= 1;
102            }
103            KeyCode::Down => {
104                if self.selected < self.choices.len().saturating_sub(1) {
105                    self.selected += 1;
106                } else {
107                    return KeyResult::NotCaptured;
108                }
109            }
110            KeyCode::Enter => {
111                self.result = Some(ChoicePickerResult::Selected(self.selected));
112            }
113            _ if is_cancel(&key) => {
114                self.result = Some(ChoicePickerResult::Selected(self.default));
115            }
116            _ => {}
117        }
118        KeyResult::Captured
119    }
120}
121
122pub struct ChoicePickerWidget<'a> {
123    picker: &'a ChoicePicker,
124}
125
126impl<'a> ChoicePickerWidget<'a> {
127    pub fn new(picker: &'a ChoicePicker) -> Self {
128        Self { picker }
129    }
130}
131
132impl<'a> Widget for ChoicePickerWidget<'a> {
133    fn render(self, area: Rect, buf: &mut Buffer) {
134        self.picker.render(area, buf);
135    }
136}