|
1
|
+ |
//! Full-screen coder TUI layout matching packages/openagents-cli/src/coder-ui.ts
|
|
2
|
+ |
|
|
3
|
+ |
use ratatui::{
|
|
4
|
+ |
layout::{Constraint, Direction, Layout, Position, Rect},
|
|
5
|
+ |
style::{Color, Style},
|
|
6
|
+ |
text::{Line, Span, Text},
|
|
7
|
+ |
widgets::{Block, Borders, Paragraph},
|
|
8
|
+ |
Frame,
|
|
9
|
+ |
};
|
|
10
|
+ |
|
|
11
|
+ |
const TEXT_COLOR: Color = Color::Rgb(255, 176, 0);
|
|
12
|
+ |
const BACKGROUND_COLOR: Color = Color::Rgb(8, 6, 0);
|
|
13
|
+ |
|
|
14
|
+ |
#[derive(Debug, Clone)]
|
|
15
|
+ |
pub enum Role {
|
|
16
|
+ |
You,
|
|
17
|
+ |
Assistant,
|
|
18
|
+ |
Tool,
|
|
19
|
+ |
Reasoning,
|
|
20
|
+ |
Notice,
|
|
21
|
+ |
}
|
|
22
|
+ |
|
|
23
|
+ |
#[derive(Debug, Clone)]
|
|
24
|
+ |
pub struct Entry {
|
|
25
|
+ |
pub role: Role,
|
|
26
|
+ |
pub text: String,
|
|
27
|
+ |
}
|
|
28
|
+ |
|
|
29
|
+ |
#[derive(Debug)]
|
|
30
|
+ |
pub struct CoderUi {
|
|
31
|
+ |
pub composer: String,
|
|
32
|
+ |
pub repo: String,
|
|
33
|
+ |
pub branch: String,
|
|
34
|
+ |
pub model: String,
|
|
35
|
+ |
pub reasoning: Option<String>,
|
|
36
|
+ |
pub running: bool,
|
|
37
|
+ |
pub entries: Vec<Entry>,
|
|
38
|
+ |
/// Manual scroll override; `None` means the viewport follows the bottom.
|
|
39
|
+ |
pub scroll_override: Option<u16>,
|
|
40
|
+ |
pub scroll_max: u16,
|
|
41
|
+ |
pub transcript_height: u16,
|
|
42
|
+ |
pub loading: bool,
|
|
43
|
+ |
}
|
|
44
|
+ |
|
|
45
|
+ |
fn wrap_text(text: &str, width: usize) -> Vec<String> {
|
|
46
|
+ |
if width == 0 {
|
|
47
|
+ |
return vec![text.to_string()];
|
|
48
|
+ |
}
|
|
49
|
+ |
let mut lines = Vec::new();
|
|
50
|
+ |
let mut current = String::new();
|
|
51
|
+ |
let mut current_width = 0;
|
|
52
|
+ |
|
|
53
|
+ |
for word in text.split_whitespace() {
|
|
54
|
+ |
let word_width = word.chars().count();
|
|
55
|
+ |
if current.is_empty() {
|
|
56
|
+ |
current.push_str(word);
|
|
57
|
+ |
current_width = word_width;
|
|
58
|
+ |
} else if current_width + 1 + word_width <= width {
|
|
59
|
+ |
current.push(' ');
|
|
60
|
+ |
current.push_str(word);
|
|
61
|
+ |
current_width += 1 + word_width;
|
|
62
|
+ |
} else {
|
|
63
|
+ |
lines.push(current);
|
|
64
|
+ |
current = word.to_string();
|
|
65
|
+ |
current_width = word_width;
|
|
66
|
+ |
}
|
|
67
|
+ |
}
|
|
68
|
+ |
|
|
69
|
+ |
if !current.is_empty() {
|
|
70
|
+ |
lines.push(current);
|
|
71
|
+ |
}
|
|
72
|
+ |
|
|
73
|
+ |
if lines.is_empty() {
|
|
74
|
+ |
lines.push(text.to_string());
|
|
75
|
+ |
}
|
|
76
|
+ |
|
|
77
|
+ |
lines
|
|
78
|
+ |
}
|
|
79
|
+ |
|
|
80
|
+ |
fn wrap_input(text: &str, width: usize) -> Vec<String> {
|
|
81
|
+ |
if width == 0 {
|
|
82
|
+ |
return vec![text.to_string()];
|
|
83
|
+ |
}
|
|
84
|
+ |
let mut lines = Vec::new();
|
|
85
|
+ |
|
|
86
|
+ |
for paragraph in text.split('\n') {
|
|
87
|
+ |
if paragraph.is_empty() {
|
|
88
|
+ |
lines.push(String::new());
|
|
89
|
+ |
continue;
|
|
90
|
+ |
}
|
|
91
|
+ |
|
|
92
|
+ |
let mut current = String::new();
|
|
93
|
+ |
let mut current_width = 0;
|
|
94
|
+ |
for word in paragraph.split_whitespace() {
|
|
95
|
+ |
let word_width = word.chars().count();
|
|
96
|
+ |
if current.is_empty() {
|
|
97
|
+ |
current.push_str(word);
|
|
98
|
+ |
current_width = word_width;
|
|
99
|
+ |
} else if current_width + 1 + word_width <= width {
|
|
100
|
+ |
current.push(' ');
|
|
101
|
+ |
current.push_str(word);
|
|
102
|
+ |
current_width += 1 + word_width;
|
|
103
|
+ |
} else {
|
|
104
|
+ |
lines.push(current);
|
|
105
|
+ |
current = word.to_string();
|
|
106
|
+ |
current_width = word_width;
|
|
107
|
+ |
}
|
|
108
|
+ |
}
|
|
109
|
+ |
|
|
110
|
+ |
if !current.is_empty() {
|
|
111
|
+ |
lines.push(current);
|
|
112
|
+ |
}
|
|
113
|
+ |
}
|
|
114
|
+ |
|
|
115
|
+ |
if lines.is_empty() {
|
|
116
|
+ |
lines.push(String::new());
|
|
117
|
+ |
}
|
|
118
|
+ |
|
|
119
|
+ |
lines
|
|
120
|
+ |
}
|
|
121
|
+ |
|
|
122
|
+ |
impl CoderUi {
|
|
123
|
+ |
pub fn new() -> Self {
|
|
124
|
+ |
Self {
|
|
125
|
+ |
composer: String::new(),
|
|
126
|
+ |
repo: "~/work/openagents".to_string(),
|
|
127
|
+ |
branch: "main".to_string(),
|
|
128
|
+ |
model: "sol-high".to_string(),
|
|
129
|
+ |
reasoning: Some("medium".to_string()),
|
|
130
|
+ |
running: true,
|
|
131
|
+ |
entries: vec![],
|
|
132
|
+ |
scroll_override: None,
|
|
133
|
+ |
scroll_max: 0,
|
|
134
|
+ |
transcript_height: 0,
|
|
135
|
+ |
loading: false,
|
|
136
|
+ |
}
|
|
137
|
+ |
}
|
|
138
|
+ |
|
|
139
|
+ |
pub fn render(&mut self, frame: &mut Frame, area: Rect) {
|
|
140
|
+ |
let style = Style::default().fg(TEXT_COLOR).bg(BACKGROUND_COLOR);
|
|
141
|
+ |
|
|
142
|
+ |
// Fill the entire terminal with the background color first.
|
|
143
|
+ |
let bg_line = Line::from(vec![Span::styled(
|
|
144
|
+ |
" ".repeat(area.width as usize),
|
|
145
|
+ |
style,
|
|
146
|
+ |
)]);
|
|
147
|
+ |
let bg = Paragraph::new(Text::from(vec![bg_line; area.height as usize]));
|
|
148
|
+ |
frame.render_widget(bg, area);
|
|
149
|
+ |
|
|
150
|
+ |
// ---- composer input (grok-style) ----
|
|
151
|
+ |
let input_width = (area.width as usize)
|
|
152
|
+ |
.saturating_sub(2)
|
|
153
|
+ |
.saturating_sub(3)
|
|
154
|
+ |
.max(1);
|
|
155
|
+ |
let input_chunks = wrap_input(&self.composer, input_width);
|
|
156
|
+ |
let total_input_lines = input_chunks.len() as u16;
|
|
157
|
+ |
let max_input_lines: u16 = 8;
|
|
158
|
+ |
let visible_input_lines = total_input_lines.min(max_input_lines);
|
|
159
|
+ |
let input_scroll = total_input_lines.saturating_sub(visible_input_lines);
|
|
160
|
+ |
let input_box_height = visible_input_lines + 2;
|
|
161
|
+ |
let status_height = if self.loading { 1 } else { 0 };
|
|
162
|
+ |
let bottom_height = input_box_height + status_height;
|
|
163
|
+ |
|
|
164
|
+ |
let main_bottom = Layout::default()
|
|
165
|
+ |
.direction(Direction::Vertical)
|
|
166
|
+ |
.constraints([Constraint::Min(0), Constraint::Length(bottom_height)])
|
|
167
|
+ |
.split(area);
|
|
168
|
+ |
|
|
169
|
+ |
let transcript_area = main_bottom[0];
|
|
170
|
+ |
|
|
171
|
+ |
let mut all_lines = Vec::new();
|
|
172
|
+ |
for entry in &self.entries {
|
|
173
|
+ |
all_lines.extend(self.render_entry(entry, transcript_area.width as usize));
|
|
174
|
+ |
}
|
|
175
|
+ |
|
|
176
|
+ |
let total = all_lines.len() as u16;
|
|
177
|
+ |
self.transcript_height = transcript_area.height;
|
|
178
|
+ |
self.scroll_max = total.saturating_sub(transcript_area.height);
|
|
179
|
+ |
let start = self.effective_scroll(transcript_area.height, total);
|
|
180
|
+ |
|
|
181
|
+ |
let transcript = Paragraph::new(Text::from(all_lines))
|
|
182
|
+ |
.scroll((start, 0))
|
|
183
|
+ |
.style(style);
|
|
184
|
+ |
frame.render_widget(transcript, transcript_area);
|
|
185
|
+ |
|
|
186
|
+ |
let bottom = main_bottom[1];
|
|
187
|
+ |
let bottom_chunks = if self.loading {
|
|
188
|
+ |
Layout::default()
|
|
189
|
+ |
.direction(Direction::Vertical)
|
|
190
|
+ |
.constraints([Constraint::Length(1), Constraint::Length(input_box_height)])
|
|
191
|
+ |
.split(bottom)
|
|
192
|
+ |
} else {
|
|
193
|
+ |
Layout::default()
|
|
194
|
+ |
.direction(Direction::Vertical)
|
|
195
|
+ |
.constraints([Constraint::Length(input_box_height)])
|
|
196
|
+ |
.split(bottom)
|
|
197
|
+ |
};
|
|
198
|
+ |
|
|
199
|
+ |
if self.loading {
|
|
200
|
+ |
let status = Paragraph::new(Line::from(vec![Span::styled("● working…", style)]))
|
|
201
|
+ |
.style(style);
|
|
202
|
+ |
frame.render_widget(status, bottom_chunks[0]);
|
|
203
|
+ |
}
|
|
204
|
+ |
|
|
205
|
+ |
let input_idx = if self.loading { 1 } else { 0 };
|
|
206
|
+ |
|
|
207
|
+ |
let mut input_lines = Vec::new();
|
|
208
|
+ |
for (i, chunk) in input_chunks.iter().enumerate().skip(input_scroll as usize) {
|
|
209
|
+ |
let prefix = if i == 0 { " > " } else { " " };
|
|
210
|
+ |
input_lines.push(Line::from(vec![
|
|
211
|
+ |
Span::styled(prefix, style),
|
|
212
|
+ |
Span::styled(chunk.clone(), style),
|
|
213
|
+ |
]));
|
|
214
|
+ |
}
|
|
215
|
+ |
|
|
216
|
+ |
let input = Paragraph::new(Text::from(input_lines))
|
|
217
|
+ |
.style(style)
|
|
218
|
+ |
.block(
|
|
219
|
+ |
Block::default()
|
|
220
|
+ |
.borders(Borders::ALL)
|
|
221
|
+ |
.border_style(style)
|
|
222
|
+ |
.style(style),
|
|
223
|
+ |
);
|
|
224
|
+ |
frame.render_widget(input, bottom_chunks[input_idx]);
|
|
225
|
+ |
|
|
226
|
+ |
let input_area = bottom_chunks[input_idx];
|
|
227
|
+ |
let last_chunk = input_chunks.last().map(|s| s.as_str()).unwrap_or("");
|
|
228
|
+ |
let cursor_x = input_area.x + 1 + 3 + last_chunk.chars().count() as u16;
|
|
229
|
+ |
let cursor_y = input_area.y + 1 + visible_input_lines.saturating_sub(1);
|
|
230
|
+ |
frame.set_cursor_position(Position::new(cursor_x, cursor_y));
|
|
231
|
+ |
}
|
|
232
|
+ |
|
|
233
|
+ |
fn render_entry(&self, entry: &Entry, width: usize) -> Vec<Line<'static>> {
|
|
234
|
+ |
let text_style = Style::default().fg(TEXT_COLOR).bg(BACKGROUND_COLOR);
|
|
235
|
+ |
|
|
236
|
+ |
let (first_prefix, marker, marker_space, rest_indent, first_body) = match entry.role {
|
|
237
|
+ |
Role::You => ("", ">", " ", " ", width.saturating_sub(2)),
|
|
238
|
+ |
Role::Assistant => ("", "", "", "", width),
|
|
239
|
+ |
_ => (" ", "⏺", " ", " ", width.saturating_sub(4)),
|
|
240
|
+ |
};
|
|
241
|
+ |
|
|
242
|
+ |
let chunks = wrap_text(&entry.text, first_body);
|
|
243
|
+ |
|
|
244
|
+ |
let mut lines = Vec::new();
|
|
245
|
+ |
for (i, chunk) in chunks.iter().enumerate() {
|
|
246
|
+ |
if i == 0 {
|
|
247
|
+ |
lines.push(Line::from(vec![
|
|
248
|
+ |
Span::styled(first_prefix, text_style),
|
|
249
|
+ |
Span::styled(marker, text_style),
|
|
250
|
+ |
Span::styled(marker_space, text_style),
|
|
251
|
+ |
Span::styled(chunk.clone(), text_style),
|
|
252
|
+ |
]));
|
|
253
|
+ |
} else {
|
|
254
|
+ |
lines.push(Line::from(vec![
|
|
255
|
+ |
Span::styled(rest_indent, text_style),
|
|
256
|
+ |
Span::styled(chunk.clone(), text_style),
|
|
257
|
+ |
]));
|
|
258
|
+ |
}
|
|
259
|
+ |
}
|
|
260
|
+ |
lines
|
|
261
|
+ |
}
|
|
262
|
+ |
|
|
263
|
+ |
/// Calculate the scroll offset that keeps the viewport at the bottom
|
|
264
|
+ |
/// unless the user has manually overridden it.
|
|
265
|
+ |
///
|
|
266
|
+ |
/// Mirrors grok-build's `effective_scroll` pattern: a `None` override
|
|
267
|
+ |
/// follows the content, while an explicit offset is clamped to the valid
|
|
268
|
+ |
/// range and left in place.
|
|
269
|
+ |
fn effective_scroll(&self, area_height: u16, total: u16) -> u16 {
|
|
270
|
+ |
let max_scroll = total.saturating_sub(area_height);
|
|
271
|
+ |
match self.scroll_override {
|
|
272
|
+ |
Some(ovr) => ovr.min(max_scroll),
|
|
273
|
+ |
None => max_scroll,
|
|
274
|
+ |
}
|
|
275
|
+ |
}
|
|
276
|
+ |
|
|
277
|
+ |
/// Scroll the transcript by `delta` lines. Positive scrolls down, negative
|
|
278
|
+ |
/// up. Reaching the bottom clears the override so the viewport resumes
|
|
279
|
+ |
/// following new messages.
|
|
280
|
+ |
pub fn scroll_by(&mut self, delta: i32) {
|
|
281
|
+ |
let max = self.scroll_max;
|
|
282
|
+ |
let current = self.scroll_override.unwrap_or(max);
|
|
283
|
+ |
let new = if delta < 0 {
|
|
284
|
+ |
current.saturating_sub((-delta) as u16)
|
|
285
|
+ |
} else {
|
|
286
|
+ |
current.saturating_add(delta as u16).min(max)
|
|
287
|
+ |
};
|
|
288
|
+ |
self.scroll_override = if new >= max { None } else { Some(new) };
|
|
289
|
+ |
}
|
|
290
|
+ |
}
|