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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

use omk::cli::chat::app::{App, PaneState};
use omk::cli::chat::commands::StubBackend;
use omk::cli::chat::input::{ChatEvent, KeyCode, KeyEvent, KeyModifiers};
use tempfile::TempDir;

fn key(c: char) -> ChatEvent {
    ChatEvent::Key(KeyEvent {
        code: KeyCode::Char(c),
        modifiers: KeyModifiers::none(),
    })
}

fn enter() -> ChatEvent {
    ChatEvent::Key(KeyEvent {
        code: KeyCode::Enter,
        modifiers: KeyModifiers::none(),
    })
}

fn tab() -> ChatEvent {
    ChatEvent::Key(KeyEvent {
        code: KeyCode::Tab,
        modifiers: KeyModifiers::none(),
    })
}

fn shift_tab() -> ChatEvent {
    ChatEvent::Key(KeyEvent {
        code: KeyCode::BackTab,
        modifiers: KeyModifiers {
            shift: true,
            ..KeyModifiers::none()
        },
    })
}

fn make_app(temp: &TempDir) -> App {
    let state_dir = temp.path().join("state");
    let config_dir = temp.path().join("config");
    App::with_dirs(
        state_dir,
        config_dir,
        "/tmp/project".to_string(),
        "o7k_test1234".to_string(),
        std::sync::Arc::new(StubBackend),
    )
    .unwrap()
}

#[test]
fn test_app_starts_with_collapsed_engine_pane() {
    let temp = TempDir::new().unwrap();
    let app = make_app(&temp);
    assert_eq!(app.pane_state, PaneState::Collapsed);
}

#[test]
fn test_tab_expands_engine_pane_then_back_to_compact() {
    let temp = TempDir::new().unwrap();
    let mut app = make_app(&temp);
    assert_eq!(app.pane_state, PaneState::Collapsed);

    app.handle_event(tab());
    assert_eq!(app.pane_state, PaneState::Expanded);

    app.handle_event(tab());
    assert_eq!(app.pane_state, PaneState::Compact);

    app.handle_event(tab());
    assert_eq!(app.pane_state, PaneState::Expanded);
}

#[test]
fn test_shift_tab_collapses_engine_pane() {
    let temp = TempDir::new().unwrap();
    let mut app = make_app(&temp);

    // Get to Compact first (Collapsed -> Tab -> Expanded -> Tab -> Compact)
    app.handle_event(tab()); // Expanded
    app.handle_event(tab()); // Compact
    assert_eq!(app.pane_state, PaneState::Compact);

    app.handle_event(shift_tab());
    assert_eq!(app.pane_state, PaneState::Collapsed);
}

#[test]
fn test_text_input_appends_to_conversation() {
    let temp = TempDir::new().unwrap();
    let mut app = make_app(&temp);

    app.handle_event(key('h'));
    app.handle_event(key('i'));
    app.handle_event(enter());

    let conv_path = app.state_dir.join("conversation.jsonl");
    let contents = std::fs::read_to_string(&conv_path).unwrap();

    assert!(
        contents.contains(r#""role":"user""#),
        "expected user message in conversation.jsonl"
    );
    assert!(
        contents.contains(r#""text":"hi""#),
        "expected 'hi' text in conversation.jsonl"
    );
    assert!(
        contents.contains(r#"[W1 stub] received \"hi\""#),
        "expected stub echo in conversation.jsonl"
    );
}

#[test]
fn test_session_resume_loads_persisted_conversation() {
    let temp = TempDir::new().unwrap();
    let state_dir = temp.path().join("state");
    let config_dir = temp.path().join("config");

    // First session: send 3 prompts.
    {
        let mut app = App::with_dirs(
            state_dir.clone(),
            config_dir.clone(),
            "/tmp/project".to_string(),
            "o7k_test1234".to_string(),
            std::sync::Arc::new(StubBackend),
        )
        .unwrap();

        for text in &["one", "two", "three"] {
            for c in text.chars() {
                app.handle_event(key(c));
            }
            app.handle_event(enter());
        }

        let msgs = app.session.conversation.read_all().unwrap();
        assert_eq!(msgs.len(), 6, "expected 6 messages before drop");
    }

    // Resume session with same id.
    {
        let app = App::with_dirs(
            state_dir,
            config_dir,
            "/tmp/project".to_string(),
            "o7k_test1234".to_string(),
            std::sync::Arc::new(StubBackend),
        )
        .unwrap();

        let msgs = app.session.conversation.read_all().unwrap();
        assert_eq!(
            msgs.len(),
            6,
            "expected 6 messages after resume (3 user + 3 assistant)"
        );
    }
}

#[test]
#[ignore = "blocked on src/main.rs wiring by orchestrator"]
fn smoke_omk_new_starts_chat_shell() {
    // This test requires `omk` binary to be wired to `run_chat(ChatArgs)`.
    // Once wired, it should spawn `omk --new` and verify the TUI initializes.
    use std::process::Command;
    let output = Command::new("cargo")
        .args(["run", "--", "--new"])
        .output()
        .expect("cargo run should succeed");
    assert!(output.status.success(), "omk --new should exit cleanly");
}