chuggin 0.5.3

A terminal harness for persistent coding projects with fresh-context local model stages
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

//! Bounded, best-effort observation. A slow renderer never blocks the agent.
use serde_json::Value;
use std::path::PathBuf;
use std::sync::{
    Mutex, OnceLock,
    mpsc::{self, Receiver, SyncSender},
};

#[derive(Clone, Debug)]
pub enum Event {
    Log(String),
    Phase(String),
    Cycle(u64),
    Task(String),
    Request,
    Delta(String),
    Metrics {
        prompt: u64,
        generated: u64,
        seconds: f64,
    },
    Tool(String),
    Check {
        command: String,
        path: PathBuf,
    },
    CheckDone(bool),
    Outcome {
        disposition: String,
        task: String,
    },
}
static SINK: OnceLock<Mutex<Option<SyncSender<Event>>>> = OnceLock::new();
pub fn subscribe() -> Receiver<Event> {
    let (tx, rx) = mpsc::sync_channel(4096);
    *SINK.get_or_init(|| Mutex::new(None)).lock().unwrap() = Some(tx);
    rx
}
pub fn unsubscribe() {
    if let Some(s) = SINK.get() {
        *s.lock().unwrap() = None;
    }
}
pub fn send(event: Event) {
    if let Some(s) = SINK.get()
        && let Ok(s) = s.lock()
        && let Some(tx) = s.as_ref()
    {
        let _ = tx.try_send(event);
    }
}
pub fn log(text: String) {
    let active = SINK
        .get()
        .and_then(|s| s.lock().ok())
        .is_some_and(|s| s.is_some());
    if active {
        send(Event::Log(text));
    } else {
        println!("{text}");
    }
}
pub fn artifact(stage: &str, value: &Value) {
    if stage.starts_with("scope-extension-") {
        send(Event::Log(format!(
            "Scope expanded: {} ยท {}",
            value["path"].as_str().unwrap_or(""),
            value["reason"].as_str().unwrap_or("")
        )));
    } else if stage.starts_with("response-error-") || stage.starts_with("patch-error-") {
        send(Event::Log(format!(
            "Recovery: {}",
            value.as_str().unwrap_or("See cycle artifacts for details")
        )));
    } else if stage.starts_with("tool-") && value["ok"] == false {
        send(Event::Log(format!(
            "Tool error: {}",
            value["error"].as_str().unwrap_or("See cycle artifacts")
        )));
    }
    match stage {
        "task" => {
            if let Some(t) = value["title"].as_str() {
                send(Event::Task(t.into()));
            }
        }
        "outcome" => send(Event::Outcome {
            disposition: value["disposition"].as_str().unwrap_or("retry").into(),
            task: value["task"].as_str().unwrap_or("").into(),
        }),
        _ => {}
    }
}