imp-tui 0.2.0

Terminal UI for the imp coding agent
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
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::io::{self, Write};

use crossterm::cursor::Show;
use crossterm::event::{
    DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture,
};
use crossterm::terminal::{
    disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen,
};
use ratatui::backend::CrosstermBackend;
use ratatui::Terminal;

pub type InteractiveTerminal = Terminal<CrosstermBackend<io::Stdout>>;

pub fn set_window_title(title: &str) -> io::Result<()> {
    let mut stdout = io::stdout();
    write!(stdout, "\x1b]0;{title}\x07")?;
    stdout.flush()?;
    Ok(())
}

pub fn ring_terminal_bell() -> io::Result<()> {
    #[cfg(test)]
    {
        Ok(())
    }

    #[cfg(not(test))]
    {
        let mut stdout = io::stdout();
        write!(stdout, "\x07")?;
        stdout.flush()?;
        Ok(())
    }
}

fn restore_terminal<W: Write>(writer: &mut W) -> io::Result<()> {
    let _ = disable_raw_mode();
    write!(writer, "\x1b[0m")?;
    #[cfg(unix)]
    crossterm::execute!(
        writer,
        Show,
        LeaveAlternateScreen,
        DisableMouseCapture,
        DisableBracketedPaste
    )?;
    #[cfg(not(unix))]
    crossterm::execute!(writer, Show, LeaveAlternateScreen, DisableMouseCapture)?;
    writer.flush()?;
    Ok(())
}

fn restore_terminal_if_needed<W: Write>(writer: &mut W, restored: &mut bool) -> io::Result<()> {
    if *restored {
        Ok(())
    } else {
        *restored = true;
        restore_terminal(writer)
    }
}

pub struct TerminalSession {
    terminal: InteractiveTerminal,
    last_title: Option<String>,
    restored: bool,
}

impl TerminalSession {
    pub fn enter() -> io::Result<Self> {
        enable_raw_mode()?;
        let mut stdout = io::stdout();
        #[cfg(unix)]
        crossterm::execute!(
            stdout,
            EnterAlternateScreen,
            EnableMouseCapture,
            EnableBracketedPaste
        )?;
        #[cfg(not(unix))]
        crossterm::execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
        let backend = CrosstermBackend::new(stdout);
        let terminal = Terminal::new(backend)?;
        Ok(Self {
            terminal,
            last_title: None,
            restored: false,
        })
    }

    pub fn terminal_mut(&mut self) -> &mut InteractiveTerminal {
        &mut self.terminal
    }

    pub fn restore(&mut self) -> io::Result<()> {
        restore_terminal_if_needed(self.terminal.backend_mut(), &mut self.restored)
    }

    pub fn set_window_title(&mut self, title: &str) -> io::Result<()> {
        if self.last_title.as_deref() == Some(title) {
            return Ok(());
        }

        let mut stdout = io::stdout();
        write!(stdout, "\x1b]0;{title}\x07")?;
        stdout.flush()?;
        self.last_title = Some(title.to_string());
        Ok(())
    }
}

impl Drop for TerminalSession {
    fn drop(&mut self) {
        let _ = self.restore();
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn restore_terminal_writes_reset_and_exit_sequences() {
        let mut output = Vec::new();
        restore_terminal(&mut output).unwrap();
        let text = String::from_utf8(output).unwrap();

        assert!(text.contains("\u{1b}[0m"));
        assert!(text.contains("\u{1b}[?25h"));
        assert!(text.contains("\u{1b}[?1049l"));
    }

    #[test]
    fn restore_terminal_if_needed_is_idempotent() {
        let mut output = Vec::new();
        let mut restored = false;

        restore_terminal_if_needed(&mut output, &mut restored).unwrap();
        let first = output.clone();
        restore_terminal_if_needed(&mut output, &mut restored).unwrap();

        assert!(restored);
        assert_eq!(output, first);
    }
}