ralph-workflow 0.7.18

PROMPT-driven multi-agent orchestrator for git repos
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

use crate::json_parser::streaming_state::StreamingSession;
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug, Clone)]
pub struct StreamingState {
    session: Rc<RefCell<StreamingSession>>,
    terminal_mode: Rc<RefCell<crate::json_parser::terminal::TerminalMode>>,
    thinking_active_index: Rc<RefCell<Option<u64>>>,
    thinking_non_tty_indices: Rc<RefCell<std::collections::BTreeSet<u64>>>,
    suppress_thinking_for_message: Rc<RefCell<bool>>,
    text_line_active: Rc<RefCell<bool>>,
    cursor_up_active: Rc<RefCell<bool>>,
    last_rendered_content: Rc<RefCell<std::collections::HashMap<String, String>>>,
}

impl StreamingState {
    #[must_use]
    pub fn new() -> Self {
        Self {
            session: Rc::new(RefCell::new(StreamingSession::new())),
            terminal_mode: Rc::new(RefCell::new(
                crate::json_parser::terminal::TerminalMode::detect(),
            )),
            thinking_active_index: Rc::new(RefCell::new(None)),
            thinking_non_tty_indices: Rc::new(RefCell::new(std::collections::BTreeSet::new())),
            suppress_thinking_for_message: Rc::new(RefCell::new(false)),
            text_line_active: Rc::new(RefCell::new(false)),
            cursor_up_active: Rc::new(RefCell::new(false)),
            last_rendered_content: Rc::new(RefCell::new(std::collections::HashMap::new())),
        }
    }

    pub fn borrow_session(&self) -> std::cell::Ref<'_, StreamingSession> {
        self.session.borrow()
    }

    pub fn borrow_session_mut(&self) -> std::cell::RefMut<'_, StreamingSession> {
        self.session.borrow_mut()
    }

    pub fn terminal_mode(&self) -> std::cell::Ref<'_, crate::json_parser::terminal::TerminalMode> {
        self.terminal_mode.borrow()
    }

    pub fn terminal_mode_mut(
        &self,
    ) -> std::cell::RefMut<'_, crate::json_parser::terminal::TerminalMode> {
        self.terminal_mode.borrow_mut()
    }

    pub fn thinking_active_index(&self) -> std::cell::Ref<'_, Option<u64>> {
        self.thinking_active_index.borrow()
    }

    pub fn thinking_active_index_mut(&self) -> std::cell::RefMut<'_, Option<u64>> {
        self.thinking_active_index.borrow_mut()
    }

    pub fn thinking_non_tty_indices(&self) -> std::cell::Ref<'_, std::collections::BTreeSet<u64>> {
        self.thinking_non_tty_indices.borrow()
    }

    pub fn thinking_non_tty_indices_mut(
        &self,
    ) -> std::cell::RefMut<'_, std::collections::BTreeSet<u64>> {
        self.thinking_non_tty_indices.borrow_mut()
    }

    pub fn suppress_thinking_for_message(&self) -> std::cell::Ref<'_, bool> {
        self.suppress_thinking_for_message.borrow()
    }

    pub fn suppress_thinking_for_message_mut(&self) -> std::cell::RefMut<'_, bool> {
        self.suppress_thinking_for_message.borrow_mut()
    }

    pub fn text_line_active(&self) -> std::cell::Ref<'_, bool> {
        self.text_line_active.borrow()
    }

    pub fn text_line_active_mut(&self) -> std::cell::RefMut<'_, bool> {
        self.text_line_active.borrow_mut()
    }

    pub fn cursor_up_active(&self) -> std::cell::Ref<'_, bool> {
        self.cursor_up_active.borrow()
    }

    pub fn cursor_up_active_mut(&self) -> std::cell::RefMut<'_, bool> {
        self.cursor_up_active.borrow_mut()
    }

    pub fn last_rendered_content(
        &self,
    ) -> std::cell::Ref<'_, std::collections::HashMap<String, String>> {
        self.last_rendered_content.borrow()
    }

    pub fn last_rendered_content_mut(
        &self,
    ) -> std::cell::RefMut<'_, std::collections::HashMap<String, String>> {
        self.last_rendered_content.borrow_mut()
    }
}

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