infinity-agent-cli 0.2.0

Terminal client for Infinity coding agents.
Documentation
use crate::component::{Component, KeyResult, is_cancel};
use infinity_protocol::{SessionInfo, SessionStatus};
use ratatui::{
    buffer::Buffer,
    crossterm::event::{KeyCode, KeyEvent},
    layout::Rect,
    style::{Color, Modifier, Style},
    widgets::Widget,
};

pub const MAX_VISIBLE_ROWS: u16 = 5;

pub enum SessionPickerResult {
    /// User selected a session (id).
    Selected(infinity_protocol::ThreadRef),
    Cancelled,
}

pub struct SessionPicker {
    pub sessions: Vec<(infinity_protocol::ThreadRef, SessionInfo)>,
    pub selected: usize,
    scroll_offset: usize,
    result: Option<SessionPickerResult>,
    pub current_session_id: Option<infinity_protocol::ThreadRef>,
}

impl SessionPicker {
    pub fn new(
        sessions: Vec<(infinity_protocol::ThreadRef, SessionInfo)>,
        current_session_id: Option<infinity_protocol::ThreadRef>,
    ) -> Self {
        let selected = current_session_id
            .as_ref()
            .and_then(|cid| sessions.iter().position(|s| &s.0 == cid))
            .unwrap_or(0);
        let scroll_offset = selected.saturating_sub(MAX_VISIBLE_ROWS as usize - 1);
        Self {
            sessions,
            selected,
            scroll_offset,
            result: None,
            current_session_id,
        }
    }

    pub fn take_result(&mut self) -> Option<SessionPickerResult> {
        self.result.take()
    }

    pub fn visible_rows(&self) -> u16 {
        // Reserve one row for the "no sessions" placeholder when empty.
        (self.sessions.len() as u16).clamp(1, MAX_VISIBLE_ROWS)
    }

    pub fn preferred_height(&self) -> u16 {
        self.visible_rows() + 1
    }

    fn move_up(&mut self) {
        if self.selected > 0 {
            self.selected -= 1;
            if self.selected < self.scroll_offset {
                self.scroll_offset = self.selected;
            }
        }
    }

    fn move_down(&mut self) {
        if self.selected + 1 < self.sessions.len() {
            self.selected += 1;
            let visible = MAX_VISIBLE_ROWS as usize;
            if self.selected >= self.scroll_offset + visible {
                self.scroll_offset = self.selected + 1 - visible;
            }
        }
    }

    fn confirm(&mut self) {
        if let Some((id, _)) = self.sessions.get(self.selected) {
            self.result = Some(SessionPickerResult::Selected(id.clone()));
        } else if self.sessions.is_empty() {
            // Nothing to select — treat Enter as dismissal.
            self.result = Some(SessionPickerResult::Cancelled);
        }
    }

    fn cancel(&mut self) {
        self.result = Some(SessionPickerResult::Cancelled);
    }

