Skip to main content

infinity_agent_cli/
session_picker.rs

1use crate::component::{Component, KeyResult, is_cancel};
2use infinity_protocol::{SessionInfo, SessionStatus};
3use ratatui::{
4    buffer::Buffer,
5    crossterm::event::{KeyCode, KeyEvent},
6    layout::Rect,
7    style::{Color, Modifier, Style},
8    widgets::Widget,
9};
10
11pub const MAX_VISIBLE_ROWS: u16 = 5;
12
13pub enum SessionPickerResult {
14    /// User selected a session (id).
15    Selected(infinity_protocol::ThreadRef),
16    Cancelled,
17}
18
19pub struct SessionPicker {
20    pub sessions: Vec<(infinity_protocol::ThreadRef, SessionInfo)>,
21    pub selected: usize,
22    scroll_offset: usize,
23    result: Option<SessionPickerResult>,
24    pub current_session_id: Option<infinity_protocol::ThreadRef>,
25}
26
27impl SessionPicker {
28    pub fn new(
29        sessions: Vec<(infinity_protocol::ThreadRef, SessionInfo)>,
30        current_session_id: Option<infinity_protocol::ThreadRef>,
31    ) -> Self {
32        let selected = current_session_id
33            .as_ref()
34            .and_then(|cid| sessions.iter().position(|s| &s.0 == cid))
35            .unwrap_or(0);
36        let scroll_offset = selected.saturating_sub(MAX_VISIBLE_ROWS as usize - 1);
37        Self {
38            sessions,
39            selected,
40            scroll_offset,
41            result: None,
42            current_session_id,
43        }
44    }
45
46    pub fn take_result(&mut self) -> Option<SessionPickerResult> {
47        self.result.take()
48    }
49
50    pub fn visible_rows(&self) -> u16 {
51        // Reserve one row for the "no sessions" placeholder when empty.
52        (self.sessions.len() as u16).clamp(1, MAX_VISIBLE_ROWS)
53    }
54
55    pub fn preferred_height(&self) -> u16 {
56        self.visible_rows() + 1
57    }
58
59    fn move_up(&mut self) {
60        if self.selected > 0 {
61            self.selected -= 1;
62            if self.selected < self.scroll_offset {
63                self.scroll_offset = self.selected;
64            }
65        }
66    }
67
68    fn move_down(&mut self) {
69        if self.selected + 1 < self.sessions.len() {
70            self.selected += 1;
71            let visible = MAX_VISIBLE_ROWS as usize;
72            if self.selected >= self.scroll_offset + visible {
73                self.scroll_offset = self.selected + 1 - visible;
74            }
75        }
76    }
77
78    fn confirm(&mut self) {
79        if let Some((id, _)) = self.sessions.get(self.selected) {
80            self.result = Some(SessionPickerResult::Selected(id.clone()));
81        } else if self.sessions.is_empty() {
82            // Nothing to select — treat Enter as dismissal.
83            self.result = Some(SessionPickerResult::Cancelled);
84        }
85    }
86
87    fn cancel(&mut self) {
88        self.result = Some(SessionPickerResult::Cancelled);
89    }
90
91    pub fn render(&self, area: Rect, buf: &mut Buffer) {
92        if area.height == 0 || area.width == 0 {
93            return;
94        }
95        if self.sessions.is_empty() {
96            let msg = " No sessions to load — press esc to dismiss and start a new one.";
97            for (col, ch) in msg.chars().enumerate() {
98                let x = area.x + col as u16;
99                if x >= area.right() {
100                    break;
101                }
102                buf[(x, area.y)]
103                    .set_char(ch)
104                    .set_fg(Color::DarkGray)
105                    .set_style(Style::default().add_modifier(Modifier::ITALIC));
106            }
107            return;
108        }
109        let visible = self.visible_rows() as usize;
110        let end = (self.scroll_offset + visible).min(self.sessions.len());
111
112        // Compute dynamic name column width from available area
113        // Fixed parts: 1 (leading space) + 1 (gap) + (status) + 1 (gap) + 10 (tokens) + 2 (gap) = 15 + (status), plus time
114        let fixed_parts = 15 + "waiting for choice".len();
115        let max_time_len = self.sessions[self.scroll_offset..end]
116            .iter()
117            .map(|(_, info)| info.last_updated.len())
118            .max()
119            .unwrap_or(0);
120        let name_width = (area.width as usize)
121            .saturating_sub(fixed_parts + max_time_len)
122            .max(8);
123
124        for (i, (id, info)) in self.sessions[self.scroll_offset..end].iter().enumerate() {
125            let y = area.y + i as u16;
126            if y >= area.bottom() {
127                break;
128            }
129
130            let is_selected = self.scroll_offset + i == self.selected;
131            let (fg, bg, modifier) = if is_selected {
132                (Color::Black, Color::White, Modifier::BOLD)
133            } else {
134                (Color::DarkGray, Color::Reset, Modifier::empty())
135            };
136
137            let is_current = self.current_session_id.as_ref() == Some(id);
138            let current_suffix = if is_current { " (current)" } else { "" };
139            let suffix_len = current_suffix.len();
140            let remote_label = info
141                .remote
142                .as_ref()
143                .map(|r| format!(" [{}]", r))
144                .unwrap_or_default();
145            let remote_len = remote_label.len();
146            let extra_len = suffix_len + remote_len;
147
148            let name = if let Some(ref title) = info.title {
149                if title.len() + extra_len > name_width {
150                    let trunc = name_width.saturating_sub(extra_len + 1);
151                    format!("{}…{}{}", &title[..trunc], remote_label, current_suffix)
152                } else {
153                    format!("{}{}{}", title, remote_label, current_suffix)
154                }
155            } else {
156                let id = id.to_string();
157                if id.len() + extra_len > name_width {
158                    let trunc = name_width.saturating_sub(extra_len + 1);
159                    format!("{}…{}{}", &id[..trunc], remote_label, current_suffix)
160                } else {
161                    format!("{}{}{}", id, remote_label, current_suffix)
162                }
163            };
164            // Column ranges for the "(current)" and "[remote]" labels (1 for leading space)
165            let name_char_len = name.chars().count();
166            let current_label_start = 1 + name_char_len - suffix_len;
167            let current_label_end = 1 + name_char_len;
168            let remote_label_start = current_label_start - remote_len;
169            let remote_label_end = current_label_start;
170
171            let status_str = match info.status {
172                SessionStatus::Running => "running",
173                SessionStatus::Idle => "idle",
174                SessionStatus::Stopped => "stopped",
175                SessionStatus::WaitingForChoice => "waiting for choice",
176                SessionStatus::Migrating => "migrating",
177                SessionStatus::Archived => "archived",
178            };
179            let status_fg = match info.status {
180                SessionStatus::Running => Color::Green,
181                SessionStatus::Idle => Color::Yellow,
182                SessionStatus::Stopped => Color::DarkGray,
183                SessionStatus::WaitingForChoice => Color::Magenta,
184                SessionStatus::Migrating => Color::Cyan,
185                SessionStatus::Archived => Color::DarkGray,
186            };
187            let time_str = &info.last_updated;
188            let tokens_str = format!("{}tok", info.total_tokens_used);
189            let status_start = 1 + name_width + 1;
190            let status_width = "waiting for choice".len();
191            let status_end = status_start + status_width;
192            let line = format!(
193                " {:<name_width$} {:>status_width$} {:>10}  {}",
194                name, status_str, tokens_str, time_str,
195            );
196
197            for x in area.x..area.right() {
198                buf[(x, y)].set_char(' ').set_bg(bg);
199            }
200            for (col, ch) in line.chars().enumerate() {
201                let x = area.x + col as u16;
202                if x >= area.right() {
203                    break;
204                }
205                let char_fg = if col >= status_start && col < status_end {
206                    status_fg
207                } else if !is_selected
208                    && col >= remote_label_start
209                    && col < remote_label_end
210                    && info.remote.is_some()
211                {
212                    Color::Blue
213                } else if is_current
214                    && !is_selected
215                    && col >= current_label_start
216                    && col < current_label_end
217                {
218                    Color::Cyan
219                } else {
220                    fg
221                };
222                buf[(x, y)]
223                    .set_char(ch)
224                    .set_fg(char_fg)
225                    .set_bg(bg)
226                    .set_style(Style::default().add_modifier(modifier));
227            }
228        }
229    }
230}
231
232impl Component for SessionPicker {
233    fn handle_keystroke(&mut self, key: KeyEvent) -> KeyResult {
234        match key.code {
235            KeyCode::Up => {
236                self.move_up();
237                KeyResult::Captured
238            }
239            KeyCode::Down => {
240                self.move_down();
241                KeyResult::Captured
242            }
243            KeyCode::Enter => {
244                self.confirm();
245                KeyResult::Captured
246            }
247            _ if is_cancel(&key) => {
248                self.cancel();
249                KeyResult::Captured
250            }
251            _ => KeyResult::Captured,
252        }
253    }
254}
255
256pub struct SessionPickerWidget<'a> {
257    picker: &'a SessionPicker,
258}
259
260impl<'a> SessionPickerWidget<'a> {
261    pub fn new(picker: &'a SessionPicker) -> Self {
262        Self { picker }
263    }
264}
265
266impl<'a> Widget for SessionPickerWidget<'a> {
267    fn render(self, area: Rect, buf: &mut Buffer) {
268        self.picker.render(area, buf);
269    }
270}