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 aspect: Default::default(),
226 comfyui_dir: PathBuf::from(self.directory.trim()),
227 port: self.port,
228 bypass: self.bypass,
229 output: None,
230 output_dir: self.output_dir.clone(),
231 })
232 }
233}
234
235pub fn handle_key(view: &mut GenerateView, key: KeyEvent) -> Action {
236 if key.kind == KeyEventKind::Release {
237 return Action::Continue;
238 }
239 let control = key.modifiers.contains(KeyModifiers::CONTROL);
240 if control && key.code == KeyCode::Char('c') {
241 return if view.running() {
242 Action::Cancel
243 } else {
244 Action::Exit(130)
245 };
246 }
247 if key.code == KeyCode::Esc {
248 return if view.running() {
249 Action::Cancel
250 } else {
251 Action::Exit(0)
252 };
253 }
254 if view.running() {
255 return Action::Continue;
256 }
257 let position = FIELDS
258 .iter()
259 .position(|field| *field == view.focus)
260 .unwrap_or(0);
261 match key.code {
262 KeyCode::Tab => view.focus = FIELDS[(position + 1) % FIELDS.len()],
263 KeyCode::BackTab => view.focus = FIELDS[(position + FIELDS.len() - 1) % FIELDS.len()],
264 KeyCode::Up if view.focus == Field::Model => {
265 view.selected = view.selected.saturating_sub(1);
266 }
267 KeyCode::Down if view.focus == Field::Model => {
268 view.selected = (view.selected + 1).min(view.rows.len().saturating_sub(1));
269 }
270 KeyCode::Enter if control || key.modifiers.contains(KeyModifiers::ALT) => {
271 view.insert("\n");
272 }
273 KeyCode::Char('j') if control => view.insert("\n"),
274 KeyCode::Enter => return Action::Submit,
275 KeyCode::Backspace => {
276 let field = match view.focus {
277 Field::Model => return Action::Continue,
278 Field::Prompt => &mut view.prompt,
279 Field::Directory => &mut view.directory,
280 Field::Seed => &mut view.seed,
281 };
282 field.pop();
283 }
284 KeyCode::Char(ch) if !control => view.insert(&ch.to_string()),
285 _ => (),
286 }
287 view.error = None;
288 Action::Continue
289}
290
291fn verdict_badge(theme: Theme, verdict: &str) -> Span<'static> {
292 Span::styled(format!(" {verdict:>4} "), theme.verdict(verdict))
293}
294
295pub fn render(frame: &mut Frame<'_>, view: &GenerateView, color: bool) {
296 let theme = Theme::new(color);
297 let area = frame.area();
298 let model_height = (view.rows.len() as u16 + 2).min(8);
299 let [header, models, prompt, settings, status, log, footer] = Layout::vertical([
300 Constraint::Length(1),
301 Constraint::Length(model_height),
302 Constraint::Length(5),
303 Constraint::Length(3),
304 Constraint::Length(1),
305 Constraint::Min(3),
306 Constraint::Length(1),
307 ])
308 .areas(area);
309 theme.header(
310 frame,
311 header,
312 "rigspark / generate",
313 "ComfyUI · local only · speed unknown",
314 );
315 let focused = |field: Field| {
316 if view.focus == field && !view.running() {
317 "▸ "
318 } else {
319 ""
320 }
321 };
322 let inner = theme.panel(frame, models, &format!("{}Model", focused(Field::Model)));
323 let rows: Vec<Line> = view
324 .rows
325 .iter()
326 .enumerate()
327 .map(|(index, row)| {
328 let marker = if index == view.selected {
329 "● "
330 } else {
331 "○ "
332 };
333 let style = if index == view.selected {
334 theme.selection()
335 } else {
336 Style::default()
337 };
338 Line::from(vec![
339 Span::styled(marker, theme.accent()),
340 Span::styled(format!("{:<20}", row.id), style),
341 Span::styled(format!(" {:<6}", row.kind), theme.muted()),
342 Span::styled(format!(" {:>5}", row.params), theme.muted()),
343 Span::styled(format!(" {:>5.1} GiB ", row.weights_gib), theme.muted()),
344 verdict_badge(theme, row.verdict),
345 Span::styled(format!(" {}", row.reason), theme.muted()),
346 ])
347 })
348 .collect();
349 frame.render_widget(Paragraph::new(rows), inner);
350 let inner = theme.panel(frame, prompt, &format!("{}Prompt", focused(Field::Prompt)));
351 let mut text = strip_control(&view.prompt.replace('\n', " ⏎ "));
352 if view.focus == Field::Prompt && !view.running() {
353 text.push('▌');
354 }
355 let prompt_line = if view.prompt.is_empty() && view.focus != Field::Prompt {
356 Line::styled("Describe the image or video", theme.muted())
357 } else {
358 Line::raw(text)
359 };
360 frame.render_widget(
361 Paragraph::new(prompt_line).wrap(Wrap { trim: false }),
362 inner,
363 );
364 let [directory, seed] =
365 Layout::horizontal([Constraint::Min(20), Constraint::Length(26)]).areas(settings);
366 for (area, field, title, value, placeholder) in [
367 (
368 directory,
369 Field::Directory,
370 "ComfyUI directory",
371 &view.directory,
372 "path to your ComfyUI install",
373 ),
374 (seed, Field::Seed, "Seed", &view.seed, "random"),
375 ] {
376 let inner = theme.panel(frame, area, &format!("{}{title}", focused(field)));
377 let mut value = strip_control(value);
378 let line = if value.is_empty() && view.focus != field {
379 Line::styled(placeholder, theme.muted())
380 } else {
381 if view.focus == field && !view.running() {
382 value.push('▌');
383 }
384 let width = usize::from(inner.width.max(1));
385 let skip = value.chars().count().saturating_sub(width);
386 Line::raw(value.chars().skip(skip).collect::<String>())
387 };
388 frame.render_widget(Paragraph::new(line), inner);
389 }
390 let status_line = if let Some(error) = &view.error {
391 Line::styled(format!(" {error}"), theme.error())
392 } else {
393 let style = match view.status {
394 Status::Running(_) => theme.warning(),
395 Status::Done(_) => theme.success(),
396 Status::Failed(_) => theme.error(),
397 _ => theme.muted(),
398 };
399 Line::styled(format!(" {}", strip_control(&view.status_text())), style)
400 };
401 theme.bar(
402 frame,
403 status,
404 status_line,
405 Line::styled(
406 format!(
407 "port {}{} ",
408 view.port,
409 if view.bypass { " · bypass" } else { "" }
410 ),
411 theme.muted(),
412 ),
413 );
414 let inner = theme.panel(frame, log, "Progress");
415 let visible = usize::from(inner.height);
416 let lines: Vec<Line> = view
417 .log
418 .iter()
419 .skip(view.log.len().saturating_sub(visible))
420 .map(|line| Line::raw(line.clone()))
421 .collect();
422 frame.render_widget(Paragraph::new(lines), inner);
423 let hints: &[(&str, &str)] = if view.running() {
424 &[("Esc", "cancel"), ("Ctrl+C", "cancel")]
425 } else {
426 &[
427 ("Enter", "generate"),
428 ("Tab", "next field"),
429 ("↑/↓", "model"),
430 ("Ctrl+J", "newline"),
431 ("Esc", "exit"),
432 ]
433 };
434 frame.render_widget(Paragraph::new(theme.hints(hints, footer.width)), footer);
435}
436
437fn draw<B: Backend>(
438 terminal: &mut Terminal<B>,
439 view: &GenerateView,
440 color: bool,
441) -> io::Result<()> {
442 terminal
443 .draw(|frame| render(frame, view, color))
444 .map(|_| ())
445 .map_err(|error| io::Error::other(error.to_string()))
446}
447
448pub async fn drive<B: Backend>(
450 terminal: &mut Terminal<B>,
451 events: &mut (impl Stream<Item = io::Result<Event>> + Unpin),
452 generator: &dyn Generator,
453 view: &mut GenerateView,
454 color: bool,
455) -> io::Result<u8> {
456 loop {
457 draw(terminal, view, color)?;
458 let event = events
459 .next()
460 .await
461 .ok_or_else(|| io::Error::other("terminal input ended"))??;
462 let action = match event {
463 Event::Key(key) => handle_key(view, key),
464 Event::Paste(text) => {
465 view.insert(&text);
466 Action::Continue
467 }
468 _ => Action::Continue,
469 };
470 match action {
471 Action::Exit(code) => return Ok(code),
472 Action::Continue | Action::Cancel => continue,
473 Action::Submit => (),
474 }
475 let options = match view.options() {
476 Ok(options) => options,
477 Err(error) => {
478 view.error = Some(error);
479 continue;
480 }
481 };
482 view.log.clear();
483 view.push_log(format!(
484 "Starting {} with seed {}",
485 options.model,
486 options
487 .seed
488 .map_or_else(|| "random".to_owned(), |seed| seed.to_string())
489 ));
490 view.status = Status::Running(Instant::now());
491 let (sender, mut progress) = tokio::sync::mpsc::unbounded_channel::<String>();
492 let sink: Events = Arc::new(move |message| {
493 let _ = sender.send(message);
494 });
495 let cancel = CancellationToken::new();
496 let operation = generator.generate(options, sink, cancel.clone());
497 tokio::pin!(operation);
498 let mut exit_after = None;
499 let result = loop {
500 draw(terminal, view, color)?;
501 tokio::select! {
502 biased;
503 result = &mut operation => break result,
504 Some(message) = progress.recv() => view.push_log(message),
505 () = tokio::time::sleep(Duration::from_millis(250)) => (),
506 event = events.next() => {
507 let event = event.ok_or_else(|| io::Error::other("terminal input ended"))??;
508 if let Event::Key(key) = event {
509 match handle_key(view, key) {
510 Action::Cancel if !cancel.is_cancelled() => {
511 if key.modifiers.contains(KeyModifiers::CONTROL) {
512 exit_after = Some(130);
513 }
514 view.push_log("Cancelling: removing the queued ComfyUI prompt…".into());
515 cancel.cancel();
516 }
517 Action::Exit(code) => exit_after = Some(code),
518 _ => (),
519 }
520 }
521 },
522 }
523 };
524 while let Ok(message) = progress.try_recv() {
525 view.push_log(message);
526 }
527 view.status = match result {
528 Ok(outcome) => {
529 view.push_log(format!("Saved {}", outcome.result.path.display()));
530 view.saved.push(outcome.result.path.clone());
531 Status::Done(Box::new(outcome))
532 }
533 Err(_) if cancel.is_cancelled() => Status::Cancelled,
534 Err(error) => Status::Failed(error.to_string()),
535 };
536 if let Some(code) = exit_after {
537 return Ok(code);
538 }
539 }
540}
541
542pub async fn run(
543 view: &mut GenerateView,
544 generator: &dyn Generator,
545 color: bool,
546) -> io::Result<u8> {
547 let mut signals = crate::cancellation::TerminalSignals::new()?;
548 let (mut terminal, _restore) = crate::tui_view::enter_terminal()?;
549 let mut events = crate::terminal_events::terminal_events();
550 tokio::select! {
551 result = drive(&mut terminal, &mut events, generator, view, color) => result,
552 result = signals.recv() => result,
553 }
554}