Files
luxe/crates/luxe-tui/src/question_prompt.rs
Evan Whittaker bf86df5098 luxe update and /update, editable question answers, and a version bump owed once per release
- luxe update and /update update Luxe with the command for however it was installed (cargo or
  Homebrew), run one program at a time with the terminal attached, then check that the luxe on
  PATH is the new version. Luxe never downloads or replaces its own binary. The start screen says
  "Update available · /update".
- A question's typed answer edits at its caret: arrows, word jumps, Home, End and Delete work,
  and up and down move through a wrapped answer before leaving it.
- The version check owes a bump once per release: the version on main is the next release, and
  only a released one (a v-tag) has to move.
- Dependency updates arrive through the sync, so Dependabot and the weekly jobs no longer run here.
2026-10-17 14:14:27 -05:00

188 lines
7.5 KiB
Rust

//! Interactive question modal — the picker shown above the composer when the agent asks a question.
//!
//! Mirrors the permission prompt's chrome (rounded panel, composer width, grows up from the input)
//! and the OpenCode `askquestion` UX: an options list with up/down + digit shortcuts, inline `[✓]`
//! checkboxes for multi-select (Space toggles), and a last option for typing your own answer,
//! numbered and checked like the rest so it reads as a choice rather than a hint. Typing anywhere
//! picks it. `Enter` submits, `Esc` cancels. Modal while open — stray keys never leak into the
//! composer.
//!
//! Each option can carry a one-line rationale and a `recommended` marker, so the choice explains
//! itself instead of making the reader infer it from a bare label. The cursor opens on the
//! recommendation, which makes `Enter` the sensible default rather than the first-listed one.
use crate::glyphs::Icon;
use ratatui::text::{Line, Span};
/// Rows one option's rationale may occupy before it is clipped.
const MAX_DESCRIPTION_ROWS: usize = 2;
/// Rows the question itself may occupy — a clipped question is unanswerable.
const MAX_PROMPT_ROWS: usize = 3;
/// Rows a typed answer may occupy before the row starts following the caret.
///
/// It wraps rather than truncating, because an answer you cannot see is one you cannot check — but
/// the growth is bounded twice over: the panel grows upward into the transcript, and a chosen row
/// is one slab, whose cut steps in once per line and so can only carry as many lines as the panel
/// reserved cells for. Past this the window scrolls with the caret instead.
const MAX_CUSTOM_ROWS: usize = MAX_DESCRIPTION_ROWS + 1;
/// The typed-answer option's label until something is typed into it.
const CUSTOM_PLACEHOLDER: &str = "Type your own answer";
/// The cells a panel spends on its border and inner padding, left and right.
const PANEL_FRAME: u16 = 4;
/// Narrowest column count worth wrapping a rationale into. Below this it shreds into fragments
/// that cost more attention than the label alone.
const MIN_DESCRIPTION_WIDTH: usize = 24;
/// Marker on the option the agent would pick, in the house ` word` badge form.
const RECOMMENDED_BADGE: &str = " recommended";
/// The panel's content, measured against the room it has above the composer.
struct PanelLayout {
prompt_rows: Vec<String>,
rows: Vec<LaidOutRow>,
/// Rows the panel will occupy, chrome included.
height: u16,
}
/// Cells the panel's content may occupy inside `width`.
fn inner_width(width: u16) -> usize {
usize::from(width.saturating_sub(PANEL_FRAME))
}
/// Rows the question panel will occupy above the composer.
///
/// The renderer's own measurement, so the rows the transcript stands down from are exactly the
/// rows the panel takes — anything less and the modal covers the output it is asking about.
pub fn height(
state: &QuestionPromptState,
theme: &crate::theme::styles::ThemeStyles,
width: u16,
available: u16,
) -> u16 {
if width == 0 {
return 0;
}
plan(state, theme, inner_width(width), available).height
}
/// Lay the panel out for `available` rows, giving up detail in the order a reader can spare it.
///
/// Options come first — an option you cannot see is a modal you cannot answer — so the rationale
/// goes first, then the typed answer's own rows down to the one it cannot do without, and the
/// question itself last (through [`prompt_budget`]). The attempts are a fixed list rather than a
/// loop that decides when to stop, so the worst case is a panel that spends everything it has.
fn plan(
state: &QuestionPromptState,
theme: &crate::theme::styles::ThemeStyles,
inner_width: usize,
available: u16,
) -> PanelLayout {
let lay = |with_descriptions, custom_rows| {
let rows = lay_out_rows(state, theme, inner_width, with_descriptions, custom_rows);
let prompt_rows = wrapped_rows(&state.prompt, inner_width, prompt_budget(available, &rows));
let height = desired_height(&prompt_rows, &rows);
PanelLayout { prompt_rows, rows, height }
};
let mut panel = lay(true, MAX_CUSTOM_ROWS);
for custom_rows in (1..=MAX_CUSTOM_ROWS).rev() {
if panel.height <= available {
break;
}
panel = lay(false, custom_rows);
}
PanelLayout { height: panel.height.min(available), ..panel }
}
/// Render the question modal directly above the input, matching the permission prompt's chrome.
pub fn render_question_prompt(
f: &mut ratatui::Frame,
region: ratatui::layout::Rect,
input_top: u16,
state: &QuestionPromptState,
theme: &crate::theme::styles::ThemeStyles,
hit: &std::cell::RefCell<crate::mouse::HitRegions>,
) {
use ratatui::{
layout::Rect,
style::Modifier,
widgets::{Clear, Padding, Paragraph},
};
let available = input_top.saturating_sub(region.y);
let inner_width = inner_width(region.width);
let PanelLayout { prompt_rows, rows, height } = plan(state, theme, inner_width, available);
if region.width == 0 || height == 0 {
return;
}
let area = Rect::new(region.x, input_top.saturating_sub(height), region.width, height);
f.render_widget(Clear, area);
let mut lines: Vec<Line> = Vec::new();
for row in &prompt_rows {
lines.push(Line::from(Span::styled(row.clone(), theme.text.add_modifier(Modifier::BOLD))));
}
lines.push(Line::from(""));
for row in &rows {
lines.extend(row.lines.iter().cloned());
}
let hint = if state.multi {
"enter submit · space toggle · ↑/↓ choose · esc cancel"
} else {
"enter answer · ↑/↓ choose · esc cancel"
};
let block = crate::widgets::titled_panel(Icon::Question.glyph(), "Question", theme)
.padding(Padding::new(1, 1, 1, 1));
let body = crate::widgets::render_footed(f, block, area, hint, None, theme);
f.render_widget(Paragraph::new(lines), body);
// Publish each row as a click target over the lines it actually occupies. Above the first:
// top border, top padding, the wrapped prompt, then a blank.
let mut regions = hit.borrow_mut();
let mut y = area.y.saturating_add(2 + prompt_rows.len() as u16 + 1);
for (i, row) in rows.iter().enumerate() {
let row_height = row.lines.len() as u16;
if y < area.y + area.height {
let visible = row_height.min(area.y + area.height - y);
regions.push(
Rect::new(area.x, y, area.width, visible),
crate::mouse::MouseTarget::QuestionRow(i),
);
}
y = y.saturating_add(row_height);
}
}
/// Panel height for a laid-out modal: content plus the blanks, borders, and padding around it.
fn desired_height(prompt_rows: &[String], rows: &[LaidOutRow]) -> u16 {
u16::try_from(chrome_and_rows(rows) + prompt_rows.len()).unwrap_or(u16::MAX)
}
/// Everything the panel owes before the question gets a line: the borders, the top padding, the
/// blank under the prompt, the option rows, and the footer, which takes the bottom padding's row.
fn chrome_and_rows(rows: &[LaidOutRow]) -> usize {
3 + 1
+ rows.iter().map(|row| row.lines.len()).sum::<usize>()
+ usize::from(crate::widgets::FOOTER_ROWS)
}
/// Rows the question may occupy once the options and chrome are paid for (always at least one).
fn prompt_budget(available: u16, rows: &[LaidOutRow]) -> usize {
usize::from(available).saturating_sub(chrome_and_rows(rows)).clamp(1, MAX_PROMPT_ROWS)
}
mod answer;
mod rows;
mod state;
use rows::{lay_out_rows, wrapped_rows, LaidOutRow};
pub use state::*;
#[cfg(test)]
mod tests;