Struct TermUi 

pub struct TermUi {
    pub(crate) term: Option<DefaultTerminal>,
    pub(crate) events: EventStream,
    pub(crate) agents: UiAgents,
    pub(crate) input_area: TextArea<'static>,
    pub(crate) queued_prompts: VecDeque<String>,
    pub(crate) processing: bool,
    pub(crate) pending_permissions: VecDeque<(String, Sender<Result<(), String>>)>,
    pub(crate) app_name: String,
    pub(crate) creation: Instant,
}

UI state for WorkBuddy

Fields

term: Option<DefaultTerminal>

ratatui terminal object

Always set, except during rendering, because for some reason ratatui needs ownership access to this. (Well, “for some reason” is that it found it clever to have a term.do(|x| ...) pattern for rendering, so if we want access to self in that callback, we cannot have term stored here.)

events: EventStream

Produces terminal events, asynchronously

agents: UiAgents

All agents currently running

input_area: TextArea<'static>

User message input widget

queued_prompts: VecDeque<String>

Messages that are queued for sending

processing: bool

Whether a prompt iteration is currently being processed (from PromptSubmitted until AwaitingPrompt); the input title is not bolded while processing

pending_permissions: VecDeque<(String, Sender<Result<(), String>>)>

Tool calls awaiting a permission decision from the user, oldest first.

Only the first one is shown; the rest wait their turn.

app_name: String

The application name to use e.g. for notifications

creation: Instant

When the object was created, purely for visual purposes

Implementations

impl TermUi

pub fn new( app_name: &str, agent: &Agent, chat_history: Arc<Mutex<ChatHistory>>, ) -> Self

Create the term state with chat_history, for agent, with the application name app_name (e.g. for notifications).

pub fn draw(&mut self) -> Result<()>

Render the current state to screen

pub(crate) fn scroll_up(&mut self, lines: usize)

Scroll the active view up by the given number of lines.

pub(crate) fn scroll_down(&mut self, lines: usize)

Scroll the active view down by the given number of lines.

pub(crate) fn handle_key_event( &mut self, event: KeyEvent, ) -> Result<Option<Event>>

Handle the given keyboard event.

pub(crate) fn handle_mouse_event( &mut self, event: MouseEvent, ) -> Result<Option<Event>>

Handle the given mouse event.

pub(crate) fn handle_paste_event( &mut self, text: String, ) -> Result<Option<Event>>

Handle clipboard pasting.

pub(crate) fn input_block(processing: bool) -> Block<'static>

The input field’s block: the title is bolded while the agent awaits a prompt, and not bolded while a request is being processed.

pub(crate) fn send_osc99_notification(&self, title: &str, body: Option<&str>)

Send a terminal (OSC 99) notification with the given title and optional body.

Under tmux (detected via $TERM) the OSC 99 messages are wrapped in tmux’s passthrough envelope (which requires allow-passthrough on); otherwise the messages are sent bare.

The title and body are trimmed, and newlines, tabs, semicolons and other ASCII control characters are replaced or dropped, since they would corrupt the OSC 99 payload; both are truncated to 200 characters.

pub(crate) fn notify_prompt_done(&self, response: Option<String>)

Raise a terminal notification that the response is ready and the agent is awaiting a new prompt.

pub(crate) fn render(&mut self, frame: &mut Frame<'_>)

Render the current state onto the screen.

pub(crate) fn render_permission_popup( frame: &mut Frame<'_>, area: Rect, prompt: &str, )

Render the given permission request as a popup centered on the screen, on top of the main layout.

The popup is 80% of the terminal’s width (at most) and as tall as its wrapped prompt requires (at most the terminal’s height), and clears the area it covers, so that nothing from the main layout shows through.

Trait Implementations

impl Drop for TermUi

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl UiState for TermUi

async fn get_event(&mut self) -> Result<Event>

Handle input on the terminal, and redraw

type Error = Error

Error type for the implementing struct.

fn notify(&mut self, notification: Notification) -> Result<()>

Notify the UI about something.