vtcode-tui 0.98.4

Reusable TUI primitives and session API for VT Code-style terminal interfaces
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
146
147
148
149

//! Error types for TUI session operations

/// Errors that can occur in TUI session operations
#[derive(Debug, thiserror::Error)]
pub enum SessionError {
    /// Error during rendering operations
    #[error("Render error: {source}")]
    RenderError {
        #[source]
        source: Box<dyn std::error::Error + Send + Sync>,
    },
    /// Error during input processing
    #[error("Input error: {source}")]
    InputError {
        #[source]
        source: Box<dyn std::error::Error + Send + Sync>,
    },
    /// Error during state management
    #[error("State error: {source}")]
    StateError {
        #[source]
        source: Box<dyn std::error::Error + Send + Sync>,
    },
    /// Error during UI component operations
    #[error("UI error: {source}")]
    UIError {
        #[source]
        source: Box<dyn std::error::Error + Send + Sync>,
    },
    /// Error during message processing
    #[error("Message error: {source}")]
    MessageError {
        #[source]
        source: Box<dyn std::error::Error + Send + Sync>,
    },
    /// Error during cache operations
    #[error("Cache error: {source}")]
    CacheError {
        #[source]
        source: Box<dyn std::error::Error + Send + Sync>,
    },
    /// Resource exhausted error (e.g., memory, file handles)
    #[error("Resource exhausted: {resource}")]
    ResourceExhausted { resource: String },
    /// Configuration error
    #[error("Configuration error: {source}")]
    ConfigError {
        #[source]
        source: Box<dyn std::error::Error + Send + Sync>,
    },
}

impl SessionError {
    pub fn render<E: std::error::Error + Send + Sync + 'static>(error: E) -> Self {
        SessionError::RenderError { source: Box::new(error) }
    }

    pub fn input<E: std::error::Error + Send + Sync + 'static>(error: E) -> Self {
        SessionError::InputError { source: Box::new(error) }
    }

    pub fn state<E: std::error::Error + Send + Sync + 'static>(error: E) -> Self {
        SessionError::StateError { source: Box::new(error) }
    }

    pub fn ui<E: std::error::Error + Send + Sync + 'static>(error: E) -> Self {
        SessionError::UIError { source: Box::new(error) }
    }

    pub fn message<E: std::error::Error + Send + Sync + 'static>(error: E) -> Self {
        SessionError::MessageError { source: Box::new(error) }
    }

    pub fn cache<E: std::error::Error + Send + Sync + 'static>(error: E) -> Self {
        SessionError::CacheError { source: Box::new(error) }
    }

    pub fn config<E: std::error::Error + Send + Sync + 'static>(error: E) -> Self {
        SessionError::ConfigError { source: Box::new(error) }
    }

    pub fn resource_exhausted(resource: impl Into<String>) -> Self {
        SessionError::ResourceExhausted { resource: resource.into() }
    }
}

// Type alias for common result type
pub type SessionResult<T> = Result<T, SessionError>;

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

    #[test]
    fn test_error_construction() {
        let err = SessionError::render("Test render error");
        assert!(format!("{}", err).contains("Render error"));
    }

    #[test]
    fn test_error_with_source() {
        let io_err = std::io::Error::new(std::io::ErrorKind::Other, "IO error");
        let session_err = SessionError::input(io_err);
        assert!(format!("{}", session_err).contains("Input error"));
    }

    #[test]
    fn test_error_variants() {
        let render_err = SessionError::render("Render failed");
        let input_err = SessionError::input("Input failed");
        let state_err = SessionError::state("State failed");
        let ui_err = SessionError::ui("UI failed");
        let message_err = SessionError::message("Message failed");
        let cache_err = SessionError::cache("Cache failed");
        let resource_err = SessionError::resource_exhausted("memory");
        let config_err = SessionError::config("Config failed");

        assert!(format!("{}", render_err).contains("Render error"));
        assert!(format!("{}", input_err).contains("Input error"));
        assert!(format!("{}", state_err).contains("State error"));
        assert!(format!("{}", ui_err).contains("UI error"));
        assert!(format!("{}", message_err).contains("Message error"));
        assert!(format!("{}", cache_err).contains("Cache error"));
        assert!(format!("{}", resource_err).contains("Resource exhausted"));
        assert!(format!("{}", config_err).contains("Configuration error"));
    }

    #[test]
    fn test_error_sources() {
        let io_err = std::io::Error::new(std::io::ErrorKind::Other, "IO error");
        let session_err = SessionError::input(io_err);

        // Test that the source is properly chained
        if let Some(source) = session_err.source() {
            assert_eq!(format!("{}", source), "IO error");
        } else {
            panic!("Expected source error");
        }
    }

    #[test]
    fn test_result_type() {
        let result: SessionResult<()> = Err(SessionError::render("Test"));
        assert!(result.is_err());

        let result: SessionResult<()> = Ok(());
        assert!(result.is_ok());
    }
}