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

use std::path::PathBuf;
use std::sync::Arc;

use omk::runtime::classifier::Intent;
use omk::runtime::conversation::bus::{BusEvent, PreflightAction, PreflightKind};
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_small_intent_emits_disclosure_then_spawns_worker() {
    let bus = omk::runtime::conversation::bus::EventBus::new().arc();
    let mut rx = bus.subscribe();
    let router = Router::new(
        Arc::new(MockClassifier::new(make_classifier_output(
            Intent::Small,
            0.92,
        ))),
        Arc::new(MockLlmDirect::new(0)),
        Arc::new(MockWireWorker::new(
            SmallEditResult {
                worker_id: "sw1".into(),
                files_touched: 2,
                diff_summary: "diff".into(),
            },
            MediumPlanResult {
                workers: vec![],
                steps_completed: 0,
                steps_failed: 0,
            },
        )),
        Arc::new(MockGoalBridge::new(make_handle("g1"))),
        RouterConfig::default(),
        bus.clone(),
    );
    let session = make_session();
    let outcome = router.dispatch("fix typo", &session).await;
    assert!(matches!(outcome, RouteOutcome::Small { .. }));

    let mut events = Vec::new();
    while let Ok(ev) = rx.try_recv() {
        events.push(ev);
    }
    let mut iter = events.iter();
    assert!(matches!(
        iter.next(),
        Some(BusEvent::ClassifierDecided { .. })
    ));
    assert!(matches!(
        iter.next(),
        Some(BusEvent::RouterEscalating { .. })
    ));
    assert!(matches!(iter.next(), Some(BusEvent::DisclosureLine(_))));
    assert!(matches!(iter.next(), Some(BusEvent::WorkerStarted { .. })));
    assert!(matches!(
        iter.next(),
        Some(BusEvent::WorkerCompleted { .. })
    ));
    assert!(iter.next().is_none());
}

#[tokio::test]
async fn test_small_with_protected_path_preflights() {
    let config = RouterConfig {
        interactive_preflight: true,
        protected_paths: vec![PathBuf::from(".github/")],
        first_prompt_threshold: 0.0,
        ..Default::default()
    };
    let bus = omk::runtime::conversation::bus::EventBus::new().arc();
    let mut rx = bus.subscribe();
    let router = Router::new(
        Arc::new(MockClassifier::new(make_classifier_output(
            Intent::Small,
            0.95,
        ))),
        Arc::new(MockLlmDirect::new(0)),
        Arc::new(MockWireWorker::new(
            SmallEditResult {
                worker_id: "sw1".into(),
                files_touched: 1,
                diff_summary: "".into(),
            },
            MediumPlanResult {
                workers: vec![],
                steps_completed: 0,
                steps_failed: 0,
            },
        )),
        Arc::new(MockGoalBridge::new(make_handle("g1"))),
        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("update .github/workflows/x", &s2).await });

    let mut ticket_id = None;
    while let Ok(ev) = rx.recv().await {
        if let BusEvent::PreflightRequest(ref p) = ev {
            if matches!(p.kind, PreflightKind::SmallOverProtectedPath) {
                ticket_id = Some(p.ticket_id.clone());
                break;
            }
        }
    }
    assert!(ticket_id.is_some(), "expected preflight for protected path");

    router
        .submit_preflight(ticket_id.unwrap(), PreflightAction::Cancel)
        .await;
    let outcome = handle.await.unwrap();
    assert!(matches!(outcome, RouteOutcome::Cancelled));
}