yolop 0.7.0

Yolop — a terminal coding agent built on everruns-runtime
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232

//! Inline-viewport anchoring helpers. Ratatui anchors inline viewports to the
//! cursor row at init and keeps that row fixed across vertical grows; a
//! horizontal shrink resets the origin to the top. Yolop pins the composer to
//! the terminal bottom by moving the backend cursor there and recomputing the
//! inline origin instead of inserting blank scrollback lines.

use anyhow::Result;
use ratatui::Terminal;
use ratatui::backend::Backend;
use ratatui::layout::{Position, Rect};

/// How many rows remain between the inline viewport bottom edge and the
/// terminal bottom. Zero means the composer is flush with the terminal bottom.
pub(crate) fn rows_below_inline_viewport(
    viewport_top: u16,
    viewport_height: u16,
    terminal_height: u16,
) -> u16 {
    terminal_height.saturating_sub(viewport_top.saturating_add(viewport_height))
}

/// Push the inline viewport to the terminal bottom when it has drifted upward.
/// No-op when already flush with the bottom edge.
pub(crate) fn maybe_reanchor_inline_viewport<B>(terminal: &mut Terminal<B>) -> Result<()>
where
    B: Backend,
    B::Error: std::error::Error + Send + Sync + 'static,
{
    let terminal_size = terminal.size()?;
    let viewport_area = terminal.get_frame().area();
    let rows_below =
        rows_below_inline_viewport(viewport_area.y, viewport_area.height, terminal_size.height);
    if rows_below == 0 {
        return Ok(());
    }

    // Wait until crossterm has observed a PTY resize before recomputing the
    // inline origin from the terminal bottom.
    let viewport_bottom = viewport_area.y.saturating_add(viewport_area.height);
    if viewport_bottom > terminal_size.height {
        return Ok(());
    }

    // Recompute the inline origin from a bottom-row cursor. Blank scrollback
    // lines would leave a visible gap above the composer.
    let bottom_row = terminal_size.height.saturating_sub(1);
    terminal.backend_mut().set_cursor_position(Position {
        x: 0,
        y: bottom_row,
    })?;
    terminal.resize(Rect::new(0, 0, terminal_size.width, terminal_size.height))?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use ratatui::TerminalOptions;
    use ratatui::Viewport;
    use ratatui::backend::TestBackend;
    use ratatui::layout::Position;

    fn viewport_bottom<B: Backend>(terminal: &mut Terminal<B>) -> u16 {
        let area = terminal.get_frame().area();
        area.y.saturating_add(area.height)
    }

    fn blank_rows_before_viewport(terminal: &mut Terminal<TestBackend>) -> usize {
        let viewport_top = terminal.get_frame().area().y;
        let buffer = terminal.backend().buffer();
        (0..viewport_top)
            .filter(|y| {
                (0..buffer.area.width).all(|x| {
                    buffer[(x, *y)]
                        .symbol()
                        .chars()
                        .all(|ch| ch.is_whitespace())
                })
            })
            .count()
    }

    #[test]
    fn reanchor_from_top_pins_viewport_without_large_blank_band() {
        let height = 60;
        let mut backend = TestBackend::new(80, height);
        backend
            .set_cursor_position(Position { x: 0, y: 1 })
            .unwrap();
        let mut terminal = Terminal::with_options(
            backend,
            TerminalOptions {
                viewport: Viewport::Inline(18),
            },
        )
        .unwrap();

        maybe_reanchor_inline_viewport(&mut terminal).expect("initial anchor");

        assert_eq!(viewport_bottom(&mut terminal), height);
        assert!(
            terminal.backend().scrollback().area.height < 25,
            "cursor+resize anchoring should not push a tall blank band into scrollback"
        );
    }

    #[test]
    fn reanchor_after_grow_keeps_scrollback_band_bounded() {
        let mut backend = TestBackend::new(80, 24);
        backend
            .set_cursor_position(Position { x: 0, y: 1 })
            .unwrap();
        let mut terminal = Terminal::with_options(
            backend,
            TerminalOptions {
                viewport: Viewport::Inline(18),
            },
        )
        .unwrap();

        maybe_reanchor_inline_viewport(&mut terminal).expect("initial anchor");
        assert!(
            terminal.backend().scrollback().area.height < 25,
            "initial anchor should not push a tall blank band into scrollback"
        );

        terminal.backend_mut().resize(80, 40);
        terminal.autoresize().expect("autoresize grow");
        maybe_reanchor_inline_viewport(&mut terminal).expect("re-anchor after grow");

        assert_eq!(viewport_bottom(&mut terminal), 40);
        assert!(
            terminal.backend().scrollback().area.height < 25,
            "re-anchor after grow should not push a tall blank band into scrollback"
        );
    }

    /// Documents the pre-0.5.0 anchoring mechanism: blank `insert_before` rows
    /// fill the band above the inline viewport. On Crossterm that band becomes
    /// visible scrollback in tall terminals; PTY integration tests cover that.
    #[test]
    fn insert_before_blank_line_anchor_fills_rows_above_viewport() {
        let height = 60;
        let viewport_height = 18;
        let mut backend = TestBackend::new(80, height);
        backend
            .set_cursor_position(Position { x: 0, y: 1 })
            .unwrap();
        let mut terminal = Terminal::with_options(
            backend,
            TerminalOptions {
                viewport: Viewport::Inline(viewport_height),
            },
        )
        .unwrap();

        let viewport_area = terminal.get_frame().area();
        let blank_lines = rows_below_inline_viewport(viewport_area.y, viewport_area.height, height);
        assert!(
            blank_lines >= 40,
            "fixture should mimic a tall terminal with the cursor near the top"
        );

        terminal
            .insert_before(blank_lines, |_| {})
            .expect("blank-line anchor");

        assert_eq!(viewport_bottom(&mut terminal), height);
        assert!(
            blank_rows_before_viewport(&mut terminal) >= 40,
            "blank insert_before anchoring fills the rows above the viewport"
        );
    }

    #[test]
    fn reanchor_after_terminal_grow_moves_viewport_to_bottom() {
        let mut backend = TestBackend::new(80, 24);
        backend
            .set_cursor_position(Position { x: 0, y: 1 })
            .unwrap();
        let mut terminal = Terminal::with_options(
            backend,
            TerminalOptions {
                viewport: Viewport::Inline(18),
            },
        )
        .unwrap();

        maybe_reanchor_inline_viewport(&mut terminal).expect("initial anchor");
        assert_eq!(viewport_bottom(&mut terminal), 24);

        terminal.backend_mut().resize(80, 40);
        terminal.autoresize().expect("autoresize grow");
        let bottom_before_reanchor = viewport_bottom(&mut terminal);
        assert!(
            bottom_before_reanchor <= 40,
            "inline viewport should stay within the grown terminal before re-anchor"
        );

        maybe_reanchor_inline_viewport(&mut terminal).expect("re-anchor after grow");
        assert_eq!(viewport_bottom(&mut terminal), 40);
    }

    #[test]
    fn reanchor_after_horizontal_shrink_moves_viewport_back_to_bottom() {
        let mut backend = TestBackend::new(80, 24);
        backend
            .set_cursor_position(Position { x: 0, y: 1 })
            .unwrap();
        let mut terminal = Terminal::with_options(
            backend,
            TerminalOptions {
                viewport: Viewport::Inline(18),
            },
        )
        .unwrap();

        maybe_reanchor_inline_viewport(&mut terminal).expect("initial anchor");
        assert_eq!(viewport_bottom(&mut terminal), 24);

        terminal.backend_mut().resize(60, 24);
        terminal.autoresize().expect("autoresize shrink");
        assert_eq!(
            terminal.get_frame().area().y,
            0,
            "ratatui resets inline origin to the top on horizontal shrink"
        );

        maybe_reanchor_inline_viewport(&mut terminal).expect("re-anchor after shrink");
        assert_eq!(viewport_bottom(&mut terminal), 24);
    }
}