kaizen/shell/
init.rs

1// SPDX-License-Identifier: AGPL-3.0-or-later
2//! `kaizen init` — idempotent workspace setup.
3
4use anyhow::Result;
5use std::fmt::Write;
6use std::path::{Path, PathBuf};
7use std::time::{SystemTime, UNIX_EPOCH};
8
9const CONFIG_TOML: &str = r#"[kaizen]
10
11# Optional sync (usually override secrets in ~/.kaizen/config.toml):
12# [sync]
13# endpoint = "https://ingest.example.com"
14# team_token = "Bearer-token-from-server"
15# team_id = "your-team"
16# events_per_batch_max = 500
17# max_body_bytes = 1000000
18# flush_interval_ms = 10000
19# sample_rate = 1.0
20"#;
21const KAIZEN_RETRO_SKILL: &str = include_str!("../../assets/kaizen-retro-SKILL.md");
22const KAIZEN_EVAL_SKILL: &str = include_str!("../../assets/kaizen-eval-SKILL.md");
23
24const CURSOR_HOOK_EVENTS: &[&str] = &["SessionStart", "PreToolUse", "PostToolUse", "Stop"];
25const CLAUDE_HOOK_EVENTS: &[&str] = &["SessionStart", "PreToolUse", "PostToolUse", "Stop"];
26
27fn ts_ms() -> u64 {
28    SystemTime::now()
29        .duration_since(UNIX_EPOCH)
30        .unwrap_or_default()
31        .as_millis() as u64
32}
33
34fn backup_path(ws: &Path, filename: &str) -> PathBuf {
35    ws.join(format!(".kaizen/backup/{}.{}.bak", filename, ts_ms()))
36}
37
38fn ensure_config(out: &mut String, ws: &Path) -> Result<()> {
39    let path = ws.join(".kaizen/config.toml");
40    if path.exists() {
41        writeln!(out, "  skipped  .kaizen/config.toml").unwrap();
42        return Ok(());
43    }
44    std::fs::create_dir_all(ws.join(".kaizen"))?;
45    std::fs::write(&path, CONFIG_TOML)?;
46    writeln!(out, "  created  .kaizen/config.toml").unwrap();
47    Ok(())
48}
49
50/// Hook command string written to `.cursor/hooks.json`.
51pub const KAIZEN_CURSOR_HOOK_CMD: &str = "kaizen ingest hook --source cursor";
52pub const KAIZEN_OPENCLAW_HOOK_CMD: &str = "kaizen ingest hook --source openclaw";
53/// Hook command string written to `.claude/settings.json`.
54pub const KAIZEN_CLAUDE_HOOK_CMD: &str = "kaizen ingest hook --source claude";
55
56/// `true` if every Cursor hook event points at the kaizen ingest command.
57fn cursor_hooks_done(root: &serde_json::Value) -> bool {
58    CURSOR_HOOK_EVENTS
59        .iter()
60        .all(|event| cursor_hook_exists(root, event))
61}
62
63fn cursor_hook_exists(root: &serde_json::Value, event: &str) -> bool {
64    if let Some(arr) = root
65        .pointer(&format!("/hooks/{event}"))
66        .and_then(|v| v.as_array())
67    {
68        return arr
69            .iter()
70            .any(|v| v.get("command").and_then(|c| c.as_str()) == Some(KAIZEN_CURSOR_HOOK_CMD));
71    }
72    if let Some(arr) = root.as_array() {
73        return arr.iter().any(|v| {
74            v.get("matcher").and_then(|m| m.as_str()) == Some(event)
75                && v.get("command").and_then(|c| c.as_str()) == Some(KAIZEN_CURSOR_HOOK_CMD)
76        });
77    }
78    false
79}
80
81fn patch_cursor_hooks(out: &mut String, ws: &Path) -> Result<()> {
82    let path = ws.join(".cursor/hooks.json");
83    if !path.exists() {
84        std::fs::create_dir_all(path.parent().unwrap())?;
85        let mut obj = serde_json::Map::new();
86        let mut hooks = serde_json::Map::new();
87        for event in CURSOR_HOOK_EVENTS {
88            hooks.insert(
89                (*event).to_string(),
90                serde_json::json!([{"command": KAIZEN_CURSOR_HOOK_CMD}]),
91            );
92        }
93        obj.insert("hooks".to_string(), serde_json::Value::Object(hooks));
94        std::fs::write(&path, serde_json::to_string_pretty(&obj)?)?;
95        writeln!(out, "  created  .cursor/hooks.json").unwrap();
96        return Ok(());
97    }
98    let raw = std::fs::read_to_string(&path)?;
99    let mut root: serde_json::Value = match serde_json::from_str(&raw) {
100        Ok(v) => v,
101        Err(e) => {
102            writeln!(out, "  error  .cursor/hooks.json: {e}").unwrap();
103            anyhow::bail!("malformed .cursor/hooks.json: {e}");
104        }
105    };
106    if cursor_hooks_done(&root) {
107        writeln!(out, "  skipped  .cursor/hooks.json").unwrap();
108        return Ok(());
109    }
110    let bak = backup_path(ws, "cursor_hooks");
111    std::fs::create_dir_all(bak.parent().unwrap())?;
112    std::fs::copy(&path, &bak)?;
113    if let Some(obj) = root.pointer_mut("/hooks").and_then(|v| v.as_object_mut()) {
114        for event in CURSOR_HOOK_EVENTS {
115            let arr = obj
116                .entry((*event).to_string())
117                .or_insert_with(|| serde_json::json!([]));
118            if let Some(hooks) = arr.as_array_mut()
119                && !hooks.iter().any(|v| {
120                    v.get("command").and_then(|c| c.as_str()) == Some(KAIZEN_CURSOR_HOOK_CMD)
121                })
122            {
123                hooks.push(serde_json::json!({"command": KAIZEN_CURSOR_HOOK_CMD}));
124            }
125        }
126    } else if let Some(arr) = root.as_array_mut() {
127        for event in CURSOR_HOOK_EVENTS {
128            if !cursor_hook_exists(&serde_json::Value::Array(arr.clone()), event) {
129                arr.push(serde_json::json!({"matcher": event, "command": KAIZEN_CURSOR_HOOK_CMD}));
130            }
131        }
132    }
133    std::fs::write(&path, serde_json::to_string_pretty(&root)?)?;
134    writeln!(out, "  patched  .cursor/hooks.json  (+session/tool hooks)").unwrap();
135    Ok(())
136}
137
138fn entry_has_kaizen_cmd(entry: &serde_json::Value) -> bool {
139    if entry.get("command").and_then(|c| c.as_str()) == Some(KAIZEN_CLAUDE_HOOK_CMD) {
140        return true;
141    }
142    entry
143        .get("hooks")
144        .and_then(|v| v.as_array())
145        .is_some_and(|inner| {
146            inner
147                .iter()
148                .any(|h| h.get("command").and_then(|c| c.as_str()) == Some(KAIZEN_CLAUDE_HOOK_CMD))
149        })
150}
151
152fn patch_claude_settings(out: &mut String, ws: &Path) -> Result<()> {
153    let path = ws.join(".claude/settings.json");
154    if !path.exists() {
155        std::fs::create_dir_all(path.parent().unwrap())?;
156        let mut obj = serde_json::Map::new();
157        let mut hooks = serde_json::Map::new();
158        for event in CLAUDE_HOOK_EVENTS {
159            hooks.insert(
160                (*event).to_string(),
161                serde_json::json!([
162                    {"hooks": [{"type": "command", "command": KAIZEN_CLAUDE_HOOK_CMD}]}
163                ]),
164            );
165        }
166        obj.insert("hooks".to_string(), serde_json::Value::Object(hooks));
167        std::fs::write(&path, serde_json::to_string_pretty(&obj)?)?;
168        writeln!(out, "  created  .claude/settings.json").unwrap();
169        return Ok(());
170    }
171    let raw = std::fs::read_to_string(&path)?;
172    let mut obj: serde_json::Map<String, serde_json::Value> = match serde_json::from_str(&raw) {
173        Ok(v) => v,
174        Err(e) => {
175            writeln!(out, "  error  .claude/settings.json: {e}").unwrap();
176            anyhow::bail!("malformed .claude/settings.json: {e}");
177        }
178    };
179    let hooks = obj.entry("hooks").or_insert_with(|| serde_json::json!({}));
180    let hooks_obj = hooks.as_object_mut().unwrap();
181    let mut changed = false;
182    for event in CLAUDE_HOOK_EVENTS {
183        let arr = hooks_obj
184            .entry((*event).to_string())
185            .or_insert_with(|| serde_json::json!([]));
186        let Some(entries) = arr.as_array_mut() else {
187            continue;
188        };
189        // Migrate any bare {command,type} entries missing the `hooks` wrapper.
190        for entry in entries.iter_mut() {
191            if entry.get("hooks").is_some() {
192                continue;
193            }
194            if let Some(obj) = entry.as_object()
195                && obj.contains_key("command")
196            {
197                let inner = entry.clone();
198                *entry = serde_json::json!({ "hooks": [inner] });
199                changed = true;
200            }
201        }
202        if !entries.iter().any(entry_has_kaizen_cmd) {
203            entries.push(serde_json::json!({
204                "hooks": [
205                    {"type": "command", "command": KAIZEN_CLAUDE_HOOK_CMD}
206                ]
207            }));
208            changed = true;
209        }
210    }
211    if !changed {
212        writeln!(
213            out,
214            "  skipped  .claude/settings.json  (already configured)"
215        )
216        .unwrap();
217        return Ok(());
218    }
219    let bak = backup_path(ws, "claude_settings");
220    std::fs::create_dir_all(bak.parent().unwrap())?;
221    std::fs::copy(&path, &bak)?;
222    std::fs::write(&path, serde_json::to_string_pretty(&obj)?)?;
223    writeln!(
224        out,
225        "  patched  .claude/settings.json  (+session/tool hooks)"
226    )
227    .unwrap();
228    Ok(())
229}
230
231/// Read-only: `.cursor/hooks.json` missing, valid JSON with full kaizen wiring, or not.
232pub fn cursor_kaizen_hook_wiring(ws: &Path) -> Result<Option<bool>, String> {
233    let path = ws.join(".cursor/hooks.json");
234    if !path.exists() {
235        return Ok(None);
236    }
237    let raw = std::fs::read_to_string(&path).map_err(|e| e.to_string())?;
238    let root: serde_json::Value = serde_json::from_str(&raw).map_err(|e| e.to_string())?;
239    Ok(Some(cursor_hooks_done(&root)))
240}
241
242/// Read-only: `.claude/settings.json` hooks all reference kaizen (same as post-patch `entry_has_kaizen_cmd`).
243pub fn claude_kaizen_hook_wiring(ws: &Path) -> Result<Option<bool>, String> {
244    let path = ws.join(".claude/settings.json");
245    if !path.exists() {
246        return Ok(None);
247    }
248    let raw = std::fs::read_to_string(&path).map_err(|e| e.to_string())?;
249    let obj: serde_json::Map<String, serde_json::Value> =
250        serde_json::from_str(&raw).map_err(|e| e.to_string())?;
251    let Some(hooks) = obj.get("hooks").and_then(|v| v.as_object()) else {
252        return Ok(Some(false));
253    };
254    for event in CLAUDE_HOOK_EVENTS {
255        let Some(arr) = hooks.get(*event).and_then(|v| v.as_array()) else {
256            return Ok(Some(false));
257        };
258        if !arr.iter().any(entry_has_kaizen_cmd) {
259            return Ok(Some(false));
260        }
261    }
262    Ok(Some(true))
263}
264
265fn write_eval_skill(out: &mut String, ws: &Path) -> Result<()> {
266    let path = ws.join(".cursor/skills/kaizen-eval/SKILL.md");
267    std::fs::create_dir_all(path.parent().unwrap())?;
268    if path.exists() {
269        let existing = std::fs::read_to_string(&path)?;
270        if !existing.contains("placeholder") && !existing.trim().is_empty() {
271            writeln!(out, "  skipped  .cursor/skills/kaizen-eval/SKILL.md").unwrap();
272            return Ok(());
273        }
274    }
275    std::fs::write(&path, KAIZEN_EVAL_SKILL)?;
276    writeln!(out, "  wrote  .cursor/skills/kaizen-eval/SKILL.md").unwrap();
277    Ok(())
278}
279
280fn write_skill(out: &mut String, ws: &Path) -> Result<()> {
281    let path = ws.join(".cursor/skills/kaizen-retro/SKILL.md");
282    std::fs::create_dir_all(path.parent().unwrap())?;
283    if path.exists() {
284        let existing = std::fs::read_to_string(&path)?;
285        if !existing.contains("placeholder") && !existing.trim().is_empty() {
286            writeln!(out, "  skipped  .cursor/skills/kaizen-retro/SKILL.md").unwrap();
287            return Ok(());
288        }
289    }
290    std::fs::write(&path, KAIZEN_RETRO_SKILL)?;
291    writeln!(out, "  wrote  .cursor/skills/kaizen-retro/SKILL.md").unwrap();
292    Ok(())
293}
294
295const OPENCLAW_HOOK_EVENTS: &[&str] = &[
296    "message:received",
297    "message:sent",
298    "command:new",
299    "command:reset",
300    "command:stop",
301    "session:compact:before",
302    "session:compact:after",
303    "session:patch",
304];
305
306const OPENCLAW_HANDLER_TS: &str = r#"import { spawn } from "child_process";
307
308export async function handler(event: Record<string, unknown>) {
309  const payload = JSON.stringify({
310    event: event["type"] ?? event["event"],
311    session_id: event["sessionId"] ?? event["session_id"] ?? "",
312    timestamp_ms: typeof event["timestamp"] === "number" ? event["timestamp"] : Date.now(),
313    ...event,
314  });
315  const child = spawn("kaizen", ["ingest", "hook", "--source", "openclaw"], {
316    stdio: ["pipe", "ignore", "ignore"],
317  });
318  child.stdin?.write(payload + "\n");
319  child.stdin?.end();
320}
321"#;
322
323const OPENCLAW_HOOK_MD: &str = "# kaizen-events\n\nCaptures OpenClaw sessions for kaizen.\n";
324
325fn openclaw_hooks_dir() -> Option<PathBuf> {
326    std::env::var("HOME")
327        .ok()
328        .map(|h| PathBuf::from(h).join(".openclaw/hooks/kaizen-events"))
329}
330
331/// Write (or idempotently skip) the OpenClaw TS hook handler.
332///
333/// Backs up any pre-existing `handler.ts` that does not already reference kaizen.
334pub fn patch_openclaw_handlers(out: &mut String, ws: &Path) -> Result<()> {
335    let Some(hook_dir) = openclaw_hooks_dir() else {
336        writeln!(
337            out,
338            "  skipped  ~/.openclaw/hooks/kaizen-events (HOME unset)"
339        )
340        .unwrap();
341        return Ok(());
342    };
343    let handler_path = hook_dir.join("handler.ts");
344    if handler_path.exists() {
345        let existing = std::fs::read_to_string(&handler_path)?;
346        if existing.contains(KAIZEN_OPENCLAW_HOOK_CMD) {
347            writeln!(out, "  skipped  ~/.openclaw/hooks/kaizen-events/handler.ts").unwrap();
348            return Ok(());
349        }
350        let bak = backup_path(ws, "openclaw_hook");
351        std::fs::create_dir_all(bak.parent().unwrap())?;
352        std::fs::copy(&handler_path, &bak)?;
353    }
354    std::fs::create_dir_all(&hook_dir)?;
355    std::fs::write(&handler_path, OPENCLAW_HANDLER_TS)?;
356    std::fs::write(hook_dir.join("HOOK.md"), OPENCLAW_HOOK_MD)?;
357    writeln!(out, "  created  ~/.openclaw/hooks/kaizen-events/handler.ts").unwrap();
358    let _ = std::process::Command::new("openclaw")
359        .args(["hooks", "enable", "kaizen-events"])
360        .status();
361    for event in OPENCLAW_HOOK_EVENTS {
362        let _ = std::process::Command::new("openclaw")
363            .args(["hooks", "subscribe", "kaizen-events", event])
364            .status();
365    }
366    Ok(())
367}
368
369/// Read-only: `~/.openclaw/hooks/kaizen-events` absent / wired / partial.
370pub fn openclaw_kaizen_hook_wiring(_ws: &Path) -> Result<Option<bool>, String> {
371    let Some(hook_dir) = openclaw_hooks_dir() else {
372        return Ok(None);
373    };
374    if !hook_dir.is_dir() {
375        return Ok(None);
376    }
377    let handler_path = hook_dir.join("handler.ts");
378    let hook_md = hook_dir.join("HOOK.md");
379    if !handler_path.exists() || !hook_md.exists() {
380        return Ok(Some(false));
381    }
382    let raw = std::fs::read_to_string(&handler_path).map_err(|e| e.to_string())?;
383    Ok(Some(raw.contains(KAIZEN_OPENCLAW_HOOK_CMD)))
384}
385
386/// Text that `kaizen init` would print to stdout.
387pub fn init_text(workspace: Option<&std::path::Path>) -> Result<String> {
388    let ws = match workspace {
389        Some(p) => p.to_path_buf(),
390        None => std::env::current_dir()?,
391    };
392    let mut out = String::new();
393    ensure_config(&mut out, &ws)?;
394    patch_cursor_hooks(&mut out, &ws)?;
395    patch_claude_settings(&mut out, &ws)?;
396    patch_openclaw_handlers(&mut out, &ws)?;
397    write_skill(&mut out, &ws)?;
398    write_eval_skill(&mut out, &ws)?;
399    let cws = crate::core::workspace::canonical(&ws);
400    if let Err(e) = crate::core::machine_registry::record_init(&cws) {
401        tracing::warn!("machine registry: {e:#}");
402    }
403    writeln!(out).unwrap();
404    writeln!(
405        out,
406        "kaizen init complete — Cursor + Claude Code + OpenClaw hooks wired."
407    )
408    .unwrap();
409    writeln!(out).unwrap();
410    writeln!(out, "Run Cursor or Claude Code in this repo once, then:").unwrap();
411    writeln!(
412        out,
413        "  kaizen summary            # cost + rollups (agent / model)"
414    )
415    .unwrap();
416    writeln!(
417        out,
418        "  kaizen insights           # activity, top tools, guidance"
419    )
420    .unwrap();
421    writeln!(out, "  kaizen tui                # live session browser").unwrap();
422    writeln!(out, "  kaizen retro --days 7     # weekly heuristic bets").unwrap();
423    writeln!(out).unwrap();
424    writeln!(
425        out,
426        "Agents: `kaizen mcp` exposes every command as MCP tools — see docs/mcp.md."
427    )
428    .unwrap();
429    Ok(out)
430}
431
432/// Idempotent workspace setup.
433pub fn cmd_init(workspace: Option<&Path>) -> Result<()> {
434    print!("{}", init_text(workspace)?);
435    Ok(())
436}
kaizen/shell/init.rs

kaizen/shell/
init.rs
