Skip to main content

rigspark_cli/
tui_generate.rs

1//! Interactive terminal UI for local image/video generation through ComfyUI.
2use 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
43/// Rows for every bundled generation model with its memory-only fit on `hardware`.
44pub 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    /// Preselects `image`, `video`, or an exact model id.
131    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    /// Builds validated options or explains what is missing.
193    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
448/// Runs the form loop; each submission drives `generator` while streaming progress.
449pub 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}