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

use anyhow::Result;
use chrono::Utc;

use super::state::{GoalFailure, GoalState, GoalStatus};
use super::{budget, state};
use crate::runtime::goal::state::{FileSystemGoalStateStore, GoalStateStore};

mod until_ready;

pub(crate) use until_ready::{resolve_base_branch, run_goal_until_ready};

pub async fn pause_goal(goal_id: &str) -> Result<GoalState> {
    let mut state = super::resolve_goal(goal_id).await?;
    if matches!(state.status, GoalStatus::Ready | GoalStatus::Cancelled) {
        anyhow::bail!(
            "Goal '{}' is terminal ({}) and cannot be paused. \
             Use 'omk goal show {}' to inspect it, or 'omk goal cancel {}' if you need to terminate an active run.",
            state.goal_id,
            state.status,
            state.goal_id,
            state.goal_id
        );
    }

    let now = Utc::now();
    state.status = GoalStatus::Paused;
    state.updated_at = now;
    state.completed_at = None;
    FileSystemGoalStateStore::new().save(&state).await?;
    append_goal_lifecycle_event(&state, crate::runtime::events::EventKind::GoalPaused).await?;
    budget::append_budget_checkpoint(&state, "goal_paused").await?;
    Ok(state)
}

pub async fn resume_goal(goal_id: &str) -> Result<GoalState> {
    let mut state = super::resolve_goal(goal_id).await?;
    if state.status != GoalStatus::Paused {
        anyhow::bail!(
            "Goal '{}' is not paused (status: {}). \
             Pause it first with 'omk goal pause {}', or check status with 'omk goal status {}'.",
            state.goal_id,
            state.status,
            state.goal_id,
            state.goal_id
        );
    }

    let now = Utc::now();
    state.status = GoalStatus::NotReady;
    state.updated_at = now;
    state.completed_at = None;
    FileSystemGoalStateStore::new().save(&state).await?;
    append_goal_lifecycle_event(&state, crate::runtime::events::EventKind::GoalResumed).await?;
    budget::append_budget_checkpoint(&state, "goal_resumed").await?;
    Ok(state)
}

pub async fn cancel_goal(goal_id: &str) -> Result<GoalState> {
    let mut state = super::resolve_goal(goal_id).await?;
    let now = Utc::now();
    state.status = GoalStatus::Cancelled;
    state.updated_at = now;
    state.completed_at = Some(now);
    state.failure = Some(GoalFailure {
        reason: "cancelled by user".to_string(),
        recorded_at: now,
    });
    FileSystemGoalStateStore::new().save(&state).await?;

    let failure_json = serde_json::to_string_pretty(&state)?;
    crate::runtime::atomic::atomic_write(
        &state.state_dir.join(state::GOAL_FAILURE_FILE),
        failure_json.as_bytes(),
    )
    .await?;

    let writer = crate::runtime::events::EventWriter::new(
        state.state_dir.join(crate::runtime::config::EVENTS_FILE),
    );
    let run_id = crate::runtime::events::RunId(state.goal_id.clone());
    let interrupted = crate::runtime::events::Event::new(
        run_id.clone(),
        crate::runtime::events::EventKind::ManualInterrupt,
    )
    .with_actor("omk-cli");
    let failed =
        crate::runtime::events::EventBuilder::new(run_id).run_failed("cancelled by user")?;
    writer.append_many(&[interrupted, failed]).await?;
    budget::append_budget_checkpoint(&state, "goal_cancelled").await?;

    Ok(state)
}

async fn append_goal_lifecycle_event(
    state: &GoalState,
    kind: crate::runtime::events::EventKind,
) -> Result<()> {
    let writer = crate::runtime::events::EventWriter::new(
        state.state_dir.join(crate::runtime::config::EVENTS_FILE),
    );
    let event = crate::runtime::events::Event::new(
        crate::runtime::events::RunId(state.goal_id.clone()),
        kind,
    )
    .with_actor("omk-cli")
    .with_payload(serde_json::json!({
        "status": state.status.to_string(),
        "phase": state.phase.to_string(),
        "updated_at": state.updated_at,
    }))?;
    writer.append(&event).await
}