heal-cli 0.2.1

Hook-driven Evaluation & Autonomous Loop — code-health harness CLI for AI coding agents
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

use chrono::{Datelike, TimeZone, Utc};
use heal_cli::core::eventlog::{Event, EventLog};
use heal_cli::core::snapshot::{MetricsSnapshot, METRICS_SNAPSHOT_VERSION};
use serde_json::json;

#[test]
fn metrics_snapshot_round_trips_through_writer() {
    let dir = tempfile::tempdir().unwrap();
    let log = EventLog::new(dir.path());

    let metrics = MetricsSnapshot {
        version: METRICS_SNAPSHOT_VERSION,
        git_sha: Some("a3b1c2f".into()),
        loc: Some(json!({"primary": "rust"})),
        complexity: Some(json!({"max_ccn": 12})),
        churn: None,
        change_coupling: None,
        duplication: None,
        hotspot: None,
        lcom: None,
        severity_counts: None,
        codebase_files: None,
        delta: None,
    };
    let event = Event {
        timestamp: Utc.with_ymd_and_hms(2026, 4, 20, 12, 0, 0).unwrap(),
        event: "commit".into(),
        data: serde_json::to_value(&metrics).unwrap(),
    };
    log.append(&event).unwrap();

    let events: Vec<_> = log.try_iter().unwrap().collect::<Result<_, _>>().unwrap();
    assert_eq!(events.len(), 1);
    let decoded: MetricsSnapshot = serde_json::from_value(events[0].data.clone()).unwrap();
    assert_eq!(decoded, metrics);
}

#[test]
fn latest_in_returns_most_recent() {
    let dir = tempfile::tempdir().unwrap();
    let log = EventLog::new(dir.path());
    let mk = |month: u32, sha: &str| -> Event {
        let m = MetricsSnapshot {
            git_sha: Some(sha.into()),
            ..MetricsSnapshot::default()
        };
        Event {
            timestamp: Utc.with_ymd_and_hms(2026, month, 1, 0, 0, 0).unwrap(),
            event: "commit".into(),
            data: serde_json::to_value(&m).unwrap(),
        }
    };
    log.append(&mk(2, "feb")).unwrap();
    log.append(&mk(3, "mar")).unwrap();
    log.append(&mk(4, "apr")).unwrap();

    let (event, metrics) = MetricsSnapshot::latest_in(&log).unwrap().unwrap();
    assert_eq!(event.timestamp.month(), 4);
    assert_eq!(metrics.git_sha.as_deref(), Some("apr"));
}

#[test]
fn latest_in_skips_legacy_payloads() {
    let dir = tempfile::tempdir().unwrap();
    let log = EventLog::new(dir.path());

    let real = MetricsSnapshot {
        git_sha: Some("real".into()),
        ..MetricsSnapshot::default()
    };
    log.append(&Event {
        timestamp: Utc.with_ymd_and_hms(2026, 4, 1, 0, 0, 0).unwrap(),
        event: "commit".into(),
        data: serde_json::to_value(&real).unwrap(),
    })
    .unwrap();
    // Legacy payload from a pre-MetricsSnapshot binary, written *after* the
    // real snapshot — must be skipped so the real one is returned.
    log.append(&Event {
        timestamp: Utc.with_ymd_and_hms(2026, 4, 2, 0, 0, 0).unwrap(),
        event: "edit".into(),
        data: json!("raw stdin string"),
    })
    .unwrap();

    let (_, metrics) = MetricsSnapshot::latest_in(&log).unwrap().unwrap();
    assert_eq!(metrics.git_sha.as_deref(), Some("real"));
}

#[test]
fn latest_in_empty_dir_returns_none() {
    let dir = tempfile::tempdir().unwrap();
    let log = EventLog::new(dir.path().join("missing"));
    assert!(MetricsSnapshot::latest_in(&log).unwrap().is_none());
}

#[test]
fn metrics_snapshot_default_version_is_current() {
    let snap = MetricsSnapshot::default();
    assert_eq!(snap.version, METRICS_SNAPSHOT_VERSION);
    assert!(snap.git_sha.is_none());
    assert!(snap.delta.is_none());
}

#[test]
fn latest_in_skips_corrupt_jsonl_lines() {
    use std::io::Write;
    let dir = tempfile::tempdir().unwrap();
    let log = EventLog::new(dir.path());

    let real = MetricsSnapshot {
        git_sha: Some("good".into()),
        ..MetricsSnapshot::default()
    };
    log.append(&Event {
        timestamp: Utc.with_ymd_and_hms(2026, 4, 1, 0, 0, 0).unwrap(),
        event: "commit".into(),
        data: serde_json::to_value(&real).unwrap(),
    })
    .unwrap();

    // Append a half-written line directly to simulate a SIGINT mid-write.
    // The current segment file is named YYYY-MM.jsonl; reuse the timestamp
    // we wrote above.
    let seg = dir.path().join("2026-04.jsonl");
    let mut f = std::fs::OpenOptions::new().append(true).open(&seg).unwrap();
    writeln!(f, "{{ this is not json").unwrap();
    drop(f);

    let (_, metrics) = MetricsSnapshot::latest_in(&log).unwrap().unwrap();
    assert_eq!(
        metrics.git_sha.as_deref(),
        Some("good"),
        "corrupt trailing line must be skipped, not propagated as an error"
    );
}