orchestral-cli 0.2.0

Command line interface for running Orchestral workflows
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

use std::collections::HashMap;
use std::time::Instant;

use crate::runtime::{ActivityKind, TransientSlot};

use super::bottom_pane::BottomPane;
use super::widgets::{Shimmer, Spinner};

#[derive(Debug, Clone)]
pub struct ActivityGroup {
    pub key: String,
    pub turn_id: usize,
    pub kind: ActivityKind,
    pub title: String,
    pub items: Vec<String>,
    pub failed: bool,
}

pub struct App {
    pub dirty: bool,
    pub mode: AppMode,
    pub history: Vec<String>,
    pub current_turn_id: usize,
    pub activities: Vec<ActivityGroup>,
    pub active_activity: Option<usize>,
    pub activity_index: HashMap<String, usize>,
    pub transient: HashMap<TransientSlot, String>,
    pub bottom: BottomPane,
    pub spinner: Spinner,
    pub shimmer: Shimmer,
    pub width: u16,
    pub height: u16,
    pub should_quit: bool,
    pending_submit: Option<String>,
    pending_interrupt: bool,
    pub once: bool,
    pub submitted_once: bool,
    pub turn_started_at: Option<Instant>,
    pub turn_elapsed_reported: bool,
    pub approved_command_prefixes: Vec<String>,
    pub assistant_stream_line: Option<usize>,
    pub assistant_output_persisted: bool,
    pub assistant_last_persist_range: Option<(usize, usize)>,
    pub history_scroll_back: u16,
    pub mouse_capture_enabled: bool,
    pending_mouse_capture_toggle: Option<bool>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AppMode {
    Idle,
    Planning,
    Executing,
    WaitingInput,
}

impl App {
    pub fn new(width: u16, height: u16, once: bool) -> Self {
        Self {
            dirty: true,
            mode: AppMode::Idle,
            history: Vec::new(),
            current_turn_id: 0,
            activities: Vec::new(),
            active_activity: None,
            activity_index: HashMap::new(),
            transient: HashMap::from([(
                crate::runtime::TransientSlot::Footer,
                "Ready. Enter submit | Ctrl+K help | /exit quit".to_string(),
            )]),
            bottom: BottomPane::new(),
            spinner: Spinner::new(),
            shimmer: Shimmer::new(),
            width,
            height,
            should_quit: false,
            pending_submit: None,
            pending_interrupt: false,
            once,
            submitted_once: false,
            turn_started_at: None,
            turn_elapsed_reported: false,
            approved_command_prefixes: Vec::new(),
            assistant_stream_line: None,
            assistant_output_persisted: false,
            assistant_last_persist_range: None,
            history_scroll_back: 0,
            mouse_capture_enabled: true,
            pending_mouse_capture_toggle: None,
        }
    }

    pub fn set_dirty(&mut self) {
        self.dirty = true;
    }

    pub fn queue_submit(&mut self, input: String) {
        self.pending_submit = Some(input);
    }

    pub fn take_pending_submit(&mut self) -> Option<String> {
        self.pending_submit.take()
    }

    pub fn queue_interrupt(&mut self) {
        self.pending_interrupt = true;
    }

    pub fn take_pending_interrupt(&mut self) -> bool {
        if self.pending_interrupt {
            self.pending_interrupt = false;
            true
        } else {
            false
        }
    }

    pub fn remember_approved_prefix(&mut self, prefix: String) {
        if !self
            .approved_command_prefixes
            .iter()
            .any(|saved| saved == &prefix)
        {
            self.approved_command_prefixes.push(prefix);
        }
    }

    pub fn is_command_auto_approved(&self, command: &str) -> bool {
        self.approved_command_prefixes
            .iter()
            .any(|prefix| command.starts_with(prefix))
    }

    pub fn queue_set_mouse_capture(&mut self, enabled: bool) {
        self.pending_mouse_capture_toggle = Some(enabled);
    }

    pub fn take_pending_mouse_capture_toggle(&mut self) -> Option<bool> {
        self.pending_mouse_capture_toggle.take()
    }
}