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