Skip to main content

rigspark_cli/
tui_models.rs

1use crate::{
2    accessible_catalog::CatalogPresentation,
3    accessible_installed::{InstalledCommand, InstalledView},
4    accessible_read_only::can_run_screen,
5    accessible_recommend::Recommendation,
6    accessible_text::{identifier, single_line},
7};
8use crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
9use ratatui::{
10    Frame,
11    layout::{Constraint, Layout, Rect},
12    style::{Color, Modifier, Style},
13    text::{Line, Span},
14    widgets::{Block, Borders, List, ListItem, ListState, Paragraph},
15};
16use rigspark_core::reports::strip_control;
17use serde::Deserialize;
18use serde_json::Value;
19use std::io;
20use unicode_segmentation::UnicodeSegmentation;
21
22const MAX_ROWS: usize = 1000;
23const MAX_TEXT: usize = 64 * 1024;
24const MAX_DOCUMENT: usize = 4 * 1024 * 1024;
25const MAX_QUERY: usize = 256;
26const MAX_MARKED: usize = 4;
27
28#[derive(Deserialize)]
29#[serde(rename_all = "camelCase")]
30struct CanRunMetadata<'evidence> {
31    model_id: &'evidence str,
32    runnable: &'evidence str,
33    quant: Option<&'evidence str>,
34    reason: Option<&'evidence str>,
35    throughput_backend: &'evidence str,
36    context: Option<f64>,
37}
38
39fn bound_can_run(value: &Value, depth: usize, budget: &mut usize) -> io::Result<()> {
40    let invalid = || {
41        io::Error::new(
42            io::ErrorKind::InvalidInput,
43            "can-run view input limit exceeded",
44        )
45    };
46    if depth > 16 {
47        return Err(invalid());
48    }
49    *budget = budget.checked_sub(64).ok_or_else(invalid)?;
50    match value {
51        Value::String(text) => {
52            if text.len() > MAX_TEXT {
53                return Err(invalid());
54            }
55            *budget = budget.checked_sub(text.len()).ok_or_else(invalid)?;
56        }
57        Value::Array(values) => {
58            if values.len() > MAX_ROWS {
59                return Err(invalid());
60            }
61            for value in values {
62                bound_can_run(value, depth + 1, budget)?;
63            }
64        }
65        Value::Object(values) => {
66            if values.len() > MAX_ROWS {
67                return Err(invalid());
68            }
69            for (key, value) in values {
70                if key.len() > MAX_TEXT {
71                    return Err(invalid());
72                }
73                *budget = budget.checked_sub(key.len()).ok_or_else(invalid)?;
74                bound_can_run(value, depth + 1, budget)?;
75            }
76        }
77        _ => (),
78    }
79    Ok(())
80}
81
82#[derive(Debug)]
83pub struct ModelRow {
84    label: String,
85    summary: String,
86    search: String,
87    evidence: String,
88}
89
90fn bounded_text(value: &str, limit: usize) -> io::Result<String> {
91    if value.len() > limit {
92        return Err(io::Error::new(
93            io::ErrorKind::InvalidInput,
94            "model view text limit exceeded",
95        ));
96    }
97    Ok(strip_control(value)
98        .chars()
99        .filter(|character| !character.is_control())
100        .collect())
101}
102
103impl ModelRow {
104    pub fn new(label: &str, search: &str, evidence: &str) -> io::Result<Self> {
105        Ok(Self {
106            label: bounded_text(label, 1024)?,
107            summary: String::new(),
108            search: bounded_text(search, MAX_TEXT)?.to_lowercase(),
109            evidence: bounded_evidence(evidence)?,
110        })
111    }
112
113    pub fn label(&self) -> &str {
114        &self.label
115    }
116}
117
118fn bounded_evidence(value: &str) -> io::Result<String> {
119    if value.len() > MAX_TEXT {
120        return Err(io::Error::new(
121            io::ErrorKind::InvalidInput,
122            "model view text limit exceeded",
123        ));
124    }
125    value
126        .lines()
127        .map(|line| bounded_text(line, MAX_TEXT))
128        .collect::<io::Result<Vec<_>>>()
129        .map(|lines| lines.join("\n"))
130}
131
132#[derive(Debug, PartialEq, Eq)]
133pub enum ModelOutcome {
134    Exit { code: u8 },
135    PrintCommand { command: String },
136}
137
138#[derive(Clone, Copy, PartialEq, Eq)]
139enum Focus {
140    List,
141    Detail,
142    Overview,
143    Help,
144    Compare,
145}
146
147pub struct ModelView {
148    title: String,
149    overview: Vec<String>,
150    rows: Vec<ModelRow>,
151    visible: Vec<usize>,
152    list: ListState,
153    query: String,
154    searching: bool,
155    focus: Focus,
156    help_return: Option<(Focus, usize, usize)>,
157    marked: Vec<usize>,
158    notice: Option<&'static str>,
159    scroll: usize,
160    scroll_max: usize,
161    page: usize,
162    detail_page: usize,
163    color: bool,
164    command: Option<String>,
165    comparison: bool,
166}
167
168impl ModelView {
169    pub fn new(
170        title: &str,
171        overview: Vec<String>,
172        rows: Vec<ModelRow>,
173        color: bool,
174    ) -> io::Result<Self> {
175        if rows.len() > MAX_ROWS || overview.len() > MAX_ROWS + 8 {
176            return Err(io::Error::new(
177                io::ErrorKind::InvalidInput,
178                "model view row limit exceeded",
179            ));
180        }
181        let bytes = rows
182            .iter()
183            .map(|row| row.label.len() + row.summary.len() + row.search.len() + row.evidence.len())
184            .sum::<usize>()
185            + overview.iter().map(String::len).sum::<usize>();
186        if bytes > MAX_DOCUMENT {
187            return Err(io::Error::new(
188                io::ErrorKind::InvalidInput,
189                "model view document limit exceeded",
190            ));
191        }
192        let overview = overview
193            .iter()
194            .map(|line| bounded_text(line, MAX_TEXT))
195            .collect::<io::Result<_>>()?;
196        let selection = if rows.is_empty() { None } else { Some(0) };
197        Ok(Self {
198            title: bounded_text(title, 256)?,
199            overview,
200            visible: (0..rows.len()).collect(),
201            rows,
202            list: ListState::default().with_selected(selection),
203            query: String::new(),
204            searching: false,
205            focus: Focus::List,
206            help_return: None,
207            marked: Vec::new(),
208            notice: None,
209            scroll: 0,
210            scroll_max: 0,
211            page: 1,
212            detail_page: 1,
213            color,
214            command: None,
215            comparison: true,
216        })
217    }
218
219    pub fn from_catalog(presentation: &CatalogPresentation, color: bool) -> io::Result<Self> {
220        Self::new(
221            "Catalog",
222            presentation.visual_overview(),
223            adapt_rows(presentation.visual_rows())?,
224            color,
225        )
226    }
227
228    pub fn from_recommendation(presentation: &Recommendation, color: bool) -> io::Result<Self> {
229        let mut view = Self::new(
230            "Recommend",
231            presentation.visual_overview(),
232            adapt_rows(presentation.visual_rows())?,
233            color,
234        )?;
235        view.command = presentation.print_command().map(str::to_owned);
236        Ok(view)
237    }
238
239    pub fn from_installed(presentation: &InstalledView, color: bool) -> io::Result<Self> {
240        let title = match presentation.command() {
241            InstalledCommand::Recommend => "Recommend / Installed",
242            InstalledCommand::CanRun => "Can Run / Installed",
243        };
244        let rows = presentation
245            .visual_rows()
246            .map(|(label, fit, search, evidence)| {
247                let mut row = ModelRow::new(label, search, evidence)?;
248                row.summary = format!("Fit: {fit}");
249                Ok(row)
250            })
251            .collect::<io::Result<Vec<_>>>()?;
252        let mut view = Self::new(title, presentation.visual_overview(), rows, color)?;
253        view.comparison =
254            presentation.command() == InstalledCommand::Recommend && view.rows.len() >= 2;
255        if view.rows.is_empty() {
256            view.focus(Focus::Overview);
257        } else if presentation.command() == InstalledCommand::CanRun {
258            view.focus(Focus::Detail);
259        }
260        Ok(view)
261    }
262
263    pub fn from_can_run(evidence: &Value, color: bool) -> io::Result<Self> {
264        let mut budget = MAX_DOCUMENT;
265        bound_can_run(evidence, 0, &mut budget)?;
266        let screen = can_run_screen(evidence)?;
267        let metadata = CanRunMetadata::deserialize(evidence).map_err(io::Error::other)?;
268        if metadata.model_id.len() > 1024 {
269            return Err(io::Error::new(
270                io::ErrorKind::InvalidInput,
271                "model view text limit exceeded",
272            ));
273        }
274        let label = identifier(metadata.model_id)?;
275        let summary = single_line(&format!(
276            "Verdict: {}; quant {}; reason {}",
277            metadata.runnable,
278            metadata.quant.unwrap_or("unknown"),
279            metadata.reason.unwrap_or("none"),
280        ))?;
281        let search = single_line(&format!(
282            "{} {} {}",
283            metadata.model_id, summary, metadata.throughput_backend,
284        ))?;
285        let mut row = ModelRow::new(&label, &search, &screen)?;
286        row.summary = bounded_text(&summary, 2048)?;
287        let context = metadata.context.map_or_else(
288            || "Requested context: not specified".into(),
289            |context| format!("Requested context: {context} tokens"),
290        );
291        let mut view = Self::new(
292            "Can Run",
293            vec![
294                format!("Verdict: {} / offline evidence", metadata.runnable),
295                context,
296            ],
297            vec![row],
298            color,
299        )?;
300        view.comparison = false;
301        view.focus(Focus::Detail);
302        Ok(view)
303    }
304
305    pub fn selected(&self) -> Option<&ModelRow> {
306        self.list
307            .selected()
308            .and_then(|index| self.visible.get(index))
309            .map(|index| &self.rows[*index])
310    }
311
312    pub fn visible_count(&self) -> usize {
313        self.visible.len()
314    }
315
316    pub fn detail_focused(&self) -> bool {
317        self.focus == Focus::Detail
318    }
319
320    fn filter(&mut self) {
321        let selected = self
322            .list
323            .selected()
324            .and_then(|index| self.visible.get(index))
325            .copied();
326        let needle = self.query.to_lowercase();
327        self.visible = self
328            .rows
329            .iter()
330            .enumerate()
331            .filter(|(_, row)| row.search.contains(&needle))
332            .map(|(index, _)| index)
333            .collect();
334        let position = selected
335            .and_then(|selected| self.visible.iter().position(|index| *index == selected))
336            .or_else(|| (!self.visible.is_empty()).then_some(0));
337        self.list.select(position);
338        *self.list.offset_mut() = 0;
339        self.scroll = 0;
340    }
341
342    fn move_to(&mut self, position: usize) {
343        if self.focus != Focus::List {
344            self.scroll = position.min(self.scroll_max);
345        } else if !self.visible.is_empty() {
346            self.list.select(Some(position.min(self.visible.len() - 1)));
347            self.scroll = 0;
348        }
349    }
350
351    fn focus(&mut self, focus: Focus) {
352        self.focus = focus;
353        self.scroll = 0;
354        self.scroll_max = 0;
355    }
356
357    fn append_query(&mut self, text: &str) {
358        let available = MAX_QUERY.saturating_sub(self.query.len());
359        let mut bytes = 0;
360        let prefix: String = text
361            .chars()
362            .take_while(|character| {
363                bytes += character.len_utf8();
364                bytes <= available
365            })
366            .collect();
367        let clean = strip_control(&prefix);
368        self.query
369            .extend(clean.chars().filter(|character| !character.is_control()));
370        self.filter();
371    }
372
373    fn toggle_help(&mut self) {
374        if let Some((focus, scroll, scroll_max)) = self.help_return.take() {
375            self.focus = focus;
376            self.scroll = scroll;
377            self.scroll_max = scroll_max;
378        } else {
379            self.help_return = Some((self.focus, self.scroll, self.scroll_max));
380            self.focus(Focus::Help);
381        }
382    }
383
384    fn toggle_mark(&mut self) {
385        let Some(index) = self
386            .list
387            .selected()
388            .and_then(|index| self.visible.get(index))
389            .copied()
390        else {
391            self.notice = Some("No model selected to mark");
392            return;
393        };
394        if let Some(position) = self.marked.iter().position(|marked| *marked == index) {
395            self.marked.remove(position);
396            self.notice = None;
397        } else if self.marked.len() == MAX_MARKED {
398            self.notice = Some("Mark limit 4: unmark a model with Space");
399        } else {
400            self.marked.push(index);
401            self.notice = None;
402        }
403    }
404}
405
406fn adapt_rows<'row>(
407    rows: impl Iterator<Item = (&'row str, &'row str, &'row str, &'row str)>,
408) -> io::Result<Vec<ModelRow>> {
409    rows.map(|(label, summary, search, evidence)| {
410        let mut row = ModelRow::new(label, search, evidence)?;
411        row.summary = bounded_text(summary, 2048)?;
412        Ok(row)
413    })
414    .collect()
415}
416
417pub fn handle_key(view: &mut ModelView, key: KeyEvent) -> Option<ModelOutcome> {
418    if key.kind == KeyEventKind::Release {
419        return None;
420    }
421    if key.modifiers.contains(KeyModifiers::CONTROL) {
422        match key.code {
423            KeyCode::Char('c') => return Some(ModelOutcome::Exit { code: 130 }),
424            KeyCode::Char('u') if view.focus != Focus::Help => {
425                view.query.clear();
426                view.filter();
427            }
428            _ => (),
429        }
430        return None;
431    }
432    if key
433        .modifiers
434        .intersects(KeyModifiers::ALT | KeyModifiers::SUPER)
435    {
436        return None;
437    }
438    if view.searching {
439        match key.code {
440            KeyCode::Esc | KeyCode::Enter => view.searching = false,
441            KeyCode::Backspace | KeyCode::Delete => {
442                if let Some((index, _)) = view.query.grapheme_indices(true).next_back() {
443                    view.query.truncate(index);
444                }
445                view.filter();
446            }
447            KeyCode::Char(character) if !character.is_control() => {
448                view.append_query(&character.to_string())
449            }
450            _ => (),
451        }
452        return None;
453    }
454    if view.focus == Focus::Help {
455        match key.code {
456            KeyCode::Esc | KeyCode::Left | KeyCode::Backspace => {
457                view.toggle_help();
458                return None;
459            }
460            KeyCode::Char('?' | 'q' | 'j' | 'k' | 'p')
461            | KeyCode::Up
462            | KeyCode::Down
463            | KeyCode::PageUp
464            | KeyCode::PageDown
465            | KeyCode::Home
466            | KeyCode::End => (),
467            _ => return None,
468        }
469    }
470    let position = if view.focus == Focus::List {
471        view.list.selected().unwrap_or(0)
472    } else {
473        view.scroll
474    };
475    let page = if view.focus == Focus::List {
476        view.page
477    } else {
478        view.detail_page
479    };
480    match key.code {
481        KeyCode::Char('q') => return Some(ModelOutcome::Exit { code: 0 }),
482        KeyCode::Char('?') if key.kind == KeyEventKind::Press => view.toggle_help(),
483        KeyCode::Char(' ')
484            if key.kind == KeyEventKind::Press
485                && view.comparison
486                && matches!(view.focus, Focus::List | Focus::Detail) =>
487        {
488            view.toggle_mark()
489        }
490        KeyCode::Char('c') if key.kind == KeyEventKind::Press && view.comparison => {
491            if view.focus == Focus::Compare {
492                view.focus(Focus::List);
493            } else if view.marked.len() < 2 {
494                view.notice = Some("Mark at least 2 models with Space to compare (max 4)");
495            } else {
496                view.notice = None;
497                view.focus(Focus::Compare);
498            }
499        }
500        KeyCode::Esc if view.focus == Focus::List => return Some(ModelOutcome::Exit { code: 0 }),
501        KeyCode::Esc | KeyCode::Left | KeyCode::Backspace => view.focus(Focus::List),
502        KeyCode::Enter | KeyCode::Tab | KeyCode::BackTab => {
503            if view.focus == Focus::List && view.selected().is_some() {
504                view.focus(Focus::Detail);
505            } else {
506                view.focus(Focus::List);
507            }
508        }
509        KeyCode::Right if view.selected().is_some() => view.focus(Focus::Detail),
510        KeyCode::Char('i') => view.focus(if view.focus == Focus::Overview {
511            Focus::List
512        } else {
513            Focus::Overview
514        }),
515        KeyCode::Char('/') => {
516            view.searching = true;
517            view.focus(Focus::List);
518        }
519        KeyCode::Down | KeyCode::Char('j') => view.move_to(position.saturating_add(1)),
520        KeyCode::Up | KeyCode::Char('k') => view.move_to(position.saturating_sub(1)),
521        KeyCode::PageDown => view.move_to(position.saturating_add(page)),
522        KeyCode::PageUp => view.move_to(position.saturating_sub(page)),
523        KeyCode::Home => view.move_to(0),
524        KeyCode::End => view.move_to(usize::MAX),
525        KeyCode::Char('p') if key.kind == KeyEventKind::Press => {
526            return view
527                .command
528                .as_ref()
529                .map(|command| ModelOutcome::PrintCommand {
530                    command: command.clone(),
531                });
532        }
533        _ => (),
534    }
535    None
536}
537
538pub fn handle_event(view: &mut ModelView, event: Event) -> Option<ModelOutcome> {
539    match event {
540        Event::Key(key) => handle_key(view, key),
541        Event::Paste(text) if view.searching => {
542            view.append_query(&text);
543            None
544        }
545        _ => None,
546    }
547}
548
549fn wrap_lines<'line>(lines: impl Iterator<Item = &'line str>, width: u16) -> Vec<String> {
550    let width = usize::from(width.max(1));
551    let mut result = Vec::new();
552    for line in lines {
553        let mut chunk = String::new();
554        let mut used = 0;
555        for grapheme in line.graphemes(true) {
556            let cells = Span::raw(grapheme).width();
557            if used + cells > width && !chunk.is_empty() {
558                result.push(std::mem::take(&mut chunk));
559                used = 0;
560            }
561            if cells > width {
562                chunk.push('?');
563                used += 1;
564            } else {
565                chunk.push_str(grapheme);
566                used += cells;
567            }
568        }
569        result.push(chunk);
570    }
571    result
572}
573
574fn render_detail(frame: &mut Frame<'_>, view: &mut ModelView, area: Rect, accent: Style) {
575    let title = match view.focus {
576        Focus::Overview => "Machine / scope".to_owned(),
577        Focus::Help => "Keyboard help".to_owned(),
578        Focus::Compare => format!("Compare {} models", view.marked.len()),
579        _ => "Evidence".to_owned(),
580    };
581    let block = Block::default()
582        .borders(Borders::TOP)
583        .title(title)
584        .border_style(accent);
585    let inner = block.inner(area);
586    frame.render_widget(block, area);
587    let lines = if view.focus == Focus::Help {
588        let mut help = vec![
589            "Up/Down or j/k: navigate list or scroll screen",
590            "PageUp/PageDown: page; Home/End: first/last",
591            "/: search; Enter/Esc: close search; Ctrl+U: reset filter",
592            "Enter/Right/Tab: details; Left/Backspace/Esc: back",
593            "i: machine/scope; ?: toggle help",
594            "Esc: back from screen; Esc on list or q: quit",
595            "Ctrl+C: interrupt (exit 130)",
596            "Read-only: stored evidence only; no actions execute",
597        ];
598        if view.comparison {
599            help.extend([
600                "Space: mark/unmark selected model (max 4)",
601                "c: compare 2-4 marked models / return to list",
602                "Marks survive filtering; * identifies a marked model",
603            ]);
604        }
605        if view.command.is_some() {
606            help.push("p: finish and print existing top-pick command; never execute");
607        }
608        wrap_lines(help.into_iter(), inner.width)
609    } else if view.focus == Focus::Compare {
610        wrap_lines(
611            view.marked.iter().flat_map(|index| {
612                let row = &view.rows[*index];
613                std::iter::once(row.label.as_str())
614                    .chain(
615                        std::iter::once(row.summary.as_str()).filter(|summary| !summary.is_empty()),
616                    )
617                    .chain(row.evidence.lines().flat_map(|line| line.split("; ")))
618                    .chain(std::iter::once(""))
619            }),
620            inner.width,
621        )
622    } else if view.focus == Focus::Overview {
623        wrap_lines(view.overview.iter().map(String::as_str), inner.width)
624    } else if let Some(row) = view.selected() {
625        wrap_lines(
626            row.evidence.lines().flat_map(|line| line.split("; ")),
627            inner.width,
628        )
629    } else {
630        vec!["No model selected".into()]
631    };
632    view.detail_page = usize::from(inner.height.max(1));
633    view.scroll_max = lines.len().saturating_sub(view.detail_page);
634    view.scroll = view.scroll.min(view.scroll_max);
635    let visible: Vec<_> = lines
636        .into_iter()
637        .skip(view.scroll)
638        .take(view.detail_page)
639        .map(Line::from)
640        .collect();
641    frame.render_widget(Paragraph::new(visible), inner);
642}
643
644pub fn render(frame: &mut Frame<'_>, view: &mut ModelView) {
645    let area = frame.area();
646    if area.is_empty() {
647        return;
648    }
649    let accent = if view.color {
650        Style::default().fg(Color::Cyan)
651    } else {
652        Style::default()
653    };
654    let [header, context, body, search, footer] = Layout::vertical([
655        Constraint::Length(1),
656        Constraint::Length(if area.height >= 12 { 2 } else { 0 }),
657        Constraint::Min(0),
658        Constraint::Length(if area.height >= 3 { 1 } else { 0 }),
659        Constraint::Length(if area.height >= 2 { 1 } else { 0 }),
660    ])
661    .areas(area);
662    frame.render_widget(
663        Paragraph::new(format!("rigspark / {} / Read-only", view.title))
664            .style(accent.add_modifier(Modifier::BOLD)),
665        header,
666    );
667    let overview: Vec<_> = view
668        .overview
669        .iter()
670        .take(2)
671        .map(|line| Line::from(line.as_str()))
672        .collect();
673    frame.render_widget(Paragraph::new(overview), context);
674    if view.focus != Focus::List {
675        render_detail(frame, view, body, accent.add_modifier(Modifier::BOLD));
676    } else {
677        let (list_area, detail_area) = if body.width >= 80 {
678            let [list, detail] =
679                Layout::horizontal([Constraint::Percentage(45), Constraint::Percentage(55)])
680                    .areas(body);
681            (list, Some(detail))
682        } else if body.height >= 10 {
683            let [list, detail] =
684                Layout::vertical([Constraint::Percentage(50), Constraint::Percentage(50)])
685                    .areas(body);
686            (list, Some(detail))
687        } else {
688            (body, None)
689        };
690        let block = Block::default()
691            .borders(Borders::TOP)
692            .title(format!(
693                "Models ({}/{})",
694                view.visible_count(),
695                view.rows.len()
696            ))
697            .border_style(accent);
698        let inner = block.inner(list_area);
699        frame.render_widget(block, list_area);
700        let summaries = inner.height >= 4;
701        view.page = (usize::from(inner.height) / if summaries { 2 } else { 1 }).max(1);
702        let items: Vec<_> = view
703            .visible
704            .iter()
705            .map(|index| {
706                let row = &view.rows[*index];
707                let marker = if view.marked.contains(index) {
708                    "* "
709                } else {
710                    "  "
711                };
712                let mut lines = vec![Line::from(format!("{marker}{}", row.label()))];
713                if summaries {
714                    lines.push(Line::from(row.summary.as_str()));
715                }
716                ListItem::new(lines)
717            })
718            .collect();
719        if items.is_empty() {
720            frame.render_widget(Paragraph::new("No results"), inner);
721        } else {
722            frame.render_stateful_widget(
723                List::new(items)
724                    .highlight_symbol("> ")
725                    .highlight_style(accent.add_modifier(Modifier::REVERSED)),
726                inner,
727                &mut view.list,
728            );
729        }
730        if let Some(detail) = detail_area {
731            render_detail(frame, view, detail, accent);
732        }
733    }
734    let query = if view.query.is_empty() {
735        "off"
736    } else {
737        &view.query
738    };
739    let mut status = if view.searching {
740        format!("/{}|", view.query)
741    } else if let Some(notice) = view.notice {
742        notice.to_owned()
743    } else if view.focus == Focus::List {
744        format!(
745            "{}/{}  Search: {query}",
746            view.list.selected().map_or(0, |index| index + 1),
747            view.visible_count()
748        )
749    } else {
750        format!(
751            "Line {}/{}  Search: {query}",
752            view.scroll + 1,
753            view.scroll_max + 1
754        )
755    };
756    if !view.searching && view.comparison {
757        status.push_str(&format!("  Marked {}/{MAX_MARKED}", view.marked.len()));
758    }
759    frame.render_widget(Paragraph::new(status), search);
760    let controls = if view.searching {
761        "Enter/Esc close | Ctrl+U reset"
762    } else if view.focus != Focus::List {
763        "Esc back | Up/Down scroll | Home/End | ? help | q quit"
764    } else if view.command.is_some() {
765        "q quit | / search | Enter detail | Space mark | c compare | ? help | p finish/print"
766    } else if !view.comparison {
767        "q quit | / search | Enter detail | i overview | ? help"
768    } else {
769        "q quit | / search | Enter detail | Space mark | c compare | ? help"
770    };
771    frame.render_widget(Paragraph::new(controls), footer);
772}
773
774pub async fn show_models(mut view: ModelView) -> io::Result<ModelOutcome> {
775    let mut signals = crate::cancellation::TerminalSignals::new()?;
776    let (mut terminal, _restore) = crate::tui_view::enter_terminal()?;
777    let mut events = crate::terminal_events::terminal_events();
778    loop {
779        terminal.draw(|frame| render(frame, &mut view))?;
780        let event = tokio::select! {
781            code = signals.recv() => return Ok(ModelOutcome::Exit { code: code? }),
782            event = crate::tui_view::next_navigation_event(&mut events) => event?,
783        };
784        if let Some(outcome) = handle_event(&mut view, event) {
785            return Ok(outcome);
786        }
787    }
788}