    pub fn render(&self, area: Rect, buf: &mut Buffer) {
        if area.height == 0 || area.width == 0 {
            return;
        }
        if self.sessions.is_empty() {
            let msg = " No sessions to load — press esc to dismiss and start a new one.";
            for (col, ch) in msg.chars().enumerate() {
                let x = area.x + col as u16;
                if x >= area.right() {
                    break;
                }
                buf[(x, area.y)]
                    .set_char(ch)
                    .set_fg(Color::DarkGray)
                    .set_style(Style::default().add_modifier(Modifier::ITALIC));
            }
            return;
        }
        let visible = self.visible_rows() as usize;
        let end = (self.scroll_offset + visible).min(self.sessions.len());

        // Compute dynamic name column width from available area
        // Fixed parts: 1 (leading space) + 1 (gap) + (status) + 1 (gap) + 10 (tokens) + 2 (gap) = 15 + (status), plus time
        let fixed_parts = 15 + "waiting for choice".len();
        let max_time_len = self.sessions[self.scroll_offset..end]
            .iter()
            .map(|(_, info)| info.last_updated.len())
            .max()
            .unwrap_or(0);
        let name_width = (area.width as usize)
            .saturating_sub(fixed_parts + max_time_len)
            .max(8);

        for (i, (id, info)) in self.sessions[self.scroll_offset..end].iter().enumerate() {
            let y = area.y + i as u16;
            if y >= area.bottom() {
                break;
            }

            let is_selected = self.scroll_offset + i == self.selected;
            let (fg, bg, modifier) = if is_selected {
                (Color::Black, Color::White, Modifier::BOLD)
            } else {
                (Color::DarkGray, Color::Reset, Modifier::empty())
            };

            let is_current = self.current_session_id.as_ref() == Some(id);
            let current_suffix = if is_current { " (current)" } else { "" };
            let suffix_len = current_suffix.len();
            let remote_label = info
                .remote
                .as_ref()
                .map(|r| format!(" [{}]", r))
                .unwrap_or_default();
            let remote_len = remote_label.len();
            let extra_len = suffix_len + remote_len;

            let name = if let Some(ref title) = info.title {
                if title.len() + extra_len > name_width {
                    let trunc = name_width.saturating_sub(extra_len + 1);
                    format!("{}…{}{}", &title[..trunc], remote_label, current_suffix)
                } else {
                    format!("{}{}{}", title, remote_label, current_suffix)
                }
            } else {
                let id = id.to_string();
                if id.len() + extra_len > name_width {
                    let trunc = name_width.saturating_sub(extra_len + 1);
                    format!("{}…{}{}", &id[..trunc], remote_label, current_suffix)
                } else {
                    format!("{}{}{}", id, remote_label, current_suffix)
                }
            };
            // Column ranges for the "(current)" and "[remote]" labels (1 for leading space)
            let name_char_len = name.chars().count();
            let current_label_start = 1 + name_char_len - suffix_len;
            let current_label_end = 1 + name_char_len;
            let remote_label_start = current_label_start - remote_len;
            let remote_label_end = current_label_start;

            let status_str = match info.status {
                SessionStatus::Running => "running",
                SessionStatus::Idle => "idle",
                SessionStatus::Stopped => "stopped",
                SessionStatus::WaitingForChoice => "waiting for choice",
                SessionStatus::Migrating => "migrating",
                SessionStatus::Archived => "archived",
            };
            let status_fg = match info.status {
                SessionStatus::Running => Color::Green,
                SessionStatus::Idle => Color::Yellow,
                SessionStatus::Stopped => Color::DarkGray,
                SessionStatus::WaitingForChoice => Color::Magenta,
                SessionStatus::Migrating => Color::Cyan,
                SessionStatus::Archived => Color::DarkGray,
            };
            let time_str = &info.last_updated;
            let tokens_str = format!("{}tok", info.total_tokens_used);
            let status_start = 1 + name_width + 1;
            let status_width = "waiting for choice".len();
            let status_end = status_start + status_width;
            let line = format!(
                " {:<name_width$} {:>status_width$} {:>10}  {}",
                name, status_str, tokens_str, time_str,
            );

            for x in area.x..area.right() {
                buf[(x, y)].set_char(' ').set_bg(bg);
            }
            for (col, ch) in line.chars().enumerate() {
                let x = area.x + col as u16;
                if x >= area.right() {
                    break;
                }
                let char_fg = if col >= status_start && col < status_end {
                    status_fg
                } else if !is_selected
                    && col >= remote_label_start
                    && col < remote_label_end
                    && info.remote.is_some()
                {
                    Color::Blue
                } else if is_current
                    && !is_selected
                    && col >= current_label_start
                    && col < current_label_end
                {
                    Color::Cyan
                } else {
                    fg
                };
                buf[(x, y)]
                    .set_char(ch)
                    .set_fg(char_fg)
                    .set_bg(bg)
                    .set_style(Style::default().add_modifier(modifier));
            }
        }
    }
}

impl Component for SessionPicker {
    fn handle_keystroke(&mut self, key: KeyEvent) -> KeyResult {
        match key.code {
            KeyCode::Up => {
                self.move_up();
                KeyResult::Captured
            }
            KeyCode::Down => {
                self.move_down();
                KeyResult::Captured
            }
            KeyCode::Enter => {
                self.confirm();
                KeyResult::Captured
            }
            _ if is_cancel(&key) => {
                self.cancel();
                KeyResult::Captured
            }
            _ => KeyResult::Captured,
        }
    }
}

pub struct SessionPickerWidget<'a> {
    picker: &'a SessionPicker,
}

impl<'a> SessionPickerWidget<'a> {
    pub fn new(picker: &'a SessionPicker) -> Self {
        Self { picker }
    }
}

impl<'a> Widget for SessionPickerWidget<'a> {
    fn render(self, area: Rect, buf: &mut Buffer) {
        self.picker.render(area, buf);
    }
}