rho-coding-agent 1.48.0

A lightweight agent harness inspired by Pi
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

use pretty_assertions::assert_eq;
use ratatui::layout::Rect;

use super::*;

fn nav_and_detail_panes(layout: &OverlayLayout) -> OverlayPanes {
    match layout.panes {
        panes @ OverlayPanes::NavAndDetail { .. } => panes,
        OverlayPanes::NavOnly { .. } => panic!("expected nav+detail panes, got nav-only"),
    }
}

#[test]
fn tiny_stacked_layout_keeps_viewports_within_the_body() {
    let layout = picker_overlay_layout(
        Rect::new(0, 0, 20, 1),
        OverlaySizing {
            has_details: true,
            nav_rows: 2,
        },
    );
    let OverlayPanes::NavAndDetail {
        orientation,
        detail_viewport_rows,
        nav_viewport_rows,
        ..
    } = nav_and_detail_panes(&layout)
    else {
        unreachable!()
    };

    assert_eq!(orientation, OverlayOrientation::Stacked);
    let separator_rows = usize::from(layout.body_rows > 2);
    assert!(detail_viewport_rows + nav_viewport_rows + separator_rows <= layout.body_rows);
    assert_eq!(nav_viewport_rows, 1);
}

// Covers: the overlay height must follow the item count instead of always
// filling the screen; short pickers get a compact box, long pickers still
// clamp to the margin-bounded maximum.
// Owner: tui picker_overlay geometry
#[test]
fn overlay_height_follows_item_count() {
    let area = Rect::new(0, 0, 120, 40);
    let small = picker_overlay_layout(
        area,
        OverlaySizing {
            has_details: true,
            nav_rows: 5,
        },
    );
    // 12-row detail minimum + 5 chrome rows + 2 border rows.
    assert_eq!(small.outer.height, 19);

    let nav_only = picker_overlay_layout(
        area,
        OverlaySizing {
            has_details: false,
            nav_rows: 5,
        },
    );
    // 5 nav rows + 5 chrome rows + 2 border rows.
    assert_eq!(nav_only.outer.height, 12);

    let large = picker_overlay_layout(
        area,
        OverlaySizing {
            has_details: true,
            nav_rows: 100,
        },
    );
    // Clamped to the screen minus vertical margins.
    assert_eq!(large.outer.height, 34);
    assert!(large.outer.y > area.y);
}

// Covers: wheel routing must hit the pane under the pointer for both
// orientations and ignore chrome rows, or the wrong pane scrolls.
// Owner: tui picker_overlay geometry
#[test]
fn pane_at_maps_positions_to_panes() {
    let area = Rect::new(0, 0, 120, 40);
    let sizing = OverlaySizing {
        has_details: true,
        nav_rows: 30,
    };
    let side_by_side = picker_overlay_layout(area, sizing);
    let outer = side_by_side.outer;
    let OverlayPanes::NavAndDetail { nav_width, .. } = side_by_side.panes else {
        panic!("expected nav+detail");
    };
    let body_row = side_by_side.body_top();
    assert_eq!(
        side_by_side
            .pane_hit(outer.x + 2, body_row)
            .map(|hit| hit.pane),
        Some(OverlayPane::Nav)
    );
    assert_eq!(
        side_by_side
            .pane_hit(outer.x + 2 + nav_width as u16 + 3, body_row)
            .map(|hit| hit.pane),
        Some(OverlayPane::Detail)
    );
    // Chrome rows (title, filter) and space outside the overlay hit nothing.
    assert_eq!(side_by_side.pane_hit(outer.x + 2, outer.y + 1), None);
    assert_eq!(side_by_side.pane_hit(0, 0), None);

    // Narrow terminals stack detail above nav.
    let stacked = picker_overlay_layout(Rect::new(0, 0, 40, 40), sizing);
    let outer = stacked.outer;
    let OverlayPanes::NavAndDetail {
        detail_viewport_rows,
        ..
    } = stacked.panes
    else {
        panic!("expected nav+detail");
    };
    let body_top = stacked.body_top();
    assert_eq!(
        stacked.pane_hit(outer.x + 2, body_top).map(|hit| hit.pane),
        Some(OverlayPane::Detail)
    );
    // The rule row between the stacked panes is chrome, not a pane.
    assert_eq!(
        stacked.pane_hit(outer.x + 2, body_top + detail_viewport_rows as u16),
        None
    );
    assert_eq!(
        stacked.pane_hit(outer.x + 2, body_top + detail_viewport_rows as u16 + 1),
        Some(PaneHit {
            pane: OverlayPane::Nav,
            pane_row: 0
        })
    );
}

// Covers: nav scrollbar hit testing must use the same body rect the renderer
// paints into, or track clicks select rows instead of scrolling.
// Owner: pure unit (overlay geometry)
#[test]
fn nav_body_rect_right_edge_is_scrollbar_column() {
    let layout = picker_overlay_layout(
        Rect::new(0, 0, 120, 40),
        OverlaySizing {
            has_details: true,
            nav_rows: 40,
        },
    );
    let nav = layout.nav_body_rect();
    assert!(
        nav.width >= 4,
        "nav pane must be wide enough for a scrollbar"
    );
    assert_eq!(nav.y, layout.body_top());
    assert_eq!(nav.height as usize, layout.nav_viewport_rows());
    // Rightmost column of the nav body is where the track is drawn.
    let scrollbar_x = nav.x + nav.width - 1;
    let hit = layout
        .pane_hit(scrollbar_x, nav.y)
        .expect("scrollbar column still belongs to the nav pane");
    assert_eq!(hit.pane, OverlayPane::Nav);
    assert_eq!(hit.pane_row, 0);

    let detail = layout.detail_body_rect().expect("detail pane");
    assert_eq!(detail.y, layout.body_top());
    assert!(detail.x > nav.x + nav.width);
}