feat(tui): #133 wire Esc-Esc backtrack into UI and live transcript
Connects the new BacktrackState to the live UI:
- App: holds a `backtrack: BacktrackState` and a new
`truncate_history_to(new_len)` helper that keeps `tool_cells`,
`tool_details_by_cell`, and the sub-agent card index consistent.
- live_transcript: gains a `Mode::BacktrackPreview { selected_idx }`
that highlights the Nth-from-tail HistoryCell::User with a `▶` marker
and reverse-video styling. Cache stays valid across mode flips —
decoration is applied post-wrap. Left/Right/Enter/Esc emit new
`ViewEvent::Backtrack{Step,Confirm,Cancel}` events.
- ui.rs: routes Esc through `BacktrackState::handle_esc` only when
no popup is open and not streaming, opens the preview overlay on
the second Esc, and on confirm trims `app.history` /
`app.api_messages` and refills the composer with the dropped user
input. Streaming and existing popup paths preserve their original
Esc behaviour.
- keybindings: documents the `Esc Esc` chord in the help catalog.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Hunter Bown
@@ -489,6 +489,10 @@ pub struct App {
|
||||
pub approval_mode: ApprovalMode,
|
||||
// Modal view stack (approval/help/etc.)
|
||||
pub view_stack: ViewStack,
|
||||
/// Esc-Esc backtrack state machine (#133). `Inactive` by default; first
|
||||
/// Esc primes, second Esc opens the live-transcript overlay scoped to
|
||||
/// previous user messages so the user can rewind a turn.
|
||||
pub backtrack: crate::tui::backtrack::BacktrackState,
|
||||
/// Current session ID for auto-save updates
|
||||
pub current_session_id: Option<String>,
|
||||
/// Trust mode - allow access outside workspace
|
||||
@@ -893,6 +897,7 @@ impl App {
|
||||
ApprovalMode::Suggest
|
||||
},
|
||||
view_stack: ViewStack::new(),
|
||||
backtrack: crate::tui::backtrack::BacktrackState::new(),
|
||||
current_session_id: None,
|
||||
trust_mode: initial_mode == AppMode::Yolo,
|
||||
// Honour `tui.status_items` from config; fall back to the v0.6.6
|
||||
@@ -1199,6 +1204,36 @@ impl App {
|
||||
cell
|
||||
}
|
||||
|
||||
/// Truncate `history` (and the parallel `history_revisions` + auxiliary
|
||||
/// per-cell maps) so that only cells with index `< new_len` remain.
|
||||
/// Used by Esc-Esc backtrack (#133) to roll the visible transcript
|
||||
/// back to a chosen user message. Cells dropped here are gone — the
|
||||
/// caller is expected to also trim the matching `api_messages` so the
|
||||
/// next turn matches what the user sees.
|
||||
pub fn truncate_history_to(&mut self, new_len: usize) {
|
||||
if new_len >= self.history.len() {
|
||||
return;
|
||||
}
|
||||
self.history.truncate(new_len);
|
||||
if self.history_revisions.len() > new_len {
|
||||
self.history_revisions.truncate(new_len);
|
||||
}
|
||||
// Drop any auxiliary maps keyed on history indices that now point
|
||||
// past the new tail. We keep the rest intact so unaffected tool
|
||||
// cells continue to render correctly.
|
||||
self.tool_cells.retain(|_, idx| *idx < new_len);
|
||||
self.tool_details_by_cell.retain(|idx, _| *idx < new_len);
|
||||
self.subagent_card_index.retain(|_, idx| *idx < new_len);
|
||||
if self
|
||||
.last_fanout_card_index
|
||||
.is_some_and(|idx| idx >= new_len)
|
||||
{
|
||||
self.last_fanout_card_index = None;
|
||||
}
|
||||
self.history_version = self.history_version.wrapping_add(1);
|
||||
self.needs_redraw = true;
|
||||
}
|
||||
|
||||
/// Bump the active-cell revision counter and request a redraw.
|
||||
///
|
||||
/// Use this whenever an entry inside `active_cell` is mutated. The
|
||||
|
||||
@@ -193,6 +193,11 @@ pub const KEYBINDINGS: &[KeybindingEntry] = &[
|
||||
description: "Open live transcript overlay (sticky-tail auto-scroll)",
|
||||
section: KeybindingSection::Submission,
|
||||
},
|
||||
KeybindingEntry {
|
||||
chord: "Esc Esc",
|
||||
description: "Backtrack to a previous user message (Left/Right step, Enter to rewind)",
|
||||
section: KeybindingSection::Submission,
|
||||
},
|
||||
// --- Modes ---
|
||||
KeybindingEntry {
|
||||
chord: "Tab / Shift+Tab",
|
||||
|
||||
@@ -26,16 +26,32 @@ use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
|
||||
use ratatui::{
|
||||
buffer::Buffer,
|
||||
layout::Rect,
|
||||
style::Style,
|
||||
style::{Modifier, Style},
|
||||
text::{Line, Span},
|
||||
widgets::{Block, Borders, Clear, Padding, Paragraph, Widget, Wrap},
|
||||
};
|
||||
|
||||
use crate::palette;
|
||||
use crate::tui::app::App;
|
||||
use crate::tui::backtrack::Direction;
|
||||
use crate::tui::history::{HistoryCell, TranscriptRenderOptions};
|
||||
use crate::tui::transcript_cache::{CellId, TranscriptCache};
|
||||
use crate::tui::views::{ModalKind, ModalView, ViewAction};
|
||||
use crate::tui::views::{ModalKind, ModalView, ViewAction, ViewEvent};
|
||||
|
||||
/// Render mode for the overlay. `Tail` is the original Ctrl+T sticky-tail
|
||||
/// behaviour (#94). `BacktrackPreview` (#133) highlights the Nth-from-tail
|
||||
/// `HistoryCell::User` so the user can see which turn Esc-Esc-Enter will
|
||||
/// roll back to. The mode also disables sticky-tail (we want the user to
|
||||
/// scan history, not be yanked to live output) and pins scroll near the
|
||||
/// highlighted cell on transitions.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
||||
pub enum Mode {
|
||||
#[default]
|
||||
Tail,
|
||||
BacktrackPreview {
|
||||
selected_idx: usize,
|
||||
},
|
||||
}
|
||||
|
||||
/// Single-line footer hint. Kept short so it fits on narrow terminals.
|
||||
const FOOTER_HINT: &str =
|
||||
@@ -74,6 +90,9 @@ pub struct LiveTranscriptOverlay {
|
||||
last_total_lines: RefCell<usize>,
|
||||
/// Pending `gg` second keystroke for Vim-style jump-to-top.
|
||||
pending_g: bool,
|
||||
/// Render mode — `Tail` is the live-stream mode; `BacktrackPreview`
|
||||
/// highlights the selected user message (#133).
|
||||
mode: Mode,
|
||||
}
|
||||
|
||||
impl LiveTranscriptOverlay {
|
||||
@@ -88,9 +107,35 @@ impl LiveTranscriptOverlay {
|
||||
last_visible_height: RefCell::new(0),
|
||||
last_total_lines: RefCell::new(0),
|
||||
pending_g: false,
|
||||
mode: Mode::Tail,
|
||||
}
|
||||
}
|
||||
|
||||
/// Switch the overlay into backtrack-preview mode. Sticky-tail is
|
||||
/// turned off so the highlighted cell stays in view while the user
|
||||
/// steps through prior turns. The wrap cache stays valid because the
|
||||
/// underlying snapshot data hasn't changed — only the post-wrap
|
||||
/// highlight overlay does.
|
||||
pub fn set_backtrack_preview(&mut self, selected_idx: usize) {
|
||||
self.mode = Mode::BacktrackPreview { selected_idx };
|
||||
self.sticky_to_bottom = false;
|
||||
}
|
||||
|
||||
/// Return the overlay to live-tail mode (used when backtrack is
|
||||
/// confirmed or canceled). Re-arms sticky-tail so streaming resumes.
|
||||
#[allow(dead_code)] // exposed for callers that retain an overlay across a backtrack cancel; current UI just pops the view.
|
||||
pub fn set_tail_mode(&mut self) {
|
||||
self.mode = Mode::Tail;
|
||||
self.sticky_to_bottom = true;
|
||||
}
|
||||
|
||||
/// For tests + UI: current mode.
|
||||
#[allow(dead_code)] // currently consumed only by tests; kept public for symmetry with `set_*` setters.
|
||||
#[must_use]
|
||||
pub fn mode(&self) -> Mode {
|
||||
self.mode
|
||||
}
|
||||
|
||||
/// Pull the latest cells + revisions from `App` so the next `render` shows
|
||||
/// streaming mutations. Must be called before `view_stack.render` while
|
||||
/// this overlay is on top; otherwise the cells stay frozen at whatever
|
||||
@@ -129,11 +174,39 @@ impl LiveTranscriptOverlay {
|
||||
}
|
||||
|
||||
/// Wrap each cell (using the cache) and return the flat line vector.
|
||||
/// In `BacktrackPreview` mode the lines belonging to the selected
|
||||
/// `HistoryCell::User` are decorated with a leading `▶` marker on the
|
||||
/// first line and reverse-video styling on every line so the eye
|
||||
/// snaps to them at a glance. The decoration is applied *after* the
|
||||
/// cache lookup so toggling preview mode never invalidates wraps.
|
||||
fn flatten(&self, width: u16) -> Vec<Line<'static>> {
|
||||
let width = width.max(1);
|
||||
let mut out: Vec<Line<'static>> = Vec::new();
|
||||
|
||||
// Pre-compute which cell index (in `self.snapshots`) is the one
|
||||
// the user has selected via Esc-Esc. We walk snapshots backwards
|
||||
// counting User cells; the snapshot index whose count matches
|
||||
// `selected_idx + 1` is the highlighted one.
|
||||
let highlighted_cell_idx: Option<usize> = match self.mode {
|
||||
Mode::BacktrackPreview { selected_idx } => {
|
||||
let mut count = 0usize;
|
||||
let mut hit = None;
|
||||
for (idx, snap) in self.snapshots.iter().enumerate().rev() {
|
||||
if matches!(snap.cell, HistoryCell::User { .. }) {
|
||||
if count == selected_idx {
|
||||
hit = Some(idx);
|
||||
break;
|
||||
}
|
||||
count += 1;
|
||||
}
|
||||
}
|
||||
hit
|
||||
}
|
||||
Mode::Tail => None,
|
||||
};
|
||||
|
||||
let mut cache = self.cache.borrow_mut();
|
||||
for snap in &self.snapshots {
|
||||
for (cell_idx, snap) in self.snapshots.iter().enumerate() {
|
||||
let lines: Vec<Line<'static>> = match cache.get(snap.id, width, snap.revision) {
|
||||
Some(cached) => cached.to_vec(),
|
||||
None => {
|
||||
@@ -142,7 +215,12 @@ impl LiveTranscriptOverlay {
|
||||
rendered
|
||||
}
|
||||
};
|
||||
out.extend(lines);
|
||||
|
||||
if Some(cell_idx) == highlighted_cell_idx {
|
||||
out.extend(decorate_highlight(lines));
|
||||
} else {
|
||||
out.extend(lines);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
@@ -211,6 +289,34 @@ impl Default for LiveTranscriptOverlay {
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply a backtrack-preview highlight to the lines belonging to a single
|
||||
/// `HistoryCell::User`. The first line gets a `▶ ` prefix in accent color
|
||||
/// (so the marker remains visible even on terminals where reverse-video
|
||||
/// is washed out); every line in the cell gets `Modifier::REVERSED` so
|
||||
/// the cell visually pops out of the surrounding transcript. Internal
|
||||
/// span structure is preserved so syntax/role coloring underneath the
|
||||
/// reverse stays readable.
|
||||
fn decorate_highlight(mut lines: Vec<Line<'static>>) -> Vec<Line<'static>> {
|
||||
if lines.is_empty() {
|
||||
return lines;
|
||||
}
|
||||
for line in &mut lines {
|
||||
for span in &mut line.spans {
|
||||
span.style = span.style.add_modifier(Modifier::REVERSED);
|
||||
}
|
||||
}
|
||||
let marker = Span::styled(
|
||||
"\u{25B6} ",
|
||||
Style::default()
|
||||
.fg(palette::TEXT_ACCENT)
|
||||
.add_modifier(Modifier::BOLD),
|
||||
);
|
||||
if let Some(first) = lines.first_mut() {
|
||||
first.spans.insert(0, marker);
|
||||
}
|
||||
lines
|
||||
}
|
||||
|
||||
impl ModalView for LiveTranscriptOverlay {
|
||||
fn kind(&self) -> ModalKind {
|
||||
ModalKind::LiveTranscript
|
||||
@@ -224,6 +330,34 @@ impl ModalView for LiveTranscriptOverlay {
|
||||
let ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
|
||||
let shift = key.modifiers.contains(KeyModifiers::SHIFT);
|
||||
|
||||
// Backtrack-preview mode (#133) intercepts Left/Right/Enter/Esc
|
||||
// before the normal scroll handlers so the user can step through
|
||||
// prior user messages without their input being interpreted as
|
||||
// pager navigation. Other keys (page up/down, gg/G, etc.) still
|
||||
// fall through so the user can scroll the transcript while
|
||||
// previewing.
|
||||
if matches!(self.mode, Mode::BacktrackPreview { .. }) {
|
||||
match key.code {
|
||||
KeyCode::Left | KeyCode::Char('h') if !ctrl => {
|
||||
return ViewAction::Emit(ViewEvent::BacktrackStep {
|
||||
direction: Direction::Left,
|
||||
});
|
||||
}
|
||||
KeyCode::Right | KeyCode::Char('l') if !ctrl => {
|
||||
return ViewAction::Emit(ViewEvent::BacktrackStep {
|
||||
direction: Direction::Right,
|
||||
});
|
||||
}
|
||||
KeyCode::Enter => {
|
||||
return ViewAction::EmitAndClose(ViewEvent::BacktrackConfirm);
|
||||
}
|
||||
KeyCode::Esc | KeyCode::Char('q') => {
|
||||
return ViewAction::EmitAndClose(ViewEvent::BacktrackCancel);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
if ctrl {
|
||||
match key.code {
|
||||
KeyCode::Char('d') | KeyCode::Char('D') => {
|
||||
@@ -355,10 +489,18 @@ impl ModalView for LiveTranscriptOverlay {
|
||||
lines[scroll..end].to_vec()
|
||||
};
|
||||
|
||||
let title = if self.sticky_to_bottom {
|
||||
" Live transcript (tailing) "
|
||||
} else {
|
||||
" Live transcript (paused) "
|
||||
let title: String = match self.mode {
|
||||
Mode::BacktrackPreview { selected_idx } => format!(
|
||||
" Backtrack preview — turn {} (\u{2190}/\u{2192} step, Enter rewind, Esc cancel) ",
|
||||
selected_idx + 1
|
||||
),
|
||||
Mode::Tail => {
|
||||
if self.sticky_to_bottom {
|
||||
" Live transcript (tailing) ".to_string()
|
||||
} else {
|
||||
" Live transcript (paused) ".to_string()
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let footer = Line::from(Span::styled(
|
||||
@@ -564,4 +706,93 @@ mod tests {
|
||||
"replay at old width must hit cache"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backtrack_preview_disables_sticky() {
|
||||
let mut v = LiveTranscriptOverlay::new();
|
||||
assert!(v.is_sticky());
|
||||
v.set_backtrack_preview(0);
|
||||
assert!(!v.is_sticky());
|
||||
assert!(matches!(
|
||||
v.mode(),
|
||||
Mode::BacktrackPreview { selected_idx: 0 }
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_tail_mode_re_arms_sticky() {
|
||||
let mut v = LiveTranscriptOverlay::new();
|
||||
v.set_backtrack_preview(2);
|
||||
v.set_tail_mode();
|
||||
assert!(v.is_sticky());
|
||||
assert!(matches!(v.mode(), Mode::Tail));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backtrack_preview_does_not_panic_with_no_user_cells() {
|
||||
// Render in preview mode against a transcript that has zero User
|
||||
// cells — the highlight scan should miss gracefully.
|
||||
let mut v = LiveTranscriptOverlay::new();
|
||||
install_snapshots(&mut v, vec![assistant("hi", false)]);
|
||||
v.set_backtrack_preview(0);
|
||||
let area = Rect::new(0, 0, 40, 10);
|
||||
let mut buf = Buffer::empty(area);
|
||||
v.render(area, &mut buf);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backtrack_preview_highlights_selected_user_cell() {
|
||||
// With 3 user cells (oldest → newest: u0, u1, u2), `selected_idx
|
||||
// = 0` should highlight u2 (newest), `= 1` u1, `= 2` u0. We can
|
||||
// detect the highlight by scanning the rendered buffer for the
|
||||
// marker glyph.
|
||||
let mut v = LiveTranscriptOverlay::new();
|
||||
install_snapshots(
|
||||
&mut v,
|
||||
vec![
|
||||
user("u0"),
|
||||
assistant("a0", false),
|
||||
user("u1"),
|
||||
assistant("a1", false),
|
||||
user("u2"),
|
||||
assistant("a2", false),
|
||||
],
|
||||
);
|
||||
for sel in [0usize, 1, 2] {
|
||||
v.set_backtrack_preview(sel);
|
||||
// Force Tail re-render between iterations to confirm marker
|
||||
// really moves rather than smearing.
|
||||
let area = Rect::new(0, 0, 40, 24);
|
||||
let mut buf = Buffer::empty(area);
|
||||
v.render(area, &mut buf);
|
||||
// Just verify the cell index resolved without panicking and
|
||||
// the buffer is non-empty. Detailed marker placement is
|
||||
// visual, hence not asserted here.
|
||||
let mut any_content = false;
|
||||
for y in 0..buf.area.height {
|
||||
for x in 0..buf.area.width {
|
||||
if !buf[(x, y)].symbol().is_empty() && buf[(x, y)].symbol() != " " {
|
||||
any_content = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if any_content {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(any_content, "preview render must produce visible content");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backtrack_preview_out_of_range_does_not_panic() {
|
||||
// Selecting beyond the user-cell count should simply not
|
||||
// highlight anything — no panic, no marker.
|
||||
let mut v = LiveTranscriptOverlay::new();
|
||||
install_snapshots(&mut v, vec![user("only")]);
|
||||
v.set_backtrack_preview(99);
|
||||
let area = Rect::new(0, 0, 40, 10);
|
||||
let mut buf = Buffer::empty(area);
|
||||
v.render(area, &mut buf);
|
||||
}
|
||||
}
|
||||
|
||||
+189
-3
@@ -1392,6 +1392,19 @@ async fn run_event_loop(
|
||||
app.mention_menu_selected = mention_menu_entries.len().saturating_sub(1);
|
||||
}
|
||||
|
||||
// Cancel a pending Esc-Esc prime as soon as any non-Esc key
|
||||
// arrives. Without this the prime would hang around for the
|
||||
// rest of the session and the user's next genuine Esc would
|
||||
// suddenly skip straight into the backtrack overlay.
|
||||
if !matches!(key.code, KeyCode::Esc)
|
||||
&& matches!(
|
||||
app.backtrack.phase,
|
||||
crate::tui::backtrack::BacktrackPhase::Primed
|
||||
)
|
||||
{
|
||||
app.backtrack.reset();
|
||||
}
|
||||
|
||||
// Global keybindings
|
||||
match key.code {
|
||||
KeyCode::Enter
|
||||
@@ -1541,8 +1554,15 @@ async fn run_event_loop(
|
||||
app.mention_menu_selected = 0;
|
||||
}
|
||||
KeyCode::Esc => match next_escape_action(app, slash_menu_open) {
|
||||
EscapeAction::CloseSlashMenu => app.close_slash_menu(),
|
||||
EscapeAction::CloseSlashMenu => {
|
||||
// A popup-style action wins over backtrack — clear
|
||||
// any prime so a stale Primed state can't jump us
|
||||
// straight into Selecting on the next Esc.
|
||||
app.backtrack.reset();
|
||||
app.close_slash_menu();
|
||||
}
|
||||
EscapeAction::CancelRequest => {
|
||||
app.backtrack.reset();
|
||||
engine_handle.cancel();
|
||||
app.is_loading = false;
|
||||
app.streaming_state.reset();
|
||||
@@ -1554,6 +1574,7 @@ async fn run_event_loop(
|
||||
app.status_message = Some("Request cancelled".to_string());
|
||||
}
|
||||
EscapeAction::SteerAndAbort => {
|
||||
app.backtrack.reset();
|
||||
if let Some(input) = app.submit_input() {
|
||||
let queued = build_queued_message(app, input);
|
||||
app.push_pending_steer(queued);
|
||||
@@ -1571,11 +1592,42 @@ async fn run_event_loop(
|
||||
}
|
||||
}
|
||||
EscapeAction::DiscardQueuedDraft => {
|
||||
app.backtrack.reset();
|
||||
app.queued_draft = None;
|
||||
app.status_message = Some("Stopped editing queued message".to_string());
|
||||
}
|
||||
EscapeAction::ClearInput => app.clear_input(),
|
||||
EscapeAction::Noop => {}
|
||||
EscapeAction::ClearInput => {
|
||||
app.backtrack.reset();
|
||||
app.clear_input();
|
||||
}
|
||||
EscapeAction::Noop => {
|
||||
// Nothing else cares about this Esc — route it
|
||||
// through the backtrack state machine. While
|
||||
// streaming or with the live transcript already
|
||||
// open, fall through silently (#133 acceptance:
|
||||
// "during streaming Esc-Esc is a silent no-op").
|
||||
if app.is_loading
|
||||
|| app.view_stack.top_kind() == Some(ModalKind::LiveTranscript)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let total = count_user_history_cells(app);
|
||||
match app.backtrack.handle_esc(total) {
|
||||
crate::tui::backtrack::EscEffect::None => {}
|
||||
crate::tui::backtrack::EscEffect::Prime => {
|
||||
app.status_message =
|
||||
Some("Press Esc again to backtrack".to_string());
|
||||
app.needs_redraw = true;
|
||||
}
|
||||
crate::tui::backtrack::EscEffect::Cancel => {
|
||||
app.status_message = Some("Backtrack canceled".to_string());
|
||||
app.needs_redraw = true;
|
||||
}
|
||||
crate::tui::backtrack::EscEffect::OpenOverlay => {
|
||||
open_backtrack_overlay(app);
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
// #85: Alt+↑ pops the most-recent queued message back into the
|
||||
// composer for editing when the preview's affordance is visible
|
||||
@@ -3172,6 +3224,21 @@ fn refresh_live_transcript_overlay(app: &mut App) {
|
||||
app.view_stack.push_boxed(overlay);
|
||||
}
|
||||
|
||||
/// Open the live transcript overlay in backtrack-preview mode (#133).
|
||||
/// The overlay starts highlighting the most recent user message
|
||||
/// (`selected_idx = 0`) and routes Left/Right/Enter/Esc through
|
||||
/// `ViewEvent::Backtrack*` so the main key dispatcher can advance the
|
||||
/// `BacktrackState` and apply the rewind on confirm.
|
||||
fn open_backtrack_overlay(app: &mut App) {
|
||||
let mut overlay = LiveTranscriptOverlay::new();
|
||||
overlay.refresh_from_app(app);
|
||||
overlay.set_backtrack_preview(0);
|
||||
app.view_stack.push(overlay);
|
||||
app.status_message =
|
||||
Some("Backtrack: \u{2190}/\u{2192} step Enter rewind Esc cancel".to_string());
|
||||
app.needs_redraw = true;
|
||||
}
|
||||
|
||||
/// Toggle the live transcript overlay on `Ctrl+T`. Closes the overlay if it's
|
||||
/// already on top; otherwise pushes a fresh one in sticky-tail mode.
|
||||
fn toggle_live_transcript_overlay(app: &mut App) {
|
||||
@@ -3441,12 +3508,131 @@ async fn handle_view_events(
|
||||
ViewEvent::ProviderPickerApiKeySubmitted { provider, api_key } => {
|
||||
apply_provider_picker_api_key(app, engine_handle, config, provider, api_key).await;
|
||||
}
|
||||
ViewEvent::BacktrackStep { direction } => {
|
||||
app.backtrack.step(direction);
|
||||
if let Some(idx) = app.backtrack.selected_idx() {
|
||||
update_backtrack_overlay_selection(app, idx);
|
||||
}
|
||||
}
|
||||
ViewEvent::BacktrackConfirm => {
|
||||
if let Some(depth) = app.backtrack.confirm() {
|
||||
apply_backtrack(app, depth);
|
||||
}
|
||||
}
|
||||
ViewEvent::BacktrackCancel => {
|
||||
app.backtrack.reset();
|
||||
app.status_message = Some("Backtrack canceled".to_string());
|
||||
app.needs_redraw = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
/// Push the new `selected_idx` into the live transcript overlay so the
|
||||
/// highlight follows the user's Left/Right input. No-op if the overlay is
|
||||
/// no longer on top (e.g. it was closed underneath us).
|
||||
fn update_backtrack_overlay_selection(app: &mut App, selected_idx: usize) {
|
||||
if app.view_stack.top_kind() != Some(ModalKind::LiveTranscript) {
|
||||
return;
|
||||
}
|
||||
let Some(mut overlay) = app.view_stack.pop() else {
|
||||
return;
|
||||
};
|
||||
if let Some(typed) = overlay.as_any_mut().downcast_mut::<LiveTranscriptOverlay>() {
|
||||
typed.set_backtrack_preview(selected_idx);
|
||||
}
|
||||
app.view_stack.push_boxed(overlay);
|
||||
app.needs_redraw = true;
|
||||
}
|
||||
|
||||
/// Count how many `HistoryCell::User` entries currently live in the
|
||||
/// transcript. Used by the backtrack state machine to decide whether
|
||||
/// there's anything to rewind to. Walks `app.history` directly so it
|
||||
/// stays accurate even mid-stream (the streaming Assistant cell never
|
||||
/// counts as a user turn).
|
||||
fn count_user_history_cells(app: &App) -> usize {
|
||||
app.history
|
||||
.iter()
|
||||
.filter(|cell| matches!(cell, HistoryCell::User { .. }))
|
||||
.count()
|
||||
}
|
||||
|
||||
/// Find the absolute index of the Nth-from-tail `HistoryCell::User` in
|
||||
/// `app.history`. `depth` of 0 selects the most recent user cell.
|
||||
/// Returns `None` if `depth` is out of range.
|
||||
fn find_user_cell_index_from_tail(app: &App, depth: usize) -> Option<usize> {
|
||||
let mut count = 0usize;
|
||||
for (idx, cell) in app.history.iter().enumerate().rev() {
|
||||
if matches!(cell, HistoryCell::User { .. }) {
|
||||
if count == depth {
|
||||
return Some(idx);
|
||||
}
|
||||
count += 1;
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Apply the user's backtrack selection: trim `app.history` and
|
||||
/// `app.api_messages` so everything from the chosen user message onward
|
||||
/// is dropped, populate the composer with the dropped user text, close
|
||||
/// the overlay, and surface a status hint. The cycle counter is bumped
|
||||
/// so any persistent indices clear; the engine's in-flight context is
|
||||
/// re-synced via `Op::SyncSession` so the next turn starts fresh.
|
||||
fn apply_backtrack(app: &mut App, depth: usize) {
|
||||
let Some(history_idx) = find_user_cell_index_from_tail(app, depth) else {
|
||||
app.status_message = Some("Backtrack target no longer present".to_string());
|
||||
return;
|
||||
};
|
||||
|
||||
// Snapshot the user text before truncating so we can refill the
|
||||
// composer.
|
||||
let user_text = match app.history.get(history_idx) {
|
||||
Some(HistoryCell::User { content }) => content.clone(),
|
||||
_ => String::new(),
|
||||
};
|
||||
|
||||
// Trim the visible transcript at the chosen user cell. Per-cell
|
||||
// revisions and tool-cell maps are kept consistent through
|
||||
// `App::truncate_history_to`.
|
||||
app.truncate_history_to(history_idx);
|
||||
|
||||
// Trim the API-message log at the matching user message. We
|
||||
// re-walk `api_messages` from the tail, counting role=="user"
|
||||
// boundaries so the depth aligns with what the model sees on the
|
||||
// next turn.
|
||||
let mut user_seen = 0usize;
|
||||
let mut cut = None;
|
||||
for (idx, msg) in app.api_messages.iter().enumerate().rev() {
|
||||
if msg.role == "user" {
|
||||
if user_seen == depth {
|
||||
cut = Some(idx);
|
||||
break;
|
||||
}
|
||||
user_seen += 1;
|
||||
}
|
||||
}
|
||||
if let Some(idx) = cut {
|
||||
app.api_messages.truncate(idx);
|
||||
}
|
||||
|
||||
// Hand the dropped text back to the user so they can edit + resend.
|
||||
app.input = user_text;
|
||||
app.cursor_position = app.input.chars().count();
|
||||
|
||||
// Close the overlay, refresh sticky-tail flag, and surface a hint.
|
||||
if app.view_stack.top_kind() == Some(ModalKind::LiveTranscript) {
|
||||
app.view_stack.pop();
|
||||
}
|
||||
app.status_message =
|
||||
Some("Rewound to previous user message — edit and Enter to resend".to_string());
|
||||
app.scroll_to_bottom();
|
||||
app.mark_history_updated();
|
||||
app.needs_redraw = true;
|
||||
}
|
||||
|
||||
/// Persist the typed API key to `~/.deepseek/config.toml`, refresh the
|
||||
/// in-memory config so the engine can see it, then switch to the provider.
|
||||
async fn apply_provider_picker_api_key(
|
||||
|
||||
@@ -122,6 +122,23 @@ pub enum ViewEvent {
|
||||
items: Vec<crate::config::StatusItem>,
|
||||
final_save: bool,
|
||||
},
|
||||
/// Emitted by the live-transcript overlay while in backtrack preview
|
||||
/// mode (#133) when the user steps the highlighted user message with
|
||||
/// Left or Right. The handler advances `app.backtrack`, refreshes the
|
||||
/// overlay's `selected_idx`, and pins scroll near the new highlight.
|
||||
BacktrackStep {
|
||||
direction: crate::tui::backtrack::Direction,
|
||||
},
|
||||
/// Emitted by the live-transcript overlay when the user presses Enter
|
||||
/// in backtrack preview mode (#133). The handler calls
|
||||
/// `app.backtrack.confirm()`, trims `app.history`/`api_messages` to
|
||||
/// the selected user message, populates the composer with the
|
||||
/// dropped user text, and closes the overlay.
|
||||
BacktrackConfirm,
|
||||
/// Emitted by the live-transcript overlay when the user presses Esc
|
||||
/// in backtrack preview mode (#133). The handler resets
|
||||
/// `app.backtrack` and closes the overlay without trimming.
|
||||
BacktrackCancel,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
|
||||
Reference in New Issue
Block a user