pmat 3.11.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

#![cfg_attr(coverage_nightly, coverage(off))]
//! Quality gate executor for TICKET-PMAT-5020
//!
//! Executes quality checks and generates reports.

use serde::{Deserialize, Serialize};
use std::path::Path;
use std::process::Command;
use std::time::Duration;

/// Quality gate execution result
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GateResult {
    /// Gate name
    pub name: String,
    /// Whether gate passed
    pub passed: bool,
    /// Execution time
    #[serde(with = "serde_millis")]
    pub duration: Duration,
    /// Output/error message
    pub message: String,
}

mod serde_millis {
    use serde::{Deserialize, Deserializer, Serialize, Serializer};
    use std::time::Duration;

    pub(super) fn serialize<S>(duration: &Duration, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        duration.as_millis().serialize(serializer)
    }

    pub(super) fn deserialize<'de, D>(deserializer: D) -> Result<Duration, D::Error>
    where
        D: Deserializer<'de>,
    {
        let millis = u64::deserialize(deserializer)?;
        Ok(Duration::from_millis(millis))
    }
}

/// Overall quality gate report
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QualityReport {
    /// Individual gate results
    pub gates: Vec<GateResult>,
    /// Overall pass/fail
    pub passed: bool,
    /// Total execution time
    #[serde(with = "serde_millis")]
    pub total_duration: Duration,
    /// Timestamp
    pub timestamp: String,
}

/// Quality gate configuration
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct GateConfig {
    /// Run clippy
    pub run_clippy: bool,
    /// Clippy severity (-D warnings)
    pub clippy_strict: bool,
    /// Run tests
    pub run_tests: bool,
    /// Test timeout (seconds)
    pub test_timeout: u64,
    /// Check coverage
    pub check_coverage: bool,
    /// Minimum coverage percentage
    pub min_coverage: f64,
    /// Check complexity
    pub check_complexity: bool,
    /// Maximum cyclomatic complexity
    pub max_complexity: u32,
}

impl Default for GateConfig {
    fn default() -> Self {
        Self {
            run_clippy: true,
            clippy_strict: true,
            run_tests: true,
            test_timeout: 300,
            check_coverage: true,
            min_coverage: 80.0,
            check_complexity: true,
            max_complexity: 10,
        }
    }
}

/// Quality gate errors
#[derive(Debug, thiserror::Error)]
pub enum GateError {
    #[error("Command execution failed: {0}")]
    CommandFailed(String),

    #[error("Timeout exceeded: {0}s")]
    Timeout(u64),

    #[error("I/O error: {0}")]
    IoError(#[from] std::io::Error),
}

pub type Result<T> = std::result::Result<T, GateError>;

// Individual gate check implementations (clippy, tests, coverage, complexity)
include!("gates_checks.rs");

// Gate orchestration (execute_all_gates) and report formatting (format_report)
include!("gates_runner.rs");

// Unit and integration tests
include!("gates_tests.rs");