omk 0.5.0

A Rust runtime for Kimi CLI. Turns prompts into proof-backed engineering runs with gates, worktrees, and replay.
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
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

use crate::runtime::events::{
    Event, EventKind, GateResultPayload, ProofWrittenPayload, RunStartedPayload,
    TaskCompletedPayload, TaskGraphMutationPayload, WorkerStartedPayload,
};

use super::events::{ChildGoalEvent, PlanNode, PlanNodeStatus};

pub fn to_child_event(envelope: &Event) -> Option<ChildGoalEvent> {
    match envelope.kind {
        EventKind::RunStarted => {
            let goal_id = envelope.run_id.0.clone();
            let mut plan = Vec::new();
            if let Some(ref payload) = envelope.payload {
                if let Ok(p) = serde_json::from_value::<RunStartedPayload>(payload.clone()) {
                    plan.push(p.description);
                }
            }
            Some(ChildGoalEvent::Created { goal_id, plan })
        }
        EventKind::TaskGraphMutated => {
            let total_tasks = envelope
                .payload
                .as_ref()
                .and_then(|p| serde_json::from_value::<TaskGraphMutationPayload>(p.clone()).ok())
                .map(|p| p.total_tasks_after)
                .unwrap_or(0);

            let nodes: Vec<PlanNode> = (0..total_tasks)
                .map(|i| PlanNode {
                    id: format!("task-{i}"),
                    label: "Task".to_string(),
                    status: PlanNodeStatus::Pending,
                })
                .collect();

            Some(ChildGoalEvent::PlanUpdated { revision: 0, nodes })
        }
        EventKind::WorkerStarted => {
            let (worker_id, task) = envelope
                .payload
                .as_ref()
                .and_then(|p| serde_json::from_value::<WorkerStartedPayload>(p.clone()).ok())
                .map(|p| (p.worker_id.0, p.role))
                .unwrap_or_else(|| {
                    (
                        envelope.actor.clone().unwrap_or_default(),
                        envelope.actor.clone().unwrap_or_default(),
                    )
                });
            Some(ChildGoalEvent::WorkerStarted { worker_id, task })
        }
        EventKind::TaskOutput => {
            let worker_id = envelope.actor.clone().unwrap_or_default();
            let msg = envelope
                .payload
                .as_ref()
                .and_then(|p| p.get("message"))
                .and_then(|v| v.as_str())
                .unwrap_or("")
                .to_string();
            Some(ChildGoalEvent::WorkerProgress { worker_id, msg })
        }
        EventKind::TaskCompleted => {
            let worker_id = envelope
                .payload
                .as_ref()
                .and_then(|p| serde_json::from_value::<TaskCompletedPayload>(p.clone()).ok())
                .map(|p| p.worker_id.0)
                .unwrap_or_else(|| envelope.actor.clone().unwrap_or_default());
            Some(ChildGoalEvent::WorkerCompleted {
                worker_id,
                files: 0,
                ok: true,
            })
        }
        EventKind::TaskFailed => {
            let worker_id = envelope.actor.clone().unwrap_or_default();
            Some(ChildGoalEvent::WorkerCompleted {
                worker_id,
                files: 0,
                ok: false,
            })
        }
        EventKind::GatePassed => {
            let gate = envelope
                .payload
                .as_ref()
                .and_then(|p| serde_json::from_value::<GateResultPayload>(p.clone()).ok())
                .map(|p| p.name)
                .unwrap_or_else(|| "unknown".to_string());
            Some(ChildGoalEvent::GateTransition {
                gate,
                from: "unknown".to_string(),
                to: "passed".to_string(),
            })
        }
        EventKind::GateFailed => {
            let gate = envelope
                .payload
                .as_ref()
                .and_then(|p| serde_json::from_value::<GateResultPayload>(p.clone()).ok())
                .map(|p| p.name)
                .unwrap_or_else(|| "unknown".to_string());
            Some(ChildGoalEvent::GateTransition {
                gate,
                from: "unknown".to_string(),
                to: "failed".to_string(),
            })
        }
        EventKind::ProofWritten => {
            let (status, path) = envelope
                .payload
                .as_ref()
                .and_then(|p| serde_json::from_value::<ProofWrittenPayload>(p.clone()).ok())
                .map(|p| (p.status, p.proof_path))
                .unwrap_or_default();
            if status == "ready" {
                Some(ChildGoalEvent::ProofReady { path })
            } else {
                None
            }
        }
        EventKind::RunFailed => {
            let reason = envelope
                .payload
                .as_ref()
                .and_then(|p| p.get("message"))
                .and_then(|v| v.as_str())
                .unwrap_or("goal failed")
                .to_string();
            Some(ChildGoalEvent::Failed { reason })
        }
        EventKind::ManualInterrupt => Some(ChildGoalEvent::Cancelled),
        _ => None,
    }
}