pmat 3.17.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292

// Agent autonomous code and sub-agent composition: CB-1409 through CB-1410
// Included from check.rs
//
// Spec: docs/specifications/components/agent-integration.md

/// CB-1409: No L0 Autonomous Code
///
/// Checks recent git commits for AI co-author markers. If found, verifies
/// that a corresponding work contract exists in .pmat-work/. AI-authored
/// commits without contracts indicate L0 (paper-only) autonomous code.
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "path_exists")]
pub(crate) fn check_no_l0_autonomous_code(project_path: &Path) -> ComplianceCheck {
    // Get recent commits (last 20)
    let output = match std::process::Command::new("git")
        .args(["log", "--format=%H %s%n%b", "-20"])
        .current_dir(project_path)
        .stdout(std::process::Stdio::piped())
        .stderr(std::process::Stdio::null())
        .output()
    {
        Ok(o) => o,
        Err(_) => {
            return ComplianceCheck {
                name: "CB-1409: No L0 Autonomous Code".into(),
                status: CheckStatus::Skip,
                message: "Unable to read git log".into(),
                severity: Severity::Info,
            };
        }
    };

    let log_output = String::from_utf8_lossy(&output.stdout);
    if log_output.is_empty() {
        return ComplianceCheck {
            name: "CB-1409: No L0 Autonomous Code".into(),
            status: CheckStatus::Skip,
            message: "No git history found".into(),
            severity: Severity::Info,
        };
    }

    let mut ai_commits = 0usize;
    let mut ai_commits_with_contract = 0usize;
    let mut ai_commits_without_contract = Vec::new();

    // Collect existing work item IDs
    let work_dir = project_path.join(".pmat-work");
    let mut known_work_ids: Vec<String> = Vec::new();
    if work_dir.exists() {
        if let Ok(entries) = fs::read_dir(&work_dir) {
            for entry in entries.flatten() {
                if entry.path().is_dir() {
                    known_work_ids.push(entry.file_name().to_string_lossy().to_string());
                }
            }
        }
    }

    // Parse git log output — format is: <hash> <subject>\n<body>\n
    let mut current_subject = String::new();
    let mut current_body = String::new();
    let mut in_body = false;

    for line in log_output.lines() {
        // New commit starts with a 40-char hex hash
        if line.len() > 41 && line.chars().take(40).all(|c| c.is_ascii_hexdigit()) {
            // Process previous commit if it was AI-authored
            if !current_subject.is_empty() {
                process_commit_for_ai_check(
                    &current_subject,
                    &current_body,
                    &known_work_ids,
                    &mut ai_commits,
                    &mut ai_commits_with_contract,
                    &mut ai_commits_without_contract,
                );
            }
            current_subject = line[41..].to_string();
            current_body.clear();
            in_body = false;
        } else {
            if !in_body {
                in_body = true;
            }
            current_body.push_str(line);
            current_body.push('\n');
        }
    }
    // Process the last commit
    if !current_subject.is_empty() {
        process_commit_for_ai_check(
            &current_subject,
            &current_body,
            &known_work_ids,
            &mut ai_commits,
            &mut ai_commits_with_contract,
            &mut ai_commits_without_contract,
        );
    }

    if ai_commits == 0 {
        return ComplianceCheck {
            name: "CB-1409: No L0 Autonomous Code".into(),
            status: CheckStatus::Pass,
            message: "No AI-authored commits in recent history (last 20 commits)".into(),
            severity: Severity::Info,
        };
    }

    if ai_commits_without_contract.is_empty() {
        ComplianceCheck {
            name: "CB-1409: No L0 Autonomous Code".into(),
            status: CheckStatus::Pass,
            message: format!(
                "{}/{} AI-authored commit(s) have corresponding work contracts",
                ai_commits_with_contract, ai_commits
            ),
            severity: Severity::Info,
        }
    } else {
        let examples: Vec<&str> = ai_commits_without_contract
            .iter()
            .take(3)
            .map(|s| s.as_str())
            .collect();
        ComplianceCheck {
            name: "CB-1409: No L0 Autonomous Code".into(),
            status: CheckStatus::Warn,
            message: format!(
                "{}/{} AI-authored commit(s) lack work contracts: {}",
                ai_commits_without_contract.len(),
                ai_commits,
                examples.join("; ")
            ),
            severity: Severity::Warning,
        }
    }
}

