daat-locus 0.1.1

A long-running local agent runtime with memory, workflows, apps, and sleep-time self-improvement.
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

use ratatui::{style::Color, text::Line};
use serde::{Deserialize, Serialize};

use crate::tool_ui::{ToolUiData, glyph};

use super::primitives::{
    Cell, render_error_lines, render_text_activity_lines, render_wait_activity_lines,
};

#[derive(Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct AssistantActivityCell {
    pub title: String,
    pub body_lines: Vec<String>,
}

#[derive(Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct UserActivityCell {
    pub title: String,
    pub body_lines: Vec<String>,
}

#[derive(Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct GenericAppActivityCell {
    pub title: String,
    pub body_lines: Vec<String>,
}

#[derive(Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct TerminalWaitActivityCell {
    pub title: String,
    pub body_lines: Vec<String>,
}

#[derive(Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct ErrorActivityCell {
    pub title: String,
    pub body_lines: Vec<String>,
}

impl Cell for AssistantActivityCell {
    fn render_lines(&self) -> Vec<Line<'static>> {
        render_text_activity_lines("›", Color::Cyan, &self.title, &self.body_lines, 8, None)
    }
}

impl Cell for UserActivityCell {
    fn render_lines(&self) -> Vec<Line<'static>> {
        render_text_activity_lines(
            glyph::EXEC,
            Color::Green,
            &self.title,
            &self.body_lines,
            6,
            None,
        )
    }
}

impl Cell for GenericAppActivityCell {
    fn render_lines(&self) -> Vec<Line<'static>> {
        render_text_activity_lines(
            glyph::EXEC,
            Color::LightGreen,
            &format!("App: {}", self.title),
            &[],
            0,
            None,
        )
    }
}

impl Cell for TerminalWaitActivityCell {
    fn render_lines(&self) -> Vec<Line<'static>> {
        render_wait_activity_lines(&self.title, &self.body_lines, 6)
    }
}

impl Cell for ErrorActivityCell {
    fn render_lines(&self) -> Vec<Line<'static>> {
        render_error_lines(&self.title, &self.body_lines, 12)
    }
}

pub fn assistant_cell(title: impl Into<String>, body_lines: Vec<String>) -> AssistantActivityCell {
    AssistantActivityCell {
        title: title.into(),
        body_lines,
    }
}

pub fn user_cell(title: impl Into<String>, body_lines: Vec<String>) -> UserActivityCell {
    UserActivityCell {
        title: title.into(),
        body_lines,
    }
}

pub fn generic_app_cell(
    title: impl Into<String>,
    body_lines: Vec<String>,
) -> GenericAppActivityCell {
    GenericAppActivityCell {
        title: title.into(),
        body_lines,
    }
}

pub fn terminal_wait_cell(
    title: impl Into<String>,
    body_lines: Vec<String>,
) -> TerminalWaitActivityCell {
    TerminalWaitActivityCell {
        title: title.into(),
        body_lines,
    }
}

pub fn error_cell(title: impl Into<String>, body_lines: Vec<String>) -> ErrorActivityCell {
    ErrorActivityCell {
        title: title.into(),
        body_lines,
    }
}

impl From<ToolUiData> for GenericAppActivityCell {
    fn from(data: ToolUiData) -> Self {
        generic_app_cell(data.title, data.body_lines)
    }
}

impl From<ToolUiData> for ErrorActivityCell {
    fn from(data: ToolUiData) -> Self {
        error_cell(data.title, data.body_lines)
    }
}