keel-harness 0.3.2

A gated harness for AI-assisted delivery: auditable stopping conditions and durable memory across coding agents.
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

//! `keel driver list|check|scaffold` — the drivers available, whether they
//! conform, and getting the reference scripts onto disk in the first place.

use crate::config::Config;
use crate::driver::conform;
use crate::paths::Paths;
use anyhow::Result;

pub fn scaffold(force: bool) -> Result<i32> {
    let paths = Paths::require_init()?;
    let cfg = Config::load(&paths.config())?;
    for line in crate::driver::scaffold(&paths, &cfg, force)? {
        println!("{line}");
    }
    println!("\nrun `keel driver list` to see what is reachable, or `keel run <slug> --driver <id>`.");
    Ok(0)
}

pub fn list() -> Result<i32> {
    let paths = Paths::require_init()?;
    let cfg = Config::load(&paths.config())?;
    if cfg.drivers.is_empty() {
        println!("  no drivers configured");
        return Ok(0);
    }
    for d in &cfg.drivers {
        let bin = paths.repo.join(&d.cmd);
        let reachable = bin.is_file() || which(&d.cmd);
        println!(
            "  {:<14} {:<34} {:<8} {}",
            d.id,
            d.cmd,
            if d.default { "default" } else { "" },
            if reachable { "" } else { "NOT FOUND" }
        );
    }
    println!("\n  `keel driver check <id>` runs the conformance suite");
    Ok(0)
}

fn which(cmd: &str) -> bool {
    let program = cmd.split_whitespace().next().unwrap_or(cmd);
    std::process::Command::new("sh")
        .args(["-c", &format!("command -v {program}")])
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false)
}

pub fn check(id: Option<String>, json: bool) -> Result<i32> {
    let paths = Paths::require_init()?;
    let cfg = Config::load(&paths.config())?;

    let targets: Vec<&crate::config::Driver> = match &id {
        Some(id) => vec![
            cfg.drivers
                .iter()
                .find(|d| &d.id == id)
                .ok_or_else(|| anyhow::anyhow!("no driver `{id}` in .keel/keel.toml"))?,
        ],
        None => cfg.drivers.iter().collect(),
    };

    let mut worst = crate::gate::Verdict::Pass;
    let mut reports = Vec::new();

    for d in targets {
        let c = conform::check(&paths, d)?;
        if !json {
            println!("driver `{}` — {}\n", c.driver, c.verdict.glyph());
            for check in &c.checks {
                println!("{}", check.line());
            }
            if let Some(r) = &c.result {
                println!("\n  reported: {} — {}", r.status_str(), r.detail.clone().unwrap_or_default());
            }
            println!();
        }
        if c.verdict == crate::gate::Verdict::Fail {
            worst = crate::gate::Verdict::Fail;
        } else if c.verdict == crate::gate::Verdict::Blocked && worst == crate::gate::Verdict::Pass {
            worst = crate::gate::Verdict::Blocked;
        }
        reports.push(serde_json::json!({
            "driver": c.driver,
            "verdict": c.verdict,
            "checks": c.checks,
        }));
    }

    if json {
        println!("{}", serde_json::to_string_pretty(&reports)?);
    } else {
        println!("conformance: {}", worst.glyph());
        if worst == crate::gate::Verdict::Blocked {
            println!("blocked is not failed: a driver keel could not reach says nothing about the contract.");
        }
    }
    Ok(worst.exit_code())
}