Initial public release
Luxe 0.1.0: a coding agent harness for the terminal. See README.md to get started and CHANGELOG.md for releases.
This commit is contained in:
425
crates/luxe-tui/src/guided_review.rs
Normal file
425
crates/luxe-tui/src/guided_review.rs
Normal file
@@ -0,0 +1,425 @@
|
||||
//! Guided Review surface state — route-local loading and the reviewer's one position.
|
||||
//!
|
||||
//! The pinned review data stays on [`crate::app::App`], while this module owns only the
|
||||
//! full-screen surface state needed to present it. That keeps an in-flight refresh from
|
||||
//! replacing the immutable revision still visible to the reviewer.
|
||||
//!
|
||||
//! # One selection, no focus
|
||||
//!
|
||||
//! The surface is two panes — the guide and the evidence under it — and exactly one of them takes
|
||||
//! input. `ReviewPosition` *is* the cursor: the keyboard moves it, the detail pane shows whatever
|
||||
//! it lands on, and the guide pane follows it. There is no focus owner and no second selection,
|
||||
//! which is why every key means one thing here. A mode switch and a focus switch would be state a
|
||||
//! key could be routed on wrongly — `Enter` dead in the whole view, `↑`/`↓` never reaching the
|
||||
//! surface that needed them — and with one cursor neither is expressible.
|
||||
|
||||
pub(crate) mod diff;
|
||||
mod findings;
|
||||
mod fold;
|
||||
mod geometry;
|
||||
mod navigation;
|
||||
pub(crate) mod preview_guard;
|
||||
mod progress;
|
||||
mod source;
|
||||
mod source_picker;
|
||||
pub mod state;
|
||||
mod viewport;
|
||||
|
||||
pub use fold::{
|
||||
has_mechanical_churn, hunk_row_span, is_mechanical, mechanical_label, visible_groups, Fold,
|
||||
FoldedRun, VisibleGroup,
|
||||
};
|
||||
pub(crate) use state::*;
|
||||
|
||||
use geometry::*;
|
||||
use luxe_core::config::DiffLayout;
|
||||
use luxe_core::event::GuidedReviewFailure;
|
||||
use luxe_core::guided_review::{
|
||||
ChapterId, DiffSide, FileId, FindingAnchor, FindingId, FindingSeverity, FindingState,
|
||||
GuidedReview, HunkId, ReviewChapter, ReviewFile, ReviewFinding, ReviewHunk, ReviewItemRef,
|
||||
ReviewTarget,
|
||||
};
|
||||
use std::collections::HashSet;
|
||||
|
||||
const COLUMN_SCROLL_STEP: usize = 8;
|
||||
|
||||
/// Cells the diff pane spends before either column starts.
|
||||
///
|
||||
/// Two of them for the active-hunk bar, which sits outside both columns so the rule between them
|
||||
/// does not move as the cursor does, and three for the rule. The renderer has its own names for
|
||||
/// the same two costs and `the_split_gate_measures_what_the_renderer_lays_out` holds them equal —
|
||||
/// the model may not reach into the view for a constant, and a gate that disagrees with the
|
||||
/// layout it gates is how a column comes to run off the edge.
|
||||
pub(crate) const SPLIT_PANE_CHROME: usize = 5;
|
||||
|
||||
/// Cells a unified row spends beyond its two line numbers: the active-hunk bar, a space after each
|
||||
/// number, and the diff sign. Held equal to the renderer's own sum the same way.
|
||||
pub(crate) const UNIFIED_ROW_CHROME: usize = 5;
|
||||
|
||||
/// Cells the diff pane spends on itself: a left pad off the divider, and the scrollbar column.
|
||||
const DIFF_PANE_CHROME: u16 = 2;
|
||||
|
||||
/// Route-local state for one Guided Review presentation.
|
||||
#[derive(Debug, Clone)]
|
||||
pub(crate) struct GuidedReviewWorkspace {
|
||||
/// Current immutable-source load state.
|
||||
pub(crate) load_state: GuidedReviewLoadState,
|
||||
/// Whether the guide pane is beside the diff, where the terminal is wide enough for both.
|
||||
pub(crate) guide_visible: bool,
|
||||
/// Current source-anchored location, retained where IDs survive refresh: the surface's only
|
||||
/// cursor, which both panes render and every navigation key moves.
|
||||
pub(crate) position: ReviewPosition,
|
||||
/// Chapters the reviewer has walked through — the review's only notion of progress.
|
||||
pub(crate) walked_chapters: HashSet<ChapterId>,
|
||||
/// Width the open modal's field was last drawn at, so `↑/↓` moves by the rows the reader sees
|
||||
pub(crate) field_width: std::cell::Cell<u16>,
|
||||
/// What the last frame drew; a dialog it did not draw takes only esc
|
||||
pub(crate) drawn: std::cell::Cell<preview_guard::Drawn>,
|
||||
/// Rows the feedback window's reading pane is scrolled down
|
||||
pub(crate) feedback_scroll: u16,
|
||||
/// Rows the reading pane can scroll, as last drawn
|
||||
pub(crate) feedback_room: std::cell::Cell<u16>,
|
||||
/// Whether the narration band (section prose + this change's sentence) is shown above the diff;
|
||||
/// on by default, since the prose is the point, and `z` folds it for one who wants every row.
|
||||
pub(crate) narration_visible: bool,
|
||||
/// What mechanical churn is collapsed right now — the review's only fold.
|
||||
pub(crate) fold: Fold,
|
||||
/// Whether the local explanation for folded classifications is visible.
|
||||
pub(crate) noise_details_visible: bool,
|
||||
/// Local source picker state, independent from the pinned immutable review.
|
||||
pub(crate) source_picker: ReviewSourcePickerState,
|
||||
/// Pending typed reference input for Base or Commit sources.
|
||||
pub(crate) source_reference_entry: Option<ReviewSourceReferenceEntry>,
|
||||
/// Active in-diff search query (find-in-diff). `None` = not searching; `Some("")` = the search
|
||||
/// prompt is open with an empty query.
|
||||
pub(crate) search: Option<String>,
|
||||
/// Whether the local review shortcut reference is visible.
|
||||
pub(crate) help_visible: bool,
|
||||
/// Unsaved feedback composer state, captured from the selected diff anchor.
|
||||
pub(crate) finding_draft: Option<FindingDraft>,
|
||||
/// Existing draft finding being edited by the local composer, if any.
|
||||
pub(crate) editing_finding_id: Option<FindingId>,
|
||||
/// Whether the local feedback inspector is open over the immutable review.
|
||||
pub(crate) findings_visible: bool,
|
||||
/// Persisted finding selected within the local inspector.
|
||||
pub(crate) selected_finding_id: Option<FindingId>,
|
||||
/// Whether the selected finding's read-only evidence is visible.
|
||||
pub(crate) finding_details_visible: bool,
|
||||
/// Whether the before/after view of the agent's change at this anchor is visible.
|
||||
pub(crate) finding_fix_visible: bool,
|
||||
/// Selected local finish-review choice, if the decision overlay is open.
|
||||
pub(crate) finish_review_choice: Option<FinishReviewChoice>,
|
||||
/// Whether accepting despite a blocking finding has received a second confirmation.
|
||||
pub(crate) finish_review_accept_confirmed: bool,
|
||||
/// Whether the finish chooser offers answering on GitHub: your own pull request's review
|
||||
pub(crate) finish_offers_answers: bool,
|
||||
/// Whether the finish chooser offers opening the branch's pull request
|
||||
pub(crate) finish_offers_opening: bool,
|
||||
/// Whether the finish chooser offers opening the review as a stack
|
||||
pub(crate) finish_offers_stack: bool,
|
||||
/// How this review draws a diff: the configured preference until `Ctrl+B` overrules it.
|
||||
pub(crate) layout: DiffLayout,
|
||||
/// Number of rows available to the rendered full-screen diff body.
|
||||
pub(crate) diff_viewport_rows: usize,
|
||||
/// Terminal-cell offset for horizontally clipped source lines.
|
||||
pub(crate) diff_column_offset: usize,
|
||||
/// Number of terminal cells available to a full-screen diff line.
|
||||
pub(crate) diff_viewport_columns: usize,
|
||||
/// Terminal width the diff viewport was last measured against, so hiding the guide can
|
||||
/// re-measure without waiting for a resize that may never come.
|
||||
terminal_columns: u16,
|
||||
/// The guide's width when the reader dragged its divider; `None` sizes it to the terminal
|
||||
guide_width: Option<u16>,
|
||||
/// The surface's own animation frame.
|
||||
///
|
||||
/// The status model only advances its spinner while a turn is streaming, and the two waits
|
||||
/// that happen *here* — the guide still being written, the agent still addressing comments —
|
||||
/// both happen with the app otherwise idle. A review that says it is working has to look like
|
||||
/// it, or the reviewer reads a static label as a stuck one.
|
||||
pub(crate) frame: usize,
|
||||
/// Where the guide pane is scrolled to, or `None` while it follows the cursor.
|
||||
///
|
||||
/// The guide normally tracks the review position, which is right while you are walking and
|
||||
/// useless when you want to read the section you are *not* standing in. Taking the wheel to it
|
||||
/// pins an offset; moving the cursor hands it back, so it never gets stuck somewhere the
|
||||
/// reader has left. Interior mutability because the release is decided at draw time, which is
|
||||
/// the only place the selected row and the wrapped document exist together.
|
||||
pub(crate) guide_scroll: std::cell::Cell<Option<usize>>,
|
||||
/// The review position the pinned scroll was taken at, so a moved cursor can release it.
|
||||
///
|
||||
/// A fingerprint rather than the position itself, because this is compared at draw time from
|
||||
/// an `&App` and a `Cell` needs `Copy`. Keyed on the *position* rather than on the guide row
|
||||
/// it selects: two hunks of one file share a guide row, so a row-keyed release would leave the
|
||||
/// pane pinned while the reader walked the file it is describing.
|
||||
pub(crate) guide_scroll_anchor: std::cell::Cell<u64>,
|
||||
/// The offset the guide pane was last drawn at, so the wheel moves on from what is on screen
|
||||
/// rather than from the top.
|
||||
pub(crate) guide_drawn_offset: std::cell::Cell<usize>,
|
||||
/// Furthest the guide could scroll, as last drawn, for a drag on its scrollbar
|
||||
pub(crate) guide_room: std::cell::Cell<usize>,
|
||||
/// Whether long unified-diff source lines soft-wrap (with a continuation glyph) instead of
|
||||
/// being horizontally scrolled. Toggled with `w`; default seeded from config.
|
||||
pub(crate) word_wrap: bool,
|
||||
/// Pending send, showing exactly what will reach the agent before anything is dispatched.
|
||||
pub(crate) send_preview: Option<SendPreview>,
|
||||
/// Pending commit, showing the messages before any history is written.
|
||||
pub(crate) commit_preview: Option<CommitPreview>,
|
||||
/// A pull request's review on its way to GitHub
|
||||
pub(crate) github_post: Option<GithubPost>,
|
||||
/// Answers on their way to your own pull request's review threads
|
||||
pub(crate) thread_answers: Option<ThreadAnswers>,
|
||||
/// A branch's pull request, drafted from its review, before it opens
|
||||
pub(crate) pull_request_opening: Option<PullRequestOpening>,
|
||||
/// Someone else's pull request, about to be checked out to fix
|
||||
pub(crate) pull_request_fix: Option<PullRequestFix>,
|
||||
/// A branch's review, about to open as a stack
|
||||
pub(crate) stack_opening: Option<StackOpening>,
|
||||
/// The review last posted to GitHub from here, which `o` opens instead of the pull request
|
||||
pub(crate) posted_review_url: Option<String>,
|
||||
}
|
||||
|
||||
impl Default for GuidedReviewWorkspace {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
load_state: GuidedReviewLoadState::Idle,
|
||||
guide_visible: true,
|
||||
position: ReviewPosition::default(),
|
||||
walked_chapters: HashSet::new(),
|
||||
field_width: std::cell::Cell::new(80),
|
||||
drawn: std::cell::Cell::new(preview_guard::Drawn::ALL),
|
||||
feedback_scroll: 0,
|
||||
feedback_room: std::cell::Cell::new(0),
|
||||
narration_visible: true,
|
||||
fold: Fold::default(),
|
||||
noise_details_visible: false,
|
||||
source_picker: ReviewSourcePickerState::Closed,
|
||||
source_reference_entry: None,
|
||||
search: None,
|
||||
help_visible: false,
|
||||
finding_draft: None,
|
||||
editing_finding_id: None,
|
||||
findings_visible: false,
|
||||
selected_finding_id: None,
|
||||
finding_details_visible: false,
|
||||
finding_fix_visible: false,
|
||||
finish_review_choice: None,
|
||||
finish_review_accept_confirmed: false,
|
||||
finish_offers_answers: false,
|
||||
finish_offers_opening: false,
|
||||
finish_offers_stack: false,
|
||||
layout: DiffLayout::Auto,
|
||||
diff_viewport_rows: 1,
|
||||
diff_column_offset: 0,
|
||||
diff_viewport_columns: 1,
|
||||
terminal_columns: 0,
|
||||
guide_width: None,
|
||||
frame: 0,
|
||||
guide_scroll: std::cell::Cell::new(None),
|
||||
guide_scroll_anchor: std::cell::Cell::new(0),
|
||||
guide_drawn_offset: std::cell::Cell::new(0),
|
||||
guide_room: std::cell::Cell::new(0),
|
||||
word_wrap: false,
|
||||
send_preview: None,
|
||||
commit_preview: None,
|
||||
github_post: None,
|
||||
thread_answers: None,
|
||||
pull_request_opening: None,
|
||||
pull_request_fix: None,
|
||||
stack_opening: None,
|
||||
posted_review_url: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl GuidedReviewWorkspace {
|
||||
/// Opens the local finish-review chooser without changing durable review state.
|
||||
///
|
||||
/// It opens on what the review most likely ends in: fixes when comments are waiting to go,
|
||||
/// and accepting when there is nothing to send, where asking for fixes would send nothing.
|
||||
pub(crate) fn open_finish_review(&mut self, unsent: bool) {
|
||||
self.finish_review_choice = Some(match unsent {
|
||||
true => FinishReviewChoice::RequestFixes,
|
||||
false => FinishReviewChoice::Accept,
|
||||
});
|
||||
self.finish_review_accept_confirmed = false;
|
||||
self.finish_offers_answers = false;
|
||||
self.finish_offers_opening = false;
|
||||
self.finish_offers_stack = false;
|
||||
self.help_visible = false;
|
||||
self.close_feedback_window();
|
||||
}
|
||||
|
||||
/// Moves the local finish-review selection without changing durable review state.
|
||||
pub(crate) fn move_finish_review_choice(&mut self, forward: bool) {
|
||||
if let Some(choice) = self.finish_review_choice {
|
||||
self.finish_review_choice = Some(choice.next(
|
||||
forward,
|
||||
self.finish_offers_answers,
|
||||
self.finish_offers_opening,
|
||||
self.finish_offers_stack,
|
||||
));
|
||||
self.finish_review_accept_confirmed = false;
|
||||
}
|
||||
}
|
||||
|
||||
/// Closes the local finish-review chooser without changing durable review state.
|
||||
pub(crate) fn close_finish_review(&mut self) {
|
||||
self.finish_review_choice = None;
|
||||
self.finish_review_accept_confirmed = false;
|
||||
}
|
||||
|
||||
/// Arms the required second confirmation for accepting with blocking findings.
|
||||
pub(crate) fn confirm_finish_review_accept(&mut self) {
|
||||
self.finish_review_accept_confirmed = true;
|
||||
}
|
||||
|
||||
/// Toggles the local review shortcut reference.
|
||||
pub(crate) fn toggle_help(&mut self) {
|
||||
self.help_visible = !self.help_visible;
|
||||
}
|
||||
|
||||
/// Opens the commit preview so the messages are read before history is written.
|
||||
pub(crate) fn open_commit_preview(&mut self) {
|
||||
self.commit_preview = Some(CommitPreview { squash: false, running: false });
|
||||
self.finish_review_choice = None;
|
||||
self.help_visible = false;
|
||||
}
|
||||
|
||||
/// Closes the commit preview without writing anything.
|
||||
pub(crate) fn close_commit_preview(&mut self) {
|
||||
self.commit_preview = None;
|
||||
}
|
||||
|
||||
/// Switches between one commit per chapter and a single squashed commit.
|
||||
pub(crate) fn toggle_commit_squash(&mut self) {
|
||||
if let Some(preview) = self.commit_preview.as_mut() {
|
||||
preview.squash = !preview.squash;
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a modal is waiting on the engine or GitHub, drawing a spinner as it does.
|
||||
///
|
||||
/// These waits happen while the app is otherwise idle, so nothing else earns the frames that
|
||||
/// turn the spinner: left out, it froze on one character through a whole pull request opening.
|
||||
pub(crate) fn waiting(&self) -> bool {
|
||||
let post = self.github_post.as_ref().is_some_and(|post| {
|
||||
post.posting
|
||||
|| post.drafting.is_some()
|
||||
|| (post.prepared.is_none() && post.error.is_none())
|
||||
});
|
||||
let answers = self.thread_answers.as_ref().is_some_and(|answers| {
|
||||
answers.sending || (answers.prepared.is_none() && answers.error.is_none())
|
||||
});
|
||||
let opening = self.pull_request_opening.as_ref().is_some_and(|opening| {
|
||||
opening.opening || (opening.prepared.is_none() && opening.error.is_none())
|
||||
});
|
||||
let stack = self.stack_opening.as_ref().is_some_and(|stack| {
|
||||
stack.opening || (stack.layers.is_none() && stack.error.is_none())
|
||||
});
|
||||
let fix = self
|
||||
.pull_request_fix
|
||||
.as_ref()
|
||||
.is_some_and(|fix| fix.branch.is_none() && fix.refusal.is_none());
|
||||
post || answers || opening || stack || fix
|
||||
}
|
||||
|
||||
/// Advances the surface's own animation frame.
|
||||
pub(crate) fn tick(&mut self) {
|
||||
self.frame = self.frame.wrapping_add(1);
|
||||
}
|
||||
|
||||
/// Points the reviewer at the start of the change, on a review they have not begun.
|
||||
///
|
||||
/// Called once when a review opens. Someone resuming keeps their place; someone arriving gets
|
||||
/// chapter 01 rather than whatever file happened to sort first, which is the difference between
|
||||
/// a walkthrough and a file listing.
|
||||
pub(crate) fn sync_narrative(&mut self, review: &GuidedReview) {
|
||||
if self.walked_chapters.is_empty() {
|
||||
if let Some(first) = review.chapters.first() {
|
||||
self.position.chapter_id = Some(first.id.clone());
|
||||
self.enter_selected_chapter(review);
|
||||
return;
|
||||
}
|
||||
}
|
||||
self.sync_chapter_to_selection(review);
|
||||
}
|
||||
|
||||
/// Opens or re-collapses every mechanical change, keeping a visible selection when possible.
|
||||
pub(crate) fn toggle_noise(&mut self, files: &[ReviewFile]) {
|
||||
self.fold.toggle_all();
|
||||
self.reconcile_folded_selection(files);
|
||||
}
|
||||
|
||||
/// Opens or re-collapses one file's mechanical changes — the collapsed row's own action.
|
||||
pub(crate) fn toggle_file_fold(&mut self, files: &[ReviewFile], file_id: &FileId) {
|
||||
self.fold.toggle_file(file_id);
|
||||
self.reconcile_folded_selection(files);
|
||||
}
|
||||
|
||||
pub(crate) fn toggle_narration(&mut self) {
|
||||
self.narration_visible = !self.narration_visible;
|
||||
}
|
||||
|
||||
/// Toggles the local explanation for why a lower-signal group was folded.
|
||||
pub(crate) fn toggle_noise_details(&mut self) {
|
||||
self.noise_details_visible = !self.noise_details_visible;
|
||||
}
|
||||
|
||||
/// Whether a hunk is collapsed into its file's placeholder row.
|
||||
pub(crate) fn is_hunk_hidden(&self, file: &ReviewFile, hunk: &ReviewHunk) -> bool {
|
||||
self.fold.hides(file, hunk)
|
||||
}
|
||||
|
||||
/// Returns exact collapsed hunk and source-line counts across an immutable review source.
|
||||
pub(crate) fn hidden_counts(&self, files: &[ReviewFile]) -> (usize, usize) {
|
||||
files
|
||||
.iter()
|
||||
.flat_map(|file| file.hunks.iter().map(move |hunk| (file, hunk)))
|
||||
.filter(|(file, hunk)| self.fold.hides(file, hunk))
|
||||
.fold((0, 0), |(hunks, lines), (_, hunk)| (hunks + 1, lines + hunk.lines.len()))
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a file's diff has both an old and a new side worth showing.
|
||||
///
|
||||
/// `A` and `D` say it outright; a modification with no deletion (or no addition) at all is the same
|
||||
/// shape in practice, e.g. a file that only gained lines. Two columns for a one-sided file means
|
||||
/// half the pane is an empty tinted block, which is worse than unified in every way.
|
||||
pub(crate) fn has_two_sides(file: &ReviewFile) -> bool {
|
||||
use luxe_core::guided_review::{ReviewFileStatus, ReviewLineKind};
|
||||
if matches!(
|
||||
file.status,
|
||||
ReviewFileStatus::Added | ReviewFileStatus::Untracked | ReviewFileStatus::Deleted
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
let mut additions = false;
|
||||
let mut deletions = false;
|
||||
for line in file.hunks.iter().flat_map(|hunk| &hunk.lines) {
|
||||
match line.kind {
|
||||
ReviewLineKind::Addition => additions = true,
|
||||
ReviewLineKind::Deletion => deletions = true,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
additions && deletions
|
||||
}
|
||||
|
||||
/// The new file's line a diff row stands for: its own, or for a removal the next line that survived
|
||||
/// it — where the removed text used to be — and failing that the one before.
|
||||
pub(crate) fn new_side_line(
|
||||
hunk: &luxe_core::guided_review::ReviewHunk,
|
||||
index: usize,
|
||||
) -> Option<u32> {
|
||||
let lines = &hunk.lines;
|
||||
lines.get(index)?.new_line.or_else(|| {
|
||||
lines[index..]
|
||||
.iter()
|
||||
.find_map(|line| line.new_line)
|
||||
.or_else(|| lines[..index].iter().rev().find_map(|line| line.new_line))
|
||||
.or((hunk.new_range.start > 0).then_some(hunk.new_range.start))
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
Reference in New Issue
Block a user