a3s 0.8.1

a3s — A3S coding agent CLI; `a3s code` launches the interactive TUI
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

//! Deterministic claim/source audit for a materialized research report.

use serde::{Deserialize, Serialize};
use std::collections::HashSet;

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub(crate) struct ReportAudit {
    pub(crate) passed: bool,
    pub(crate) accepted_claims: usize,
    pub(crate) matched_claims: usize,
    pub(crate) claim_coverage_basis_points: u16,
    pub(crate) accepted_sources: usize,
    pub(crate) cited_sources: usize,
    pub(crate) reason: String,
}

pub(crate) fn audit_report(
    markdown: &str,
    html: &str,
    claims: &[String],
    source_anchors: &[String],
) -> ReportAudit {
    if claims.is_empty() && source_anchors.is_empty() {
        return ReportAudit {
            passed: true,
            accepted_claims: 0,
            matched_claims: 0,
            claim_coverage_basis_points: 10_000,
            accepted_sources: 0,
            cited_sources: 0,
            reason: "legacy report has no event-sourced evidence graph to audit".to_string(),
        };
    }
    let report = normalize(&format!("{markdown}\n{html}"));
    let matched_claims = claims
        .iter()
        .filter(|claim| claim_matches(&report, claim))
        .count();
    let claim_coverage_basis_points = if claims.is_empty() {
        10_000
    } else {
        ((matched_claims.saturating_mul(10_000) / claims.len()).min(10_000)) as u16
    };
    let cited_sources = source_anchors
        .iter()
        .filter(|anchor| markdown.contains(anchor.as_str()) || html.contains(anchor.as_str()))
        .count();
    let sources_pass = !source_anchors.is_empty() && cited_sources > 0;
    let claims_pass = claims.is_empty() || claim_coverage_basis_points >= 5_000;
    let passed = sources_pass && claims_pass;
    let reason = if !sources_pass {
        "report cites none of the accepted evidence sources"
    } else if !claims_pass {
        "report covers less than half of the accepted claims"
    } else {
        "report claims and citations trace to accepted evidence"
    };
    ReportAudit {
        passed,
        accepted_claims: claims.len(),
        matched_claims,
        claim_coverage_basis_points,
        accepted_sources: source_anchors.len(),
        cited_sources,
        reason: reason.to_string(),
    }
}

fn claim_matches(report: &str, claim: &str) -> bool {
    let claim = normalize(claim);
    if claim.is_empty() || report.contains(&claim) {
        return !claim.is_empty();
    }
    let terms = claim
        .split_whitespace()
        .filter(|term| term.len() >= 3)
        .collect::<HashSet<_>>();
    if terms.is_empty() {
        return false;
    }
    let matched = terms
        .iter()
        .filter(|term| report.split_whitespace().any(|word| word == **term))
        .count();
    matched.saturating_mul(100) / terms.len() >= 60
}

fn normalize(text: &str) -> String {
    text.chars()
        .map(|ch| {
            if ch.is_alphanumeric() {
                ch.to_ascii_lowercase()
            } else {
                ' '
            }
        })
        .collect::<String>()
        .split_whitespace()
        .collect::<Vec<_>>()
        .join(" ")
}

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

    #[test]
    fn accepts_report_with_source_and_claim_coverage() {
        let audit = audit_report(
            "The release date is July 12. Source: https://example.gov/release",
            "<p>The release was published on July 12.</p>",
            &["The release date is July 12.".to_string()],
            &["https://example.gov/release".to_string()],
        );
        assert!(audit.passed);
        assert_eq!(audit.claim_coverage_basis_points, 10_000);
    }

    #[test]
    fn rejects_polished_report_without_accepted_claims() {
        let audit = audit_report(
            "A polished but unrelated conclusion. https://example.gov/release",
            "<p>Unrelated analysis.</p>",
            &["The release date is July 12.".to_string()],
            &["https://example.gov/release".to_string()],
        );
        assert!(!audit.passed);
        assert!(audit.reason.contains("less than half"));
    }
}