opendev-tui 0.1.4

Ratatui-based terminal UI for OpenDev
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

//! Skill creator controller for the TUI.
//!
//! Manages form state for creating skill files, including name,
//! description, prompt content, and invocability settings.

/// Specification for a skill, produced by validation.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SkillSpec {
    pub name: String,
    pub description: String,
    pub content: String,
    pub is_user_invocable: bool,
}

/// Controller for the skill creation form.
pub struct SkillCreatorController {
    name: String,
    description: String,
    content: String,
    is_user_invocable: bool,
}

impl SkillCreatorController {
    /// Create a new skill creator controller with empty fields.
    pub fn new() -> Self {
        Self {
            name: String::new(),
            description: String::new(),
            content: String::new(),
            is_user_invocable: true,
        }
    }

    /// Set the skill name.
    pub fn set_name(&mut self, name: impl Into<String>) {
        self.name = name.into();
    }

    /// Get the current skill name.
    pub fn name(&self) -> &str {
        &self.name
    }

    /// Set the skill description.
    pub fn set_description(&mut self, description: impl Into<String>) {
        self.description = description.into();
    }

    /// Get the current description.
    pub fn description(&self) -> &str {
        &self.description
    }

    /// Set the skill content (prompt text).
    pub fn set_content(&mut self, content: impl Into<String>) {
        self.content = content.into();
    }

    /// Get the current content.
    pub fn content(&self) -> &str {
        &self.content
    }

    /// Set whether this skill can be invoked directly by users.
    pub fn set_user_invocable(&mut self, invocable: bool) {
        self.is_user_invocable = invocable;
    }

    /// Whether this skill is user-invocable.
    pub fn is_user_invocable(&self) -> bool {
        self.is_user_invocable
    }

    /// Validate the current form state and produce a [`SkillSpec`].
    ///
    /// Returns an error string describing the first validation failure.
    pub fn validate(&self) -> Result<SkillSpec, String> {
        if self.name.trim().is_empty() {
            return Err("Skill name is required".into());
        }
        if self.description.trim().is_empty() {
            return Err("Skill description is required".into());
        }
        if self.content.trim().is_empty() {
            return Err("Skill content is required".into());
        }
        Ok(SkillSpec {
            name: self.name.trim().to_string(),
            description: self.description.trim().to_string(),
            content: self.content.clone(),
            is_user_invocable: self.is_user_invocable,
        })
    }

    /// Reset all fields to their default values.
    pub fn reset(&mut self) {
        self.name.clear();
        self.description.clear();
        self.content.clear();
        self.is_user_invocable = true;
    }
}

impl Default for SkillCreatorController {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
#[path = "skill_creator_tests.rs"]
mod tests;