opendev-tui 0.1.4

Ratatui-based terminal UI for OpenDev
Documentation 
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

use super::*;

#[test]
fn test_truncate_str() {
    assert_eq!(truncate_str("hello", 10), "hello");
    assert_eq!(truncate_str("hello world", 8), "hello...");
    assert_eq!(truncate_str("hi", 2), "hi");
}

#[test]
fn test_compute_grid_cols() {
    assert_eq!(compute_grid_cols(0, 120), 1);
    assert_eq!(compute_grid_cols(1, 120), 1);
    assert_eq!(compute_grid_cols(2, 120), 2);
    assert_eq!(compute_grid_cols(3, 120), 3);
    assert_eq!(compute_grid_cols(4, 120), 4);
    assert_eq!(compute_grid_cols(5, 120), 4); // 120/30 = 4 max cols
    assert_eq!(compute_grid_cols(3, 59), 1); // 59/30 = 1 max col
    assert_eq!(compute_grid_cols(3, 60), 2); // 60/30 = 2 max cols
}

#[test]
fn test_ceil_div() {
    assert_eq!(ceil_div(1, 1), 1);
    assert_eq!(ceil_div(3, 2), 2);
    assert_eq!(ceil_div(4, 2), 2);
    assert_eq!(ceil_div(5, 3), 2);
    assert_eq!(ceil_div(7, 3), 3);
}

#[test]
fn test_cell_rect() {
    let inner = Rect::new(0, 0, 120, 24);
    // 2 cols, 1 row
    let r0 = cell_rect(0, 0, inner, 2, 1);
    assert_eq!(r0, Rect::new(0, 0, 60, 24));
    let r1 = cell_rect(1, 0, inner, 2, 1);
    assert_eq!(r1, Rect::new(60, 0, 60, 24));

    // 3 cols with remainder (121 width)
    let inner2 = Rect::new(0, 0, 121, 24);
    let r0 = cell_rect(0, 0, inner2, 3, 1);
    assert_eq!(r0.width, 41); // 40 + 1 extra
    let r1 = cell_rect(1, 0, inner2, 3, 1);
    assert_eq!(r1.width, 40);
}

#[test]
fn test_empty_panel() {
    let subagents: Vec<SubagentDisplayState> = vec![];
    let mgr = BackgroundAgentManager::new();
    let covered = HashSet::new();
    let shortener = PathShortener::new(Some("."));
    let panel = TaskWatcherPanel::new(&subagents, &mgr, &covered, 0, &shortener);
    assert_eq!(panel.total_tasks(), 0);
}

#[test]
fn test_panel_with_subagents() {
    let subagents = vec![SubagentDisplayState::new(
        "id-1".into(),
        "Explore".into(),
        "Find TODOs".into(),
    )];
    let mgr = BackgroundAgentManager::new();
    let covered = HashSet::new();
    let shortener = PathShortener::new(Some("."));
    let panel = TaskWatcherPanel::new(&subagents, &mgr, &covered, 0, &shortener);
    assert_eq!(panel.total_tasks(), 1);
}

#[test]
fn test_panel_render_no_crash() {
    let subagents = vec![SubagentDisplayState::new(
        "id-1".into(),
        "Explore".into(),
        "Find TODOs".into(),
    )];
    let mgr = BackgroundAgentManager::new();
    let covered = HashSet::new();
    let shortener = PathShortener::new(Some("."));
    let panel = TaskWatcherPanel::new(&subagents, &mgr, &covered, 0, &shortener);

    let area = Rect::new(0, 0, 80, 24);
    let mut buffer = Buffer::empty(area);
    panel.render(area, &mut buffer);
}

#[test]
fn test_panel_focus_and_scrolls() {
    let subagents: Vec<SubagentDisplayState> = vec![];
    let mgr = BackgroundAgentManager::new();
    let covered = HashSet::new();
    let shortener = PathShortener::new(Some("."));
    let scrolls = vec![3, 5];
    let panel = TaskWatcherPanel::new(&subagents, &mgr, &covered, 0, &shortener)
        .focus(1)
        .cell_scrolls(&scrolls)
        .page(0);
    assert_eq!(panel.focus, 1);
    assert_eq!(panel.cell_scrolls, &[3, 5]);
    assert_eq!(panel.page, 0);
}

