1use crate::tui_theme::Theme;
3use crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
4use futures_util::{Stream, StreamExt};
5use ratatui::{
6 Frame, Terminal,
7 backend::Backend,
8 layout::{Constraint, Layout},
9 style::Style,
10 text::{Line, Span},
11 widgets::{Paragraph, Wrap},
12};
13use rigspark_core::{
14 generation::{GenerationCatalog, fit},
15 reports::strip_control,
16 sizing::Hardware,
17};
18use rigspark_runtime::generation::{
19 Events, Generator, MAX_PROMPT_BYTES, MAX_SEED, NativeOptions, NativeOutcome,
20};
21use std::{
22 collections::VecDeque,
23 io,
24 path::PathBuf,
25 sync::Arc,
26 time::{Duration, Instant},
27};
28use tokio_util::sync::CancellationToken;
29
30const LOG_LINES: usize = 200;
31
32#[derive(Debug, Clone)]
33pub struct ModelRow {
34 pub id: String,
35 pub kind: &'static str,
36 pub default: bool,
37 pub params: String,
38 pub weights_gib: f64,
39 pub verdict: &'static str,
40 pub reason: &'static str,
41}
42
43pub fn model_rows(catalog: &GenerationCatalog, hardware: &Hardware) -> Vec<ModelRow> {
45 let mut rows: Vec<_> = catalog
46 .models
47 .iter()
48 .map(|model| {
49 let memory = fit(model, hardware);
50 ModelRow {
51 id: model.id.clone(),
52 kind: model.kind.name(),
53 default: model.default,
54 params: model.params.clone(),
55 weights_gib: model.total_bytes() as f64 / 1073741824.0,
56 verdict: memory.verdict.name(),
57 reason: memory.reason,
58 }
59 })
60 .collect();
61 rows.sort_by(|left, right| {
62 left.kind
63 .cmp(right.kind)
64 .then(right.default.cmp(&left.default))
65 .then(left.id.cmp(&right.id))
66 });
67 rows
68}
69
70#[derive(Clone, Copy, Debug, PartialEq, Eq)]
71pub enum Field {
72 Model,
73 Prompt,
74 Directory,
75 Seed,
76}
77const FIELDS: [Field; 4] = [Field::Model, Field::Prompt, Field::Directory, Field::Seed];
78
79#[derive(Debug)]
80enum Status {
81 Idle,
82 Running(Instant),
83 Done(Box<NativeOutcome>),
84 Failed(String),
85 Cancelled,
86}
87
88pub struct GenerateView {
89 pub rows: Vec<ModelRow>,
90 pub selected: usize,
91 pub prompt: String,
92 pub directory: String,
93 pub seed: String,
94 pub focus: Field,
95 pub port: u16,
96 pub bypass: bool,
97 pub output_dir: PathBuf,
98 log: VecDeque<String>,
99 status: Status,
100 error: Option<String>,
101 pub saved: Vec<PathBuf>,
102}
103
104#[derive(Debug, PartialEq, Eq)]
105pub enum Action {
106 Continue,
107 Submit,
108 Cancel,
109 Exit(u8),
110}
111
112impl GenerateView {
113 pub fn new(rows: Vec<ModelRow>, output_dir: PathBuf) -> Self {
114 Self {
115 rows,
116 selected: 0,
117 prompt: String::new(),
118 directory: String::new(),
119 seed: String::new(),
120 focus: Field::Prompt,
121 port: rigspark_runtime::generation::DEFAULT_PORT,
122 bypass: false,
123 output_dir,
124 log: VecDeque::new(),
125 status: Status::Idle,
126 error: None,
127 saved: Vec::new(),
128 }
129 }
130 pub fn select(&mut self, query: &str) {
132 if let Some(index) = self
133 .rows
134 .iter()
135 .position(|row| row.id == query)
136 .or_else(|| {
137 self.rows
138 .iter()
139 .position(|row| row.kind == query && row.default)
140 })
141 {
142 self.selected = index;
143 }
144 }
145 pub fn running(&self) -> bool {
146 matches!(self.status, Status::Running(_))
147 }
148 pub fn status_text(&self) -> String {
149 match &self.status {
150 Status::Idle => "Ready".into(),
151 Status::Running(started) => {
152 format!("Generating… {:.0}s", started.elapsed().as_secs_f64())
153 }
154 Status::Done(outcome) => format!(
155 "Saved {}: {} (seed {})",
156 outcome.result.kind.name(),
157 outcome.result.path.display(),
158 outcome.result.seed
159 ),
160 Status::Failed(error) => format!("Failed: {error}"),
161 Status::Cancelled => "Cancelled".into(),
162 }
163 }
164 pub fn log_lines(&self) -> impl Iterator<Item = &String> {
165 self.log.iter()
166 }
167 fn push_log(&mut self, line: String) {
168 let line: String = strip_control(&line).chars().take(512).collect();
169 if self.log.len() == LOG_LINES {
170 self.log.pop_front();
171 }
172 self.log.push_back(line);
173 }
174 fn insert(&mut self, text: &str) {
175 let (field, limit) = match self.focus {
176 Field::Model => return,
177 Field::Prompt => (&mut self.prompt, MAX_PROMPT_BYTES),
178 Field::Directory => (&mut self.directory, 4096),
179 Field::Seed => (&mut self.seed, 16),
180 };
181 for ch in text.chars() {
182 let allowed = match self.focus {
183 Field::Seed => ch.is_ascii_digit(),
184 Field::Prompt => !ch.is_control() || ch == '\n',
185 _ => !ch.is_control(),
186 };
187 if allowed && field.len() + ch.len_utf8() <= limit {
188 field.push(ch);
189 }
190 }
191 }
192 pub fn options(&self) -> Result<NativeOptions, String> {
194 let row = self
195 .rows
196 .get(self.selected)
197 .ok_or("no generation model selected")?;
198 if self.prompt.trim().is_empty() {
199 return Err("enter a prompt".into());
200 }
201 if self.directory.trim().is_empty() {
202 return Err("enter your ComfyUI directory".into());
203 }
204 let seed = if self.seed.is_empty() {
205 None
206 } else {
207 Some(
208 self.seed
209 .parse::<u64>()
210 .ok()
211 .filter(|seed| *seed <= MAX_SEED)
212 .ok_or("seed must be in 0..=9007199254740991")?,
213 )
214 };
215 if row.verdict == "no" && !self.bypass {
216 return Err(format!(
217 "{} does not fit this machine ({}); restart with --bypass to try anyway",
218 row.id, row.reason
219 ));
220 }
221 Ok(NativeOptions {
222 model: row.id.clone(),
223 prompt: self.prompt.clone(),
224 seed,
225 comfyui_dir: PathBuf::from(self.directory.trim()),
226 port: self.port,
227 bypass: self.bypass,
228 output: None,
229 output_dir: self.output_dir.clone(),
230 })
231 }
232}
233
234pub fn handle_key(view: &mut GenerateView, key: KeyEvent) -> Action {
235 if key.kind == KeyEventKind::Release {
236 return Action::Continue;
237 }
238 let control = key.modifiers.contains(KeyModifiers::CONTROL);
239 if control && key.code == KeyCode::Char('c') {
240 return if view.running() {
241 Action::Cancel
242 } else {
243 Action::Exit(130)
244 };
245 }
246 if key.code == KeyCode::Esc {
247 return if view.running() {
248 Action::Cancel
249 } else {
250 Action::Exit(0)
251 };
252 }
253 if view.running() {
254 return Action::Continue;
255 }
256 let position = FIELDS
257 .iter()
258 .position(|field| *field == view.focus)
259 .unwrap_or(0);
260 match key.code {
261 KeyCode::Tab => view.focus = FIELDS[(position + 1) % FIELDS.len()],
262 KeyCode::BackTab => view.focus = FIELDS[(position + FIELDS.len() - 1) % FIELDS.len()],
263 KeyCode::Up if view.focus == Field::Model => {
264 view.selected = view.selected.saturating_sub(1);
265 }
266 KeyCode::Down if view.focus == Field::Model => {
267 view.selected = (view.selected + 1).min(view.rows.len().saturating_sub(1));
268 }
269 KeyCode::Enter if control || key.modifiers.contains(KeyModifiers::ALT) => {
270 view.insert("\n");
271 }
272 KeyCode::Char('j') if control => view.insert("\n"),
273 KeyCode::Enter => return Action::Submit,
274 KeyCode::Backspace => {
275 let field = match view.focus {
276 Field::Model => return Action::Continue,
277 Field::Prompt => &mut view.prompt,
278 Field::Directory => &mut view.directory,
279 Field::Seed => &mut view.seed,
280 };
281 field.pop();
282 }
283 KeyCode::Char(ch) if !control => view.insert(&ch.to_string()),
284 _ => (),
285 }
286 view.error = None;
287 Action::Continue
288}
289
290fn verdict_badge(theme: Theme, verdict: &str) -> Span<'static> {
291 Span::styled(format!(" {verdict:>4} "), theme.verdict(verdict))
292}
293
294pub fn render(frame: &mut Frame<'_>, view: &GenerateView, color: bool) {
295 let theme = Theme::new(color);
296 let area = frame.area();
297 let model_height = (view.rows.len() as u16 + 2).min(8);
298 let [header, models, prompt, settings, status, log, footer] = Layout::vertical([
299 Constraint::Length(1),
300 Constraint::Length(model_height),
301 Constraint::Length(5),
302 Constraint::Length(3),
303 Constraint::Length(1),
304 Constraint::Min(3),
305 Constraint::Length(1),
306 ])
307 .areas(area);
308 theme.header(
309 frame,
310 header,
311 "rigspark / generate",
312 "ComfyUI · local only · speed unknown",
313 );
314 let focused = |field: Field| {
315 if view.focus == field && !view.running() {
316 "▸ "
317 } else {
318 ""
319 }
320 };
321 let inner = theme.panel(frame, models, &format!("{}Model", focused(Field::Model)));
322 let rows: Vec<Line> = view
323 .rows
324 .iter()
325 .enumerate()
326 .map(|(index, row)| {
327 let marker = if index == view.selected {
328 "● "
329 } else {
330 "○ "
331 };
332 let style = if index == view.selected {
333 theme.selection()
334 } else {
335 Style::default()
336 };
337 Line::from(vec![
338 Span::styled(marker, theme.accent()),
339 Span::styled(format!("{:<20}", row.id), style),
340 Span::styled(format!(" {:<6}", row.kind), theme.muted()),
341 Span::styled(format!(" {:>5}", row.params), theme.muted()),
342 Span::styled(format!(" {:>5.1} GiB ", row.weights_gib), theme.muted()),
343 verdict_badge(theme, row.verdict),
344 Span::styled(format!(" {}", row.reason), theme.muted()),
345 ])
346 })
347 .collect();
348 frame.render_widget(Paragraph::new(rows), inner);
349 let inner = theme.panel(frame, prompt, &format!("{}Prompt", focused(Field::Prompt)));
350 let mut text = strip_control(&view.prompt.replace('\n', " ⏎ "));
351 if view.focus == Field::Prompt && !view.running() {
352 text.push('▌');
353 }
354 let prompt_line = if view.prompt.is_empty() && view.focus != Field::Prompt {
355 Line::styled("Describe the image or video", theme.muted())
356 } else {
357 Line::raw(text)
358 };
359 frame.render_widget(
360 Paragraph::new(prompt_line).wrap(Wrap { trim: false }),
361 inner,
362 );
363 let [directory, seed] =
364 Layout::horizontal([Constraint::Min(20), Constraint::Length(26)]).areas(settings);
365 for (area, field, title, value, placeholder) in [
366 (
367 directory,
368 Field::Directory,
369 "ComfyUI directory",
370 &view.directory,
371 "path to your ComfyUI install",
372 ),
373 (seed, Field::Seed, "Seed", &view.seed, "random"),
374 ] {
375 let inner = theme.panel(frame, area, &format!("{}{title}", focused(field)));
376 let mut value = strip_control(value);
377 let line = if value.is_empty() && view.focus != field {
378 Line::styled(placeholder, theme.muted())
379 } else {
380 if view.focus == field && !view.running() {
381 value.push('▌');
382 }
383 let width = usize::from(inner.width.max(1));
384 let skip = value.chars().count().saturating_sub(width);
385 Line::raw(value.chars().skip(skip).collect::<String>())
386 };
387 frame.render_widget(Paragraph::new(line), inner);
388 }
389 let status_line = if let Some(error) = &view.error {
390 Line::styled(format!(" {error}"), theme.error())
391 } else {
392 let style = match view.status {
393 Status::Running(_) => theme.warning(),
394 Status::Done(_) => theme.success(),
395 Status::Failed(_) => theme.error(),
396 _ => theme.muted(),
397 };
398 Line::styled(format!(" {}", strip_control(&view.status_text())), style)
399 };
400 theme.bar(
401 frame,
402 status,
403 status_line,
404 Line::styled(
405 format!(
406 "port {}{} ",
407 view.port,
408 if view.bypass { " · bypass" } else { "" }
409 ),
410 theme.muted(),
411 ),
412 );
413 let inner = theme.panel(frame, log, "Progress");
414 let visible = usize::from(inner.height);
415 let lines: Vec<Line> = view
416 .log
417 .iter()
418 .skip(view.log.len().saturating_sub(visible))
419 .map(|line| Line::raw(line.clone()))
420 .collect();
421 frame.render_widget(Paragraph::new(lines), inner);
422 let hints: &[(&str, &str)] = if view.running() {
423 &[("Esc", "cancel"), ("Ctrl+C", "cancel")]
424 } else {
425 &[
426 ("Enter", "generate"),
427 ("Tab", "next field"),
428 ("↑/↓", "model"),
429 ("Ctrl+J", "newline"),
430 ("Esc", "exit"),
431 ]
432 };
433 frame.render_widget(Paragraph::new(theme.hints(hints, footer.width)), footer);
434}
435
436fn draw<B: Backend>(
437 terminal: &mut Terminal<B>,
438 view: &GenerateView,
439 color: bool,
440) -> io::Result<()> {
441 terminal
442 .draw(|frame| render(frame, view, color))
443 .map(|_| ())
444 .map_err(|error| io::Error::other(error.to_string()))
445}
446
447pub async fn drive<B: Backend>(
449 terminal: &mut Terminal<B>,
450 events: &mut (impl Stream<Item = io::Result<Event>> + Unpin),
451 generator: &dyn Generator,
452 view: &mut GenerateView,
453 color: bool,
454) -> io::Result<u8> {
455 loop {
456 draw(terminal, view, color)?;
457 let event = events
458 .next()
459 .await
460 .ok_or_else(|| io::Error::other("terminal input ended"))??;
461 let action = match event {
462 Event::Key(key) => handle_key(view, key),
463 Event::Paste(text) => {
464 view.insert(&text);
465 Action::Continue
466 }
467 _ => Action::Continue,
468 };
469 match action {
470 Action::Exit(code) => return Ok(code),
471 Action::Continue | Action::Cancel => continue,
472 Action::Submit => (),
473 }
474 let options = match view.options() {
475 Ok(options) => options,
476 Err(error) => {
477 view.error = Some(error);
478 continue;
479 }
480 };
481 view.log.clear();
482 view.push_log(format!(
483 "Starting {} with seed {}",
484 options.model,
485 options
486 .seed
487 .map_or_else(|| "random".to_owned(), |seed| seed.to_string())
488 ));
489 view.status = Status::Running(Instant::now());
490 let (sender, mut progress) = tokio::sync::mpsc::unbounded_channel::<String>();
491 let sink: Events = Arc::new(move |message| {
492 let _ = sender.send(message);
493 });
494 let cancel = CancellationToken::new();
495 let operation = generator.generate(options, sink, cancel.clone());
496 tokio::pin!(operation);
497 let mut exit_after = None;
498 let result = loop {
499 draw(terminal, view, color)?;
500 tokio::select! {
501 biased;
502 result = &mut operation => break result,
503 Some(message) = progress.recv() => view.push_log(message),
504 () = tokio::time::sleep(Duration::from_millis(250)) => (),
505 event = events.next() => {
506 let event = event.ok_or_else(|| io::Error::other("terminal input ended"))??;
507 if let Event::Key(key) = event {
508 match handle_key(view, key) {
509 Action::Cancel if !cancel.is_cancelled() => {
510 if key.modifiers.contains(KeyModifiers::CONTROL) {
511 exit_after = Some(130);
512 }
513 view.push_log("Cancelling: removing the queued ComfyUI prompt…".into());
514 cancel.cancel();
515 }
516 Action::Exit(code) => exit_after = Some(code),
517 _ => (),
518 }
519 }
520 },
521 }
522 };
523 while let Ok(message) = progress.try_recv() {
524 view.push_log(message);
525 }
526 view.status = match result {
527 Ok(outcome) => {
528 view.push_log(format!("Saved {}", outcome.result.path.display()));
529 view.saved.push(outcome.result.path.clone());
530 Status::Done(Box::new(outcome))
531 }
532 Err(_) if cancel.is_cancelled() => Status::Cancelled,
533 Err(error) => Status::Failed(error.to_string()),
534 };
535 if let Some(code) = exit_after {
536 return Ok(code);
537 }
538 }
539}
540
541pub async fn run(
542 view: &mut GenerateView,
543 generator: &dyn Generator,
544 color: bool,
545) -> io::Result<u8> {
546 let mut signals = crate::cancellation::TerminalSignals::new()?;
547 let (mut terminal, _restore) = crate::tui_view::enter_terminal()?;
548 let mut events = crate::terminal_events::terminal_events();
549 tokio::select! {
550 result = drive(&mut terminal, &mut events, generator, view, color) => result,
551 result = signals.recv() => result,
552 }
553}