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

// TDG helper functions - percentile, primary factor, refactoring estimates, filtering

/// Calculate percentile value from sorted array
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
pub fn percentile(sorted_values: &[f64], p: f64) -> f64 {
    if sorted_values.is_empty() {
        return 0.0;
    }

    let index = (sorted_values.len() as f64 * p) as usize;
    let index = index.min(sorted_values.len() - 1);
    sorted_values[index]
}

/// Identify the primary contributing factor from TDG components
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
pub fn identify_primary_factor(components: &crate::models::tdg::TDGComponents) -> String {
    let mut factors = [
        (components.complexity * 0.30, "High Complexity"),
        (components.churn * 0.35, "Frequent Changes"),
        (components.coupling * 0.15, "High Coupling"),
        (components.domain_risk * 0.10, "Domain Risk"),
        (components.duplication * 0.10, "Code Duplication"),
    ];

    factors.sort_unstable_by(|a, b| {
        b.0.partial_cmp(&a.0)
            .unwrap_or(std::cmp::Ordering::Equal)
    });
    factors[0].1.to_string()
}

/// Estimate refactoring hours based on TDG score
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
pub fn estimate_refactoring_hours(tdg_score: f64) -> f64 {
    // Empirical formula: hours = base * multiplier^tdg
    let base_hours = 2.0;
    let multiplier: f64 = 1.8;
    base_hours * multiplier.powf(tdg_score)
}

/// Resolve file path relative to project directory
fn resolve_file_path(project_path: &Path, file_path: PathBuf) -> PathBuf {
    if file_path.is_absolute() {
        file_path
    } else {
        project_path.join(&file_path)
    }
}

/// Check if score should be included based on filters
fn should_include_score(
    score: &crate::models::tdg::TDGScore,
    threshold: f64,
    critical_only: bool,
) -> bool {
    if critical_only && score.value <= 2.5 {
        return false;
    }
    if score.value < threshold {
        return false;
    }
    true
}

/// Apply sorting and `top_files` limit to results
fn apply_results_filtering(
    mut results: Vec<(crate::models::tdg::TDGScore, PathBuf)>,
    top_files: usize,
) -> Vec<(crate::models::tdg::TDGScore, PathBuf)> {
    // Sort by TDG score descending
    results.sort_unstable_by(|a, b| {
        b.0.value
            .partial_cmp(&a.0.value)
            .unwrap_or(std::cmp::Ordering::Equal)
    });

    // Apply top_files limit
    if top_files > 0 && results.len() > top_files {
        results.truncate(top_files);
    }

    results
}

/// Create a summary from individual file results
fn create_summary_from_file_results(
    results: &[(crate::models::tdg::TDGScore, PathBuf)],
) -> crate::models::tdg::TDGSummary {
    use crate::models::tdg::{TDGHotspot, TDGSeverity, TDGSummary};

    let total_files = results.len();
    let critical_files = results
        .iter()
        .filter(|(s, _)| matches!(s.severity, TDGSeverity::Critical))
        .count();
    let warning_files = results
        .iter()
        .filter(|(s, _)| matches!(s.severity, TDGSeverity::Warning))
        .count();

    let tdg_values: Vec<f64> = results.iter().map(|(s, _)| s.value).collect();
    let average_tdg = if tdg_values.is_empty() {
        0.0
    } else {
        tdg_values.iter().sum::<f64>() / tdg_values.len() as f64
    };

    // Calculate percentiles
    let mut sorted_values = tdg_values;
    sorted_values.sort_unstable_by(|a, b| {
        a.partial_cmp(b)
            .unwrap_or(std::cmp::Ordering::Equal)
    });

    let p95_tdg = percentile(&sorted_values, 0.95);
    let p99_tdg = percentile(&sorted_values, 0.99);

    // Create hotspots
    let hotspots = results
        .iter()
        .map(|(score, path)| TDGHotspot {
            path: path.display().to_string(),
            tdg_score: score.value,
            primary_factor: identify_primary_factor(&score.components),
            estimated_hours: estimate_refactoring_hours(score.value),
        })
        .collect();

    let estimated_debt_hours = results
        .iter()
        .map(|(s, _)| estimate_refactoring_hours(s.value))
        .sum();

    TDGSummary {
        total_files,
        critical_files,
        warning_files,
        average_tdg,
        p95_tdg,
        p99_tdg,
        estimated_debt_hours,
        hotspots,
    }
}