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            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
447/// Runs the form loop; each submission drives `generator` while streaming progress.
448pub 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}