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}