jev-seo 0.4.0

Free Rust SEO and GEO toolkit powered by TypeSafe Jev: 64-rule audits, site crawls, AI citation checks, rank drift, CI gates, 19-tool MCP. Zero cost.
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

//! `jev-seo check` — one-command search CI. Policy + audit scope +
//! baseline compare + exit code. SARIF/JUnit writers for GitHub.

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckResult {
    pub path: String,
    pub pass_rate: f64,
    pub blocking: usize,
    pub critical: usize,
    pub verdict: String,
    pub findings: Vec<CheckFinding>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckFinding {
    pub rule: String,
    pub target: String,
    pub severity: String,
    pub gate: String,
}

/// SARIF 2.1.0 minimal: one run, one driver, results carry ruleId + level.
pub fn to_sarif(tool: &str, version: &str, findings: &[CheckFinding]) -> String {
    let results: Vec<serde_json::Value> = findings
        .iter()
        .map(|f| {
            serde_json::json!({
                "ruleId": f.rule,
                "level": if f.gate == "blocking" { "error" } else { "warning" },
                "message": { "text": format!("{} on {}", f.rule, f.target) },
                "locations": [{ "physicalLocation": {
                    "artifactLocation": { "uri": f.target },
                }}],
            })
        })
        .collect();
    serde_json::to_string_pretty(&serde_json::json!({
        "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
        "version": "2.1.0",
        "runs": [{ "tool": { "driver": { "name": tool, "version": version } },
            "results": results }],
    }))
    .unwrap_or_default()
}

/// JUnit minimal: one testsuite, blocking findings are failures.
pub fn to_junit(suite: &str, findings: &[CheckFinding]) -> String {
    let mut out = format!(
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<testsuite name=\"{}\" tests=\"{}\" failures=\"{}\">\n",
        xml_escape(suite),
        findings.len(),
        findings.iter().filter(|f| f.gate == "blocking").count(),
    );
    for f in findings {
        out.push_str(&format!(
            "  <testcase classname=\"search\" name=\"{}-{}\">\n",
            xml_escape(&f.rule),
            xml_escape(&f.target)
        ));
        if f.gate == "blocking" {
            out.push_str(&format!(
                "    <failure message=\"{} ({})\"/>\n",
                xml_escape(&f.rule),
                xml_escape(&f.severity)
            ));
        }
        out.push_str("  </testcase>\n");
    }
    out.push_str("</testsuite>\n");
    out
}

fn xml_escape(s: &str) -> String {
    s.replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
        .replace('"', "&quot;")
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn sarif_shape() {
        let f = vec![CheckFinding {
            rule: "R09".into(),
            target: "docs/a.md".into(),
            severity: "High".into(),
            gate: "blocking".into(),
        }];
        let s: serde_json::Value = serde_json::from_str(&to_sarif("jev-seo", "0.4.0", &f)).unwrap();
        assert_eq!(s["version"], "2.1.0");
        assert_eq!(s["runs"][0]["results"][0]["level"], "error");
    }
}