/// Helper: check if a commit is AI-authored and has a work contract reference
fn process_commit_for_ai_check(
    subject: &str,
    body: &str,
    known_work_ids: &[String],
    ai_commits: &mut usize,
    ai_commits_with_contract: &mut usize,
    ai_commits_without_contract: &mut Vec<String>,
) {
    let full_text = format!("{}\n{}", subject, body);
    let is_ai = AI_COAUTHOR_PATTERNS
        .iter()
        .any(|p| full_text.to_lowercase().contains(&p.to_lowercase()));

    if !is_ai {
        return;
    }

    *ai_commits += 1;

    // Check if commit references a known work item
    let has_contract_ref = known_work_ids
        .iter()
        .any(|id| full_text.contains(id));

    // Also check for Refs PMAT-xxx pattern
    let has_refs = full_text.contains("Refs PMAT-")
        || full_text.contains("refs PMAT-")
        || full_text.contains("Contract:");

    if has_contract_ref || has_refs {
        *ai_commits_with_contract += 1;
    } else {
        let truncated = if subject.len() > 60 {
            // Safe truncation: find char boundary at or before byte 57
            let mut end = 57.min(subject.len());
            while end > 0 && !subject.is_char_boundary(end) {
                end -= 1;
            }
            format!("{}...", &subject[..end])
        } else {
            subject.to_string()
        };
        if ai_commits_without_contract.len() < 5 {
            ai_commits_without_contract.push(truncated);
        }
    }
}

/// CB-1410: Sub-Agent Contract Composition
///
/// Validates that iterative work contracts (iteration > 1) properly
/// reference their predecessor's postconditions. Checks that the
/// contract chain is continuous.
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "path_exists")]
pub(crate) fn check_subagent_contract_composition(project_path: &Path) -> ComplianceCheck {
    let work_dir = project_path.join(".pmat-work");
    if !work_dir.exists() {
        return ComplianceCheck {
            name: "CB-1410: Sub-Agent Composition".into(),
            status: CheckStatus::Skip,
            message: "No .pmat-work/ directory found".into(),
            severity: Severity::Info,
        };
    }

    let mut total_contracts = 0usize;
    let mut iterated_contracts = 0usize;

    // Check for contracts with iteration markers or receipt chains
    if let Ok(entries) = fs::read_dir(&work_dir) {
        for entry in entries.flatten() {
            let contract_path = entry.path().join("contract.json");
            if !contract_path.exists() {
                continue;
            }
            total_contracts += 1;

            // Check for falsification receipts (indicates contract was evaluated)
            let receipt_dir = entry.path().join("falsification");
            if receipt_dir.exists() {
                if let Ok(receipts) = fs::read_dir(&receipt_dir) {
                    let receipt_count = receipts.filter_map(|r| r.ok()).count();
                    if receipt_count > 1 {
                        iterated_contracts += 1;
                    }
                }
            }
        }
    }

    if total_contracts == 0 {
        return ComplianceCheck {
            name: "CB-1410: Sub-Agent Composition".into(),
            status: CheckStatus::Skip,
            message: "No work contracts found".into(),
            severity: Severity::Info,
        };
    }

    ComplianceCheck {
        name: "CB-1410: Sub-Agent Composition".into(),
        status: CheckStatus::Pass,
        message: format!(
            "{}/{} contract(s) have multi-iteration falsification chains",
            iterated_contracts, total_contracts
        ),
        severity: Severity::Info,
    }
}

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

    // --- CB-1409 tests ---

    #[test]
    fn test_cb1409_skip_no_git() {
        let tmp = tempfile::tempdir().expect("create tempdir");
        let result = check_no_l0_autonomous_code(tmp.path());
        // No git repo → skip or pass (depends on git availability)
        assert!(
            result.status == CheckStatus::Skip || result.status == CheckStatus::Pass,
            "Expected Skip or Pass, got {:?}",
            result.status
        );
    }


    // --- CB-1410 tests ---

    #[test]
    fn test_cb1410_skip_no_work_dir() {
        let tmp = tempfile::tempdir().expect("create tempdir");
        let result = check_subagent_contract_composition(tmp.path());
        assert_eq!(result.status, CheckStatus::Skip);
    }

    #[test]
    fn test_cb1410_pass_with_receipts() {
        let tmp = tempfile::tempdir().expect("create tempdir");
        let work_dir = tmp.path().join(".pmat-work").join("PMAT-008");
        let receipt_dir = work_dir.join("falsification");
        std::fs::create_dir_all(&receipt_dir).unwrap();
        std::fs::write(work_dir.join("contract.json"), r#"{"version": "5.0"}"#).unwrap();
        std::fs::write(receipt_dir.join("receipt-1.json"), "{}").unwrap();
        std::fs::write(receipt_dir.join("receipt-2.json"), "{}").unwrap();
        let result = check_subagent_contract_composition(tmp.path());
        assert_eq!(result.status, CheckStatus::Pass);
        assert!(result.message.contains("1/1"));
    }
}