Skip to main content

infinity_agent_cli/
model_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
10/// Models shown in the picker are described by the protocol's `ModelInfo`
11/// (provider id + model id + display metadata).
12pub use infinity_protocol::ModelInfo;
13
14/// Maximum visible rows in the model picker.
15pub const MAX_VISIBLE_ROWS: u16 = 5;
16
17/// Result of the model picker interaction.
18pub enum ModelPickerResult {
19    /// User selected a model (index into `available_models()`).
20    Selected(usize),
21    /// User cancelled (Escape).
22    Cancelled,
23}
24
25/// A scrollable model picker overlay.
26pub struct ModelPicker {
27    models: Vec<ModelInfo>,
28    /// Index of the currently highlighted model.
29    selected: usize,
30    /// Scroll offset for the visible window.
31    scroll_offset: usize,
32    /// Pending result to be consumed by the caller.
33    result: Option<ModelPickerResult>,
34}
35
36impl ModelPicker {
37    pub fn new(models: Vec<ModelInfo>) -> Self {
38        Self {
39            models,
40            selected: 0,
41            scroll_offset: 0,
42            result: None,
43        }
44    }
45
46    /// Take the pending result, if any.
47    pub fn take_result(&mut self) -> Option<ModelPickerResult> {
48        self.result.take()
49    }
50
51    /// The number of rows this picker wants to display (capped at MAX_VISIBLE_ROWS).
52    pub fn visible_rows(&self) -> u16 {
53        (self.models.len() as u16).min(MAX_VISIBLE_ROWS)
54    }
55
56    /// Total height including the top border row.
57    pub fn preferred_height(&self) -> u16 {
58        self.visible_rows() + 1 // +1 for border
59    }
60
61    fn move_up(&mut self) {
62        if self.selected > 0 {
63            self.selected -= 1;
64            if self.selected < self.scroll_offset {
65                self.scroll_offset = self.selected;
66            }
67        }
68    }
69
70    fn move_down(&mut self) {
71        if self.selected + 1 < self.models.len() {
72            self.selected += 1;
73            let visible = MAX_VISIBLE_ROWS as usize;
74            if self.selected >= self.scroll_offset + visible {
75                self.scroll_offset = self.selected + 1 - visible;
76            }
77        }
78    }
79
80    fn confirm(&mut self) {
81        if self.selected < self.models.len() {
82            self.result = Some(ModelPickerResult::Selected(self.selected));
83        }
84    }
85
86    fn cancel(&mut self) {
87        self.result = Some(ModelPickerResult::Cancelled);
88    }
89
90    /// Render the model list into the given area.
91    pub fn render(&self, area: Rect, buf: &mut Buffer) {
92        if area.height == 0 || area.width == 0 {
93            return;
94        }
95
96        let visible = self.visible_rows() as usize;
97        let end = (self.scroll_offset + visible).min(self.models.len());
98
99        for (i, model) in self.models[self.scroll_offset..end].iter().enumerate() {
100            let y = area.y + i as u16;
101            if y >= area.bottom() {
102                break;
103            }
104
105            let abs_idx = self.scroll_offset + i;
106            let is_selected = abs_idx == self.selected;
107
108            let (fg, bg, modifier) = if is_selected {
109                (Color::Black, Color::White, Modifier::BOLD)
110            } else {
111                (Color::DarkGray, Color::Reset, Modifier::empty())
112            };
113
114            let ctx_str = if model.context_window >= 1_000_000 {
115                format!("{}m ctx", model.context_window / 1_000_000)
116            } else {
117                format!("{}k ctx", model.context_window / 1_000)
118            };
119
120            let line = format!(
121                " {:<10} {:<24} {:>10}",
122                model.provider_id, model.display_name, ctx_str
123            );
124
125            // Fill the row background
126            for x in area.x..area.right() {
127                buf[(x, y)].set_char(' ').set_bg(bg);
128            }
129
130            // Write text
131            for (col, ch) in line.chars().enumerate() {
132                let x = area.x + col as u16;
133                if x >= area.right() {
134                    break;
135                }
136                buf[(x, y)]
137                    .set_char(ch)
138                    .set_fg(fg)
139                    .set_bg(bg)
140                    .set_style(Style::default().add_modifier(modifier));
141            }
142        }
143    }
144}
145
146impl Component for ModelPicker {
147    fn handle_keystroke(&mut self, key: KeyEvent) -> KeyResult {
148        match key.code {
149            KeyCode::Up => {
150                self.move_up();
151                KeyResult::Captured
152            }
153            KeyCode::Down => {
154                self.move_down();
155                KeyResult::Captured
156            }
157            KeyCode::Enter => {
158                self.confirm();
159                KeyResult::Captured
160            }
161            _ if is_cancel(&key) => {
162                self.cancel();
163                KeyResult::Captured
164            }
165            _ => KeyResult::Captured, // swallow all keys while picker is open
166        }
167    }
168}
169
170/// Widget adapter for rendering the ModelPicker.
171pub struct ModelPickerWidget<'a> {
172    picker: &'a ModelPicker,
173}
174
175impl<'a> ModelPickerWidget<'a> {
176    pub fn new(picker: &'a ModelPicker) -> Self {
177        Self { picker }
178    }
179}
180
181impl<'a> Widget for ModelPickerWidget<'a> {
182    fn render(self, area: Rect, buf: &mut Buffer) {
183        self.picker.render(area, buf);
184    }
185}