vibe-action 0.1.1

Command router — execute shell commands and LLM prompts via simple YAML actions.
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

//! Action models for YAML parsing.
//! Defines structures for action files, trigger and steps.

use serde::Deserialize;
use serde::Serialize;

use crate::models::context::ContextModel;

/// Action runner type.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ActionRun {
    /// Execute command in terminal.
    Cmd,
    /// Return the action string directly (no shell, no LLM).
    Value,
    /// Send prompt to tiny LLM.
    Tiny,
    /// Send prompt to small LLM.
    Small,
    /// Send prompt to medium LLM.
    Medium,
    /// Send prompt to large LLM.
    Large,
    /// Send prompt to vision LLM.
    Vision,
}

/// Action value: simple string or switch with when/then pairs.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ActionValue {
    Simple(String),
    Switch(Vec<SwitchCase>),
}

/// A single switch case.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SwitchCase {
    pub when: String,
    pub then: String,
}

/// A single action step.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionModel {
    /// Tag name for {tag} references.
    pub tag: String,
    /// Action runner type.
    pub run: ActionRun,
    /// Expected result type.
    pub expect: Option<ContextModel>,
    /// Optional regex validation for the result.
    #[serde(default)]
    pub check: Option<String>,
    /// Ask for confirmation before executing.
    #[serde(default)]
    pub confirm: bool,
    /// Action value: simple string or switch with when/then pairs.
    pub action: ActionValue,
}

impl ActionModel {
    /// Return all action texts for dependency scanning.
    pub fn actions(&self) -> Vec<&str> {
        let mut texts = Vec::new();
        match &self.action {
            ActionValue::Simple(s) => {
                if !s.is_empty() {
                    texts.push(s.as_str());
                }
            }
            ActionValue::Switch(cases) => {
                for case in cases {
                    texts.push(case.when.as_str());
                    texts.push(case.then.as_str());
                }
            }
        }
        texts
    }
}

impl std::fmt::Display for ActionRun {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ActionRun::Cmd => write!(f, "cmd"),
            ActionRun::Value => write!(f, "val"),
            ActionRun::Tiny => write!(f, "tiny"),
            ActionRun::Small => write!(f, "small"),
            ActionRun::Medium => write!(f, "medium"),
            ActionRun::Large => write!(f, "large"),
            ActionRun::Vision => write!(f, "vision"),
        }
    }
}