//! Pending tray — mid-turn requests parked above the composer. //! //! A steer, a queued follow-up or a review asked for mid-turn is not part of the conversation yet, //! so it does not go in the //! transcript: dropped there it would land wherever the stream happened to be, then scroll away //! under the turn's own output while the user is still waiting on it. It sits here instead, //! pinned to the composer and deliberately quiet, until one of three things happens to it: the turn //! takes it in (a steer's row retires as the engine commits it — see //! [`crate::app::App::retire_steering`]), [`crate::app::App::promote_next_queued`] promotes a //! follow-up into a turn of its own, or the reader takes it back to edit //! ([`crate::app::App::restore_pending`], which the strip's own hint row advertises). use crate::app::{App, MidTurnDelivery, PendingSubmission}; use crate::glyphs::Icon; use crate::theme::styles::ThemeStyles; use ratatui::{ layout::Rect, text::{Line, Span}, widgets::Paragraph, Frame, }; /// Held submissions listed before the rest collapse into a count. const MAX_VISIBLE: usize = 4; /// Rows the tray needs, or 0 when nothing is held. /// /// One row per submission plus a leading blank, so the strip separates from the activity row /// above it instead of reading as one dense block above the prompt. pub(super) fn height(app: &App) -> u16 { let held = app.pending_submissions.len(); let review = usize::from(app.review.queued.is_some()); if held == 0 && review == 0 { return 0; } let listed = held.min(MAX_VISIBLE); let overflow = usize::from(held > MAX_VISIBLE); let hint = usize::from(recall_hint(app).is_some()); (listed + overflow + hint + review + 1) as u16 } /// `Alt+Up to edit it` — the one thing a reader cannot discover from the tray itself. /// /// Reads the chord out of the key map rather than naming a default, so a rebound (or unbound) key /// never leaves the strip advertising something that does nothing. Suppressed by /// `show_key_hints: false`, which is what that setting is for. fn recall_hint(app: &App) -> Option { if !app.config.show_key_hints.unwrap_or(true) { return None; } // Nothing to recall, nothing to say. The strip also carries a queued review, which is not a // message and cannot be edited — so without this the offer to edit "them" appears over a row // that is only reporting that a review finished capturing. if app.pending_submissions.is_empty() { return None; } let chord = app .keymap .chords_for(luxe_core::keymap::UiAction::DequeueMessages) .and_then(|chords| chords.first())?; let subject = if app.pending_submissions.len() == 1 { "it" } else { "them" }; Some(format!(" {chord} to edit {subject} here")) } /// Draws the held submissions, newest last, in the strip directly above the composer. pub(super) fn render(f: &mut Frame, area: Rect, app: &App) { if area.height == 0 || (app.pending_submissions.is_empty() && app.review.queued.is_none()) { return; } let styles = &app.theme_styles; let width = usize::from(area.width); let mut lines = vec![Line::default()]; // Queue positions are the order they will run in, counted as we go: derived from the list // rather than stored, so promoting one can't leave a stale number behind. let mut position = 0usize; for held in app.pending_submissions.iter() { if held.delivery == MidTurnDelivery::Queue { position += 1; } if lines.len() > MAX_VISIBLE { continue; } lines.push(submission_line(held, position, width, styles)); } let hidden = app.pending_submissions.len().saturating_sub(MAX_VISIBLE); if hidden > 0 { lines.push(Line::from(Span::styled(format!(" +{hidden} more waiting"), styles.muted))); } if let Some(hint) = recall_hint(app) { lines.push(Line::from(Span::styled(hint, styles.dim))); } if let Some(queued) = app.review.queued.as_ref() { lines.push(queued_review_line(app, queued, styles)); } f.render_widget(Paragraph::new(lines), area); } /// The queued review's row: what it is waiting for, then what to press when it stops waiting. /// /// Same shape as a steer's row because it is the same kind of promise — something asked for that /// has not happened yet — and the same reason for living here rather than in the transcript: it /// would scroll away under the output of the very turn it is waiting on. fn queued_review_line( app: &App, queued: &crate::app::QueuedReview, styles: &ThemeStyles, ) -> Line<'static> { use crate::app::QueuedReviewState; let (glyph, label, detail, detail_style) = match queued.state { QueuedReviewState::Waiting => ( Icon::Queued.glyph().to_string(), "review queued", "starts when this turn ends".to_owned(), styles.muted, ), // A spinner, not the queued glyph: work is happening in both of these, and a pause-shaped // mark over it says the opposite of what is true. Each says what the work is, because // "capturing" for a minute while a model writes reads as a hang QueuedReviewState::Capturing => ( crate::statusline::spinner(app.status.spinner_frame).to_string(), "review", capture_label(&queued.target), styles.muted, ), // The long part, so it names who is doing it and counts: a number that keeps moving is // what tells a reader the wait is progress rather than a stall QueuedReviewState::Writing { since } => ( crate::statusline::spinner(app.status.spinner_frame).to_string(), "review", format!( "{} is writing the guide \u{b7} {}", match app.status.model.trim() { "" => "the model", model => model, }, crate::statusline::format_elapsed_compact( app.frame_now().saturating_duration_since(since) ) ), styles.muted, ), QueuedReviewState::Ready => ( Icon::Findings.glyph().to_string(), "review ready", match app .keymap .chords_for(luxe_core::keymap::UiAction::ReviewOpen) .and_then(|chords| chords.first()) { // The chord alone. The row already says the review is ready, and the only thing // anyone does with a ready review is open it. Some(chord) => chord.to_string(), None => "open it from the palette".to_owned(), }, styles.success, ), }; let marker_style = if queued.state == QueuedReviewState::Ready { styles.success } else { styles.warning }; Line::from(vec![ Span::raw(" "), Span::styled(crate::glyphs::icon_prefix(&glyph), marker_style), Span::styled(label, styles.muted), Span::styled(" \u{b7} ".to_string(), styles.muted), Span::styled(detail, detail_style), ]) } /// What a capture is doing, named by its source. fn capture_label(target: &luxe_core::guided_review::ReviewTarget) -> String { use luxe_core::guided_review::ReviewTarget; match target { ReviewTarget::WorkingTree => "capturing the working tree".into(), ReviewTarget::LastTurn { .. } => "capturing the last turn".into(), ReviewTarget::Base { reference } => format!("capturing the change since {reference}"), ReviewTarget::Commit { oid } => { format!("capturing commit {}", oid.chars().take(12).collect::()) } ReviewTarget::PullRequest { number, .. } => format!("fetching pull request #{number}"), ReviewTarget::OwnPullRequest { number } => { format!("reading pull request #{number} and its threads") } } } /// `→ steering · ` on one row: the state first so the column scans, the message after it /// so the row is still recognizable as the thing the user typed. fn submission_line( held: &PendingSubmission, position: usize, width: usize, styles: &ThemeStyles, ) -> Line<'static> { let (glyph, label) = match held.delivery { MidTurnDelivery::Steer => (Icon::Steering.glyph(), "steering".to_string()), MidTurnDelivery::Queue => (Icon::Queued.glyph(), format!("queued #{position}")), }; // Muted throughout, including the marker: nothing here has happened yet, and the transcript's // accent-on-band user messages are the ones that have. let mut spans = vec![ Span::raw(" "), Span::styled(crate::glyphs::icon_prefix(glyph), styles.warning), Span::styled(label.clone(), styles.muted), ]; let used = 1 + crate::glyphs::icon_cells(glyph) + crate::selection::cell_width(&label); let room = width.saturating_sub(used + 3); let preview = preview_text(&held.display, room); if !preview.is_empty() { spans.push(Span::styled(" \u{b7} ".to_string(), styles.muted)); spans.push(Span::styled(preview, styles.muted)); } Line::from(spans) } /// The message flattened to one row: newlines become spaces, and an over-long draft is cut with /// an ellipsis so the tray height never depends on what was typed. fn preview_text(display: &str, room: usize) -> String { if room == 0 { return String::new(); } let flattened = display.split_whitespace().collect::>().join(" "); if crate::selection::cell_width(&flattened) <= room { return flattened; } let mut out = String::new(); let mut used = 0usize; for character in flattened.chars() { let cell = crate::selection::cell_width(&character.to_string()); if used + cell > room.saturating_sub(1) { break; } out.push(character); used += cell; } out.push('\u{2026}'); out } #[cfg(test)] mod tests;