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

use std::sync::Arc;

use omk::runtime::classifier::Intent;
use omk::runtime::conversation::bus::{BusEvent, PreflightAction};
use omk::runtime::conversation::outcome::RouteOutcome;
use omk::runtime::escalation::{
    backends::{MediumPlanResult, SmallEditResult},
    mocks::{MockClassifier, MockGoalBridge, MockLlmDirect, MockWireWorker},
    router::{Router, RouterConfig},
};

use crate::common::{make_classifier_output, make_handle, make_session};

#[tokio::test]
async fn test_large_intent_always_preflights_before_creating_goal() {
    let config = RouterConfig {
        interactive_preflight: true,
        preflight_timeout_ms: 100,
        ..Default::default()
    };
    let bus = omk::runtime::conversation::bus::EventBus::new().arc();
    let mut rx = bus.subscribe();
    let bridge = Arc::new(MockGoalBridge::new(make_handle("g1")));
    let router = Router::new(
        Arc::new(MockClassifier::new(make_classifier_output(
            Intent::Large,
            0.94,
        ))),
        Arc::new(MockLlmDirect::new(0)),
        Arc::new(MockWireWorker::new(
            SmallEditResult {
                worker_id: "sw1".into(),
                files_touched: 0,
                diff_summary: "".into(),
            },
            MediumPlanResult {
                workers: vec![],
                steps_completed: 0,
                steps_failed: 0,
            },
        )),
        bridge.clone(),
        config,
        bus.clone(),
    );
    let session = make_session();
    let outcome = router.dispatch("big refactor", &session).await;
    assert!(matches!(outcome, RouteOutcome::Cancelled));

    let mut created = false;
    while let Ok(ev) = rx.try_recv() {
        if matches!(ev, BusEvent::ChildGoalCreated { .. }) {
            created = true;
        }
    }
    assert!(!created, "goal should not be created after timeout");
    assert!(bridge.created.lock().await.is_empty());
}

#[tokio::test]
async fn test_large_preflight_accept_creates_child_goal() {
    let config = RouterConfig {
        interactive_preflight: true,
        preflight_timeout_ms: 5_000,
        ..Default::default()
    };
    let bus = omk::runtime::conversation::bus::EventBus::new().arc();
    let mut rx = bus.subscribe();
    let bridge = Arc::new(MockGoalBridge::new(make_handle("g-large")));
    let router = Router::new(
        Arc::new(MockClassifier::new(make_classifier_output(
            Intent::Large,
            0.94,
        ))),
        Arc::new(MockLlmDirect::new(0)),
        Arc::new(MockWireWorker::new(
            SmallEditResult {
                worker_id: "sw1".into(),
                files_touched: 0,
                diff_summary: "".into(),
            },
            MediumPlanResult {
                workers: vec![],
                steps_completed: 0,
                steps_failed: 0,
            },
        )),
        bridge.clone(),
        config,
        bus.clone(),
    );
    let session = make_session();
    let router = Arc::new(router);

    let router2 = router.clone();
    let s2 = session.clone();
    let handle = tokio::spawn(async move { router2.dispatch("big refactor", &s2).await });

    let mut ticket_id = None;
    while let Ok(ev) = rx.recv().await {
        if let BusEvent::PreflightRequest(ref p) = ev {
            ticket_id = Some(p.ticket_id.clone());
            break;
        }
    }
    assert!(ticket_id.is_some());

    router
        .submit_preflight(ticket_id.unwrap(), PreflightAction::Accept)
        .await;
    let outcome = handle.await.unwrap();
    assert!(matches!(outcome, RouteOutcome::Large { goal_id, .. } if goal_id == "g-large"));
    assert_eq!(bridge.created.lock().await.len(), 1);
}