tuillem-tui 0.1.4

Ratatui TUI layer for tuillem
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

pub mod app;
pub mod commands;
pub mod control;
pub mod conversation;
pub mod help;
pub mod input;
pub mod settings;
pub mod sidebar;
pub mod theme;

use std::time::Duration;

use crossterm::{
    event::{
        self, DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture,
        Event as CrosstermEvent, KeyboardEnhancementFlags, PopKeyboardEnhancementFlags,
        PushKeyboardEnhancementFlags,
    },
    execute,
    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use ratatui::{Terminal, backend::CrosstermBackend};
use tokio::sync::mpsc;
use tuillem_core::actions::Event;

use tracing::debug;

use crate::app::App;

pub async fn run(
    mut app: App,
    mut event_rx: mpsc::UnboundedReceiver<Event>,
    mouse_enabled: bool,
) -> anyhow::Result<()> {
    // Check minimum terminal size (60x20)
    let (cols, rows) = crossterm::terminal::size()?;
    if cols < 60 || rows < 20 {
        anyhow::bail!("Terminal too small ({cols}x{rows}). Minimum size is 60x20.");
    }

    // Setup terminal
    enable_raw_mode()?;
    let mut stdout = std::io::stdout();

    // Enable keyboard enhancement for Shift+Enter detection
    let keyboard_enhanced = execute!(
        stdout,
        PushKeyboardEnhancementFlags(KeyboardEnhancementFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES)
    )
    .is_ok();

    if mouse_enabled {
        execute!(
            stdout,
            EnterAlternateScreen,
            EnableMouseCapture,
            EnableBracketedPaste
        )?;
    } else {
        execute!(stdout, EnterAlternateScreen, EnableBracketedPaste)?;
    }
    let backend = CrosstermBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

    // Main loop
    loop {
        // Force full redraw if needed (e.g. after external editor)
        if app.needs_redraw {
            terminal.clear()?;
            app.needs_redraw = false;
        }

        // Draw
        terminal.draw(|frame| {
            app.draw(frame);
        })?;

        // Process backend events (non-blocking)
        let mut event_count = 0;
        while let Ok(event) = event_rx.try_recv() {
            debug!("TUI received event: {:?}", event);
            app.apply_event(&event);
            event_count += 1;
        }
        if event_count > 0 {
            debug!("TUI processed {} events this frame", event_count);
        }

        // Poll terminal events with 16ms timeout (~60fps)
        if event::poll(Duration::from_millis(16))? {
            match event::read()? {
                CrosstermEvent::Key(key) => {
                    app.handle_key_event(key);
                }
                CrosstermEvent::Mouse(mouse) => {
                    app.handle_mouse_event(mouse);
                }
                CrosstermEvent::Paste(text) => {
                    app.handle_paste(text);
                }
                _ => {}
            }
        }

        if app.should_quit {
            break;
        }
    }

    // Cleanup
    if keyboard_enhanced {
        let _ = execute!(terminal.backend_mut(), PopKeyboardEnhancementFlags);
    }
    disable_raw_mode()?;
    if mouse_enabled {
        execute!(
            terminal.backend_mut(),
            DisableMouseCapture,
            DisableBracketedPaste,
            LeaveAlternateScreen
        )?;
    } else {
        execute!(
            terminal.backend_mut(),
            DisableBracketedPaste,
            LeaveAlternateScreen
        )?;
    }
    terminal.show_cursor()?;

    Ok(())
}