kaizen-cli 0.1.38

Distributable agent observability: real-time-tailable sessions, agile-style retros, and repo-level improvement (Cursor, Claude Code, Codex). SQLite, redact before any sync you enable.
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

use crate::bin_kaizen::args::*;
use crate::bin_kaizen::dispatch::common::ws;
use crate::bin_kaizen::workspace::resolve_ws;
use kaizen::DataSource;
use std::path::PathBuf;

pub(super) fn cases(cmd: CasesCommand) -> anyhow::Result<()> {
    match cmd {
        CasesCommand::Mine(a) => {
            kaizen::shell::cases::cmd_cases_mine(ws(&a.ws)?.as_deref(), a.since.as_deref(), a.json)
        }
        CasesCommand::Create {
            session,
            reason,
            label,
            json,
            ws: f,
        } => kaizen::shell::cases::cmd_cases_create(
            ws(&f)?.as_deref(),
            &session,
            &reason,
            label,
            json,
        ),
        CasesCommand::List {
            status,
            json,
            ws: f,
        } => kaizen::shell::cases::cmd_cases_list(ws(&f)?.as_deref(), status, json),
        CasesCommand::Show(a) => {
            kaizen::shell::cases::cmd_cases_show(ws(&a.ws)?.as_deref(), &a.id, a.json)
        }
        CasesCommand::Archive(a) => {
            kaizen::shell::cases::cmd_cases_archive(ws(&a.ws)?.as_deref(), &a.id)
        }
    }
}

pub(super) fn rules(cmd: RulesCommand) -> anyhow::Result<()> {
    match cmd {
        RulesCommand::Create {
            name,
            filter,
            action,
            message,
            ws: f,
        } => kaizen::shell::rules::cmd_rules_create(
            ws(&f)?.as_deref(),
            &name,
            &filter,
            &action,
            message,
        ),
        RulesCommand::List(a) => {
            kaizen::shell::rules::cmd_rules_list(ws(&a.ws)?.as_deref(), a.json)
        }
        RulesCommand::Run {
            since,
            dry_run,
            json,
            ws: f,
        } => {
            kaizen::shell::rules::cmd_rules_run(ws(&f)?.as_deref(), since.as_deref(), dry_run, json)
        }
        RulesCommand::Enable(a) => {
            kaizen::shell::rules::cmd_rules_enable(ws(&a.ws)?.as_deref(), &a.id, true)
        }
        RulesCommand::Disable(a) => {
            kaizen::shell::rules::cmd_rules_enable(ws(&a.ws)?.as_deref(), &a.id, false)
        }
    }
}

pub(super) fn alerts(cmd: AlertsCommand) -> anyhow::Result<()> {
    match cmd {
        AlertsCommand::Check { days, json, ws: f } => {
            kaizen::shell::alerts::cmd_alerts_check(ws(&f)?.as_deref(), days, json)
        }
    }
}

pub(super) fn review(cmd: ReviewCommand) -> anyhow::Result<()> {
    match cmd {
        ReviewCommand::List {
            status,
            json,
            ws: f,
        } => kaizen::shell::review::cmd_review_list(ws(&f)?.as_deref(), status, json),
        ReviewCommand::Show(a) => {
            kaizen::shell::review::cmd_review_show(ws(&a.ws)?.as_deref(), &a.id, a.json)
        }
        ReviewCommand::Resolve(a) => {
            kaizen::shell::review::cmd_review_resolve(ws(&a.ws)?.as_deref(), &a.id)
        }
        ReviewCommand::Dismiss(a) => {
            kaizen::shell::review::cmd_review_dismiss(ws(&a.ws)?.as_deref(), &a.id)
        }
    }
}

pub(super) fn eval(cmd: EvalCommand) -> anyhow::Result<()> {
    match cmd {
        EvalCommand::Run {
            workspace,
            project,
            since_days,
            dry_run,
            json,
        } => {
            let ws = resolve_ws(workspace.as_deref(), project.as_deref())?;
            kaizen::shell::eval::cmd_eval_run(ws.as_deref(), since_days, dry_run, json)
        }
        EvalCommand::List {
            workspace,
            project,
            min_score,
            json,
        } => {
            let ws = resolve_ws(workspace.as_deref(), project.as_deref())?;
            kaizen::shell::eval::cmd_eval_list(ws.as_deref(), min_score, json)
        }
        EvalCommand::Prompt {
            workspace,
            project,
            session_id,
            rubric,
        } => {
            let ws = resolve_ws(workspace.as_deref(), project.as_deref())?;
            kaizen::shell::eval::cmd_eval_prompt(ws.as_deref(), &session_id, &rubric)
        }
    }
}

pub(super) struct RetroRequest {
    pub(super) days: u32,
    pub(super) dry_run: bool,
    pub(super) json: bool,
    pub(super) force: bool,
    pub(super) workspace: Option<PathBuf>,
    pub(super) project: Option<String>,
    pub(super) refresh: bool,
    pub(super) source: DataSource,
}

pub(super) fn retro(req: RetroRequest) -> anyhow::Result<()> {
    let ws = resolve_ws(req.workspace.as_deref(), req.project.as_deref())?;
    kaizen::shell::retro::cmd_retro(
        ws.as_deref(),
        req.days,
        req.dry_run,
        req.json,
        req.force,
        req.refresh,
        req.source,
    )
}