kwaak 0.8.2

Run a team of autonomous agents on your code, right from your terminal
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

use crate::commands::{CommandResponse, Responder};
use std::sync::Mutex;
use swiftide::chat_completion::ChatMessage;

#[derive(Debug)]
pub struct LoggingResponder {
    messages: Mutex<Vec<String>>,
}

impl LoggingResponder {
    pub fn new() -> Self {
        Self {
            messages: Mutex::new(Vec::new()),
        }
    }

    pub fn get_log(&self) -> String {
        self.messages.lock().unwrap().join("\n")
    }

    fn format_string(s: &str) -> String {
        s.replace("\\\"", "\"")
            .replace("\\n", "\n")
            .replace("\\t", "\t")
            .replace("\\r", "\r")
    }
}

impl Responder for LoggingResponder {
    fn agent_message(&self, message: ChatMessage) {
        let mut messages = self.messages.lock().unwrap();
        let formatted = format!("{message:?}").replace("\\\\", "\\");
        messages.push(format!(
            "DEBUG: Agent message: {}",
            Self::format_string(&formatted)
        ));
    }

    fn update(&self, message: &str) {
        let mut messages = self.messages.lock().unwrap();
        messages.push(format!(
            "DEBUG: State update: {}",
            Self::format_string(message)
        ));
    }

    fn send(&self, response: CommandResponse) {
        let mut messages = self.messages.lock().unwrap();
        let formatted = format!("{response:?}").replace("\\\\", "\\");
        messages.push(format!(
            "DEBUG: Command response: {}",
            Self::format_string(&formatted)
        ));
    }

    fn system_message(&self, message: &str) {
        let mut messages = self.messages.lock().unwrap();
        messages.push(format!(
            "DEBUG: System message: {}",
            Self::format_string(message)
        ));
    }

    fn rename_chat(&self, _name: &str) {}
    fn rename_branch(&self, _name: &str) {}
}