dkp 0.1.1

dkp — Domain Knowledge Pack management CLI
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

use anyhow::Result;
use clap::Args;
use std::path::PathBuf;

use dkp_core::{
    validate::{
        gate4, gate7, gate8,
        gates::{ConformanceLevel, GateStatus, ValidationReport},
    },
    Pack,
};

use comfy_table::{presets::UTF8_FULL, Cell, Color, Table};

use crate::{cli::CmdCtx, output::Render};

#[derive(Args, Debug)]
pub struct ValidateArgs {
    /// Path to the DKP bundle directory
    pub pack: PathBuf,

    /// Treat warnings as errors
    #[arg(long)]
    pub strict: bool,

    /// Run only a specific quality gate (4, 7, or 8)
    #[arg(long, value_name = "N")]
    pub gate: Option<u8>,
}

impl Render for ValidationReport {
    fn render_plain(&self) -> String {
        let mut out = String::new();
        for gate in &self.gates {
            out.push_str(&format!("\n[Gate {}]\n", gate.gate));
            for check in &gate.checks {
                let icon = match check.status {
                    GateStatus::Pass => "OK      ",
                    GateStatus::Fail => "FAIL    ",
                    GateStatus::Skipped => "SKIPPED ",
                    GateStatus::NotApplicable => "N/A     ",
                };
                out.push_str(&format!("  {}  {}\n", icon, check.description));
                if let Some(ref d) = check.detail {
                    out.push_str(&format!("          {d}\n"));
                }
            }
        }
        out.push('\n');
        let status = match self.conformance {
            ConformanceLevel::DkpConformant => "DKP-Conformant",
            ConformanceLevel::DkpReviewed => "DKP-Reviewed",
            ConformanceLevel::NonConformant => "Non-Conformant",
        };
        out.push_str(&format!("Conformance: {status}\n"));
        out.push_str(&format!(
            "Reviewed:    {}\n",
            if self.reviewed {
                "Yes"
            } else {
                "No (no sign-off in evidence/review_notes.md)"
            }
        ));
        out
    }

    fn render_table(&self) -> String {
        let mut table = Table::new();
        table.load_preset(UTF8_FULL);
        table.set_header(["Gate", "Status", "Check", "Detail"]);
        for gate in &self.gates {
            for check in &gate.checks {
                let (label, color) = match check.status {
                    GateStatus::Pass => ("OK", Color::Green),
                    GateStatus::Fail => ("FAIL", Color::Red),
                    GateStatus::Skipped => ("SKIPPED", Color::Yellow),
                    GateStatus::NotApplicable => ("N/A", Color::DarkGrey),
                };
                table.add_row([
                    Cell::new(gate.gate),
                    Cell::new(label).fg(color),
                    Cell::new(&check.description),
                    Cell::new(check.detail.as_deref().unwrap_or("")),
                ]);
            }
        }
        let status = match self.conformance {
            ConformanceLevel::DkpConformant => "DKP-Conformant",
            ConformanceLevel::DkpReviewed => "DKP-Reviewed",
            ConformanceLevel::NonConformant => "Non-Conformant",
        };
        let reviewed = if self.reviewed { "Yes" } else { "No" };
        format!("{table}\n\nConformance: {status}    Reviewed: {reviewed}\n")
    }
}

pub async fn run(args: ValidateArgs, cli: &CmdCtx) -> Result<()> {
    let pack = Pack::open(&args.pack)?;

    let mut gate_results = Vec::new();

    let run_gate = |n: u8| args.gate.is_none_or(|g| g == n);

    if run_gate(4) {
        gate_results.push(gate4::run(&pack));
    }
    if run_gate(7) {
        gate_results.push(gate7::run(&pack));
    }
    if run_gate(8) {
        gate_results.push(gate8::run(&pack));
    }

    let any_failed = gate_results.iter().any(|g| g.status == GateStatus::Fail);
    let reviewed = has_review_signoff(&pack.evidence_file("review_notes.md"));

    let conformance = if any_failed {
        ConformanceLevel::NonConformant
    } else if reviewed {
        ConformanceLevel::DkpReviewed
    } else {
        ConformanceLevel::DkpConformant
    };

    let report = ValidationReport {
        pack_name: pack.manifest.name.clone(),
        pack_version: pack.manifest.version.clone(),
        gates: gate_results,
        overall: if any_failed {
            GateStatus::Fail
        } else {
            GateStatus::Pass
        },
        conformance,
        reviewed,
    };

    report.print(cli.output);

    if any_failed {
        anyhow::bail!("validation failed");
    }

    Ok(())
}

/// Returns true only if review_notes.md contains the canonical sign-off line.
/// Mere file presence is not enough — the author must explicitly attest.
fn has_review_signoff(path: &std::path::Path) -> bool {
    std::fs::read_to_string(path)
        .map(|s| s.lines().any(|l| l.trim() == "- **Status:** DKP-Reviewed"))
        .unwrap_or(false)
}