#[test]
fn test_parse_activity_line() {
    // Running tool: spinner icon, verb bold, args subtle
    let line = parse_activity_line("\u{25b8} \u{2819} Grep(.route 3s");
    assert_eq!(line.icon_color, style_tokens::BLUE_BRIGHT);
    assert_eq!(line.verb, "Grep");
    assert_eq!(line.args, "(.route 3s");

    // Success: ⏺ icon in green, verb/args split
    let line = parse_activity_line("\u{2713} Read file.rs");
    assert_eq!(line.icon_color, style_tokens::GREEN_BRIGHT);
    assert!(line.icon.contains(COMPLETED_CHAR));
    assert_eq!(line.verb, "Read");
    assert_eq!(line.args, " file.rs");

    // Failure: ⏺ icon in red
    let line = parse_activity_line("\u{2717} Bash(exit 1)");
    assert_eq!(line.icon_color, style_tokens::ERROR);
    assert!(line.icon.contains(COMPLETED_CHAR));
    assert_eq!(line.verb, "Bash");
    assert_eq!(line.args, "(exit 1)");

    // Thinking: subtle
    let line = parse_activity_line("\u{27e1} thinking");
    assert_eq!(line.icon_color, style_tokens::SUBTLE);
    assert_eq!(line.verb, "thinking");

    // Plain text: no icon
    let line = parse_activity_line("normal text");
    assert_eq!(line.icon_color, style_tokens::PRIMARY);
    assert!(line.icon.is_empty());
    assert!(line.verb.is_empty());
    assert_eq!(line.args, "normal text");
}

/// Helper to create a SubagentDisplayState with given fields.
fn make_subagent(id: &str, backgrounded: bool, finished: bool) -> SubagentDisplayState {
    let mut s = SubagentDisplayState::new(id.to_string(), "Agent".into(), "task".into());
    s.backgrounded = backgrounded;
    if finished {
        s.finish(true, "done".into(), 3, None);
    }
    s
}

#[test]
fn test_finished_bg_subagent_still_covers_parent() {
    // A finished backgrounded subagent should still cover its parent task.
    let subagents = vec![make_subagent("sa1", true, true)];
    let mgr = BackgroundAgentManager::new();
    // Simulate bg_subagent_map: sa1 -> bg_task_1
    let covered: HashSet<String> = ["bg_task_1".to_string()].into_iter().collect();
    let shortener = PathShortener::new(Some("."));
    let panel = TaskWatcherPanel::new(&subagents, &mgr, &covered, 0, &shortener);
    let filtered = panel.filtered_bg_tasks();
    // No bg tasks in mgr, so nothing to filter, but covered set is correct
    assert!(filtered.is_empty());
    // The subagent is still counted in total_tasks
    assert_eq!(panel.total_tasks(), 1);
}

#[test]
fn test_mixed_running_and_finished_bg_subagents_cover_parent() {
    // Both running and finished backgrounded subagents should cover the parent.
    let subagents = vec![
        make_subagent("sa1", true, false),
        make_subagent("sa2", true, true),
    ];
    // Both map to same parent
    let covered: HashSet<String> = ["bg_task_1".to_string()].into_iter().collect();
    let mgr = BackgroundAgentManager::new();
    let shortener = PathShortener::new(Some("."));
    let panel = TaskWatcherPanel::new(&subagents, &mgr, &covered, 0, &shortener);
    assert_eq!(panel.total_tasks(), 2);
}

#[test]
fn test_non_bg_finished_subagent_does_not_affect_filtering() {
    // A foreground finished subagent should not contribute to covered_bg_task_ids.
    let subagents = vec![make_subagent("sa1", false, true)];
    let covered: HashSet<String> = HashSet::new(); // no coverage
    let mgr = BackgroundAgentManager::new();
    let shortener = PathShortener::new(Some("."));
    let panel = TaskWatcherPanel::new(&subagents, &mgr, &covered, 0, &shortener);
    // Foreground subagent still shows, covered set is empty
    assert!(panel.filtered_bg_tasks().is_empty());
    assert_eq!(panel.total_tasks(), 1);
}