kaizen-cli 0.1.45

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

// SPDX-License-Identifier: AGPL-3.0-or-later
//! Scientific skill/rule scoring and candidate commands.

use crate::guidance::{self, ArtifactRef, GuidanceCandidate};
use crate::shell::cli::workspace_path;
use crate::store::Store;
use anyhow::{Result, anyhow};
use std::fmt::Write;
use std::path::Path;

pub fn cmd_score(ws: Option<&Path>, days: u32, min_sessions: u64, json_out: bool) -> Result<()> {
    print!("{}", score_text(ws, days, min_sessions, json_out)?);
    Ok(())
}

pub fn score_text(
    ws: Option<&Path>,
    days: u32,
    min_sessions: u64,
    json_out: bool,
) -> Result<String> {
    let ws = workspace_path(ws)?;
    let store = Store::open(&crate::core::workspace::db_path(&ws)?)?;
    let ws_key = ws.to_string_lossy().to_string();
    let (start, end) = crate::shell::guidance::trailing_window_ms(days);
    let report = guidance::score::build(&store, &ws, &ws_key, start, end, min_sessions)?;
    if json_out {
        return Ok(serde_json::to_string_pretty(&report)?);
    }
    Ok(format_score(&report))
}

pub fn cmd_propose(
    ws: Option<&Path>,
    artifact: &str,
    max_ops: usize,
    llm: bool,
    json_out: bool,
) -> Result<()> {
    print!("{}", propose_text(ws, artifact, max_ops, llm, json_out)?);
    Ok(())
}

pub fn propose_text(
    ws: Option<&Path>,
    artifact: &str,
    max_ops: usize,
    llm: bool,
    json_out: bool,
) -> Result<String> {
    let ws = workspace_path(ws)?;
    let store = Store::open(&crate::core::workspace::db_path(&ws)?)?;
    let artifact =
        ArtifactRef::parse(artifact).ok_or_else(|| anyhow!("use skill:<id> or rule:<id>"))?;
    let candidate = proposed_candidate(&ws, &store, &artifact, max_ops, llm)?;
    store.upsert_guidance_candidate(&candidate)?;
    if json_out {
        Ok(serde_json::to_string_pretty(&candidate)?)
    } else {
        Ok(crate::shell::guidance_candidates::format_candidate(
            &candidate,
        ))
    }
}

fn proposed_candidate(
    ws: &Path,
    store: &Store,
    artifact: &ArtifactRef,
    max_ops: usize,
    llm: bool,
) -> Result<GuidanceCandidate> {
    let row = score_row(ws, store, artifact)?;
    let rejected = store.rejected_guidance_candidates(artifact, 5)?;
    if llm {
        let cfg = crate::core::config::load(ws)?.guidance.proposals;
        return guidance::llm::candidate(&cfg, &row, max_ops, now_ms(), &rejected, ws);
    }
    Ok(guidance::proposals::deterministic(
        &row,
        now_ms(),
        &rejected,
    ))
}

fn score_row(
    ws: &Path,
    store: &Store,
    artifact: &ArtifactRef,
) -> Result<crate::guidance::GuidanceScoreRow> {
    let ws_key = ws.to_string_lossy().to_string();
    let (start, end) = crate::shell::guidance::trailing_window_ms(30);
    let report = guidance::score::build(store, ws, &ws_key, start, end, 30)?;
    report
        .rows
        .into_iter()
        .find(|r| r.artifact == *artifact)
        .ok_or_else(|| anyhow!("artifact not in scorecard: {artifact}"))
}

fn format_score(report: &crate::guidance::GuidanceScoreReport) -> String {
    let mut out = String::new();
    let _ = writeln!(&mut out, "guidance score - {}", report.workspace);
    let _ = writeln!(
        &mut out,
        "{:<8} {:<24} {:>7} {:>7} {:>8} STATE",
        "kind", "id", "score", "val", "sessions"
    );
    for row in &report.rows {
        let _ = writeln!(
            &mut out,
            "{:<8} {:<24} {:>7.1} {:>7.1} {:>8} {:?}",
            row.artifact.kind.as_str(),
            row.artifact.slug,
            row.score,
            row.validation.score,
            row.sessions,
            row.state
        );
    }
    out
}

fn now_ms() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap_or_default()
        .as_millis() as u64
}