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

pub mod error;
pub mod handle;
pub mod migrations;
pub mod repo;
pub mod schema;
pub mod transaction;
pub mod types;

pub use error::DbError;
pub use handle::DbHandle;
pub use transaction::DbTransaction;
pub use types::{
    ArtifactRecord, BudgetCheckpoint, DecisionRecord, EventRecord, GoalFilter, GoalRecord,
    GoalSummary, ProofRecord, TaskRecord,
};

// Re-export repository traits so consumers don't need to reach into repo::.
pub use repo::{
    artifact::ArtifactRepo,
    budget::BudgetRepo,
    decision::DecisionRepo,
    event::EventRepo,
    goal::GoalRepo,
    proof::ProofRepo,
    slice_lease::{SliceLease, SliceLeaseRepo},
    task::TaskRepo,
};

use repo::{
    artifact::ArtifactRepoImpl, budget::BudgetRepoImpl, decision::DecisionRepoImpl,
    event::EventRepoImpl, goal::GoalRepoImpl, proof::ProofRepoImpl,
    slice_lease::SliceLeaseRepoImpl, task::TaskRepoImpl,
};

use std::sync::OnceLock;

static GLOBAL_DB: OnceLock<DbHandle> = OnceLock::new();

/// Set the global database handle used by runtime/goal code that does not
/// receive an explicit `DbHandle` parameter. Called once during app startup.
pub fn set_global_db(db: DbHandle) -> Result<(), DbHandle> {
    GLOBAL_DB.set(db)
}

/// Access the global database handle, if one has been set.
pub fn global_db() -> Option<DbHandle> {
    GLOBAL_DB.get().cloned()
}

impl DbHandle {
    /// Access the goal repository directly (auto-commit mode).
    pub fn goal_repo(&self) -> GoalRepoImpl {
        GoalRepoImpl {
            conn: self.conn.clone(),
        }
    }

    /// Access the task repository directly (auto-commit mode).
    pub fn task_repo(&self) -> TaskRepoImpl {
        TaskRepoImpl {
            conn: self.conn.clone(),
        }
    }

    /// Access the event repository directly (auto-commit mode).
    pub fn event_repo(&self) -> EventRepoImpl {
        EventRepoImpl {
            conn: self.conn.clone(),
        }
    }

    /// Access the proof repository directly (auto-commit mode).
    pub fn proof_repo(&self) -> ProofRepoImpl {
        ProofRepoImpl {
            conn: self.conn.clone(),
        }
    }

    /// Access the budget repository directly (auto-commit mode).
    pub fn budget_repo(&self) -> BudgetRepoImpl {
        BudgetRepoImpl {
            conn: self.conn.clone(),
        }
    }

    /// Access the artifact repository directly (auto-commit mode).
    pub fn artifact_repo(&self) -> ArtifactRepoImpl {
        ArtifactRepoImpl {
            conn: self.conn.clone(),
        }
    }

    /// Access the decision repository directly (auto-commit mode).
    pub fn decision_repo(&self) -> DecisionRepoImpl {
        DecisionRepoImpl {
            conn: self.conn.clone(),
        }
    }

    /// Access the slice lease repository directly (auto-commit mode).
    pub fn slice_lease_repo(&self) -> SliceLeaseRepoImpl {
        SliceLeaseRepoImpl {
            conn: self.conn.clone(),
        }
    }
}

#[cfg(test)]
mod tests;