rho-coding-agent 1.48.0

A lightweight agent harness inspired by Pi
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! Who owns the full terminal: setup, in-place attach, or the session.
//!
//! This is stored state, not a query over sibling flags. Setup and attach both
//! replace session chrome. Only attach swallows input; setup still types into
//! its composer pickers.

use std::time::Instant;

use crossterm::event::Event;
use ratatui::Frame;

use super::{attachment::AttachmentApp, setup_screen::SetupStep, App};

/// Foreground occupant of the interactive TUI.
pub(super) enum ExclusiveOccupant {
    Session,
    Setup(SetupStep),
    Attach {
        view: Box<AttachmentApp>,
        parent_turn_armed: bool,
    },
}

impl ExclusiveOccupant {
    pub(super) fn setup_step(&self) -> Option<SetupStep> {
        match self {
            Self::Setup(step) => Some(*step),
            Self::Session | Self::Attach { .. } => None,
        }
    }

    pub(super) fn wants_journal_ticks(&self) -> bool {
        matches!(self, Self::Attach { .. })
    }

    pub(super) fn parent_turn_armed(&self) -> Option<bool> {
        match self {
            Self::Attach {
                parent_turn_armed, ..
            } => Some(*parent_turn_armed),
            Self::Session | Self::Setup(_) => None,
        }
    }

    pub(super) fn attach_view(&self) -> Option<&AttachmentApp> {
        match self {
            Self::Attach { view, .. } => Some(view),
            Self::Session | Self::Setup(_) => None,
        }
    }

    pub(super) fn attach_view_mut(&mut self) -> Option<&mut AttachmentApp> {
        match self {
            Self::Attach { view, .. } => Some(view),
            Self::Session | Self::Setup(_) => None,
        }
    }
}

impl App {
    pub(super) fn draw_exclusive_screen(&mut self, frame: &mut Frame<'_>) -> bool {
        match self.exclusive {
            ExclusiveOccupant::Setup(step) => {
                let area = frame.area();
                self.draw_setup_screen(frame, area, step);
                true
            }
            ExclusiveOccupant::Attach { .. } => self.draw_attach_screen(frame),
            ExclusiveOccupant::Session => false,
        }
    }

    /// Consume a terminal event when the occupant owns the keyboard.
    ///
    /// Setup is exclusive paint only, so its events are returned for the
    /// composer. Attach consumes every event and reports whether it was a resize.
    pub(super) fn take_exclusive_event(&mut self, event: Event) -> Result<bool, Event> {
        match self.exclusive {
            ExclusiveOccupant::Attach { .. } => Ok(self.route_attach_event(event)),
            ExclusiveOccupant::Setup(_) | ExclusiveOccupant::Session => Err(event),
        }
    }

    pub(super) fn exclusive_should_redraw(&self, now: Instant) -> bool {
        self.exclusive
            .attach_view()
            .is_some_and(|view| view.should_redraw(now))
    }

    pub(super) fn refresh_exclusive_screen(&mut self) -> anyhow::Result<bool> {
        let Some(view) = self.exclusive.attach_view_mut() else {
            return Ok(false);
        };
        let changed = view.refresh()?;
        Ok(changed || view.should_redraw(Instant::now()))
    }
}