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
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

// TDG core analysis - single file, multiple files, and project analysis

/// Analyze a single file and return formatted output
#[allow(clippy::too_many_arguments)]
async fn analyze_single_file(
    calculator: &crate::services::tdg_calculator::TDGCalculator,
    project_path: &Path,
    file: PathBuf,
    threshold: f64,
    format: TdgOutputFormat,
    include_components: bool,
    critical_only: bool,
    verbose: bool,
) -> Result<String> {
    eprintln!("📄 Analyzing TDG for file: {}", file.display());

    // Resolve path
    let full_path = if file.is_absolute() {
        file
    } else {
        project_path.join(&file)
    };

    if !full_path.exists() {
        anyhow::bail!("File not found: {}", full_path.display());
    }

    // Analyze file
    let score = calculator.calculate_file(&full_path).await?;

    // Check if it meets criteria
    if critical_only && score.value <= 2.5 {
        return Ok(format_empty_results(format));
    }
    if score.value < threshold {
        return Ok(format_empty_results(format));
    }

    // Format single file results
    format_tdg_single_file_output(&score, &full_path, format, include_components, verbose)
}

/// Analyze multiple files and return formatted output
#[allow(clippy::too_many_arguments)]
async fn analyze_multiple_files(
    calculator: &crate::services::tdg_calculator::TDGCalculator,
    project_path: &Path,
    files: Vec<PathBuf>,
    threshold: f64,
    top_files: usize,
    format: TdgOutputFormat,
    include_components: bool,
    critical_only: bool,
    verbose: bool,
) -> Result<String> {
    eprintln!("📄 Analyzing TDG for {} files...", files.len());

    let results =
        process_files_for_tdg(calculator, project_path, files, threshold, critical_only).await;

    let filtered_results = apply_results_filtering(results, top_files);
    let summary = create_summary_from_file_results(&filtered_results);

    format_output_from_summary(&summary, format, include_components, verbose)
}

/// Process multiple files for TDG analysis
async fn process_files_for_tdg(
    calculator: &crate::services::tdg_calculator::TDGCalculator,
    project_path: &Path,
    files: Vec<PathBuf>,
    threshold: f64,
    critical_only: bool,
) -> Vec<(crate::models::tdg::TDGScore, PathBuf)> {
    let mut results = Vec::new();

    for file_path in files {
        let full_path = resolve_file_path(project_path, file_path);

        if !full_path.exists() {
            eprintln!("⚠️  Skipping missing file: {}", full_path.display());
            continue;
        }

        if let Some(score) =
            calculate_and_filter_file(calculator, &full_path, threshold, critical_only).await
        {
            results.push((score, full_path));
        }
    }

    results
}

/// Calculate TDG score for file and apply filters
async fn calculate_and_filter_file(
    calculator: &crate::services::tdg_calculator::TDGCalculator,
    full_path: &Path,
    threshold: f64,
    critical_only: bool,
) -> Option<crate::models::tdg::TDGScore> {
    match calculator.calculate_file(full_path).await {
        Ok(score) => {
            if should_include_score(&score, threshold, critical_only) {
                Some(score)
            } else {
                None
            }
        }
        Err(e) => {
            eprintln!("⚠️  Error analyzing {}: {}", full_path.display(), e);
            None
        }
    }
}

/// Analyze entire project and return formatted output
#[allow(clippy::too_many_arguments)]
async fn analyze_project(
    calculator: &crate::services::tdg_calculator::TDGCalculator,
    project_path: &Path,
    _include: Vec<String>,
    threshold: f64,
    top_files: usize,
    format: TdgOutputFormat,
    include_components: bool,
    critical_only: bool,
    verbose: bool,
) -> Result<String> {
    eprintln!("📁 Project path: {}", project_path.display());

    // Analyze directory
    let mut summary = calculator.analyze_directory(project_path).await?;

    // Filter hotspots based on criteria
    summary.hotspots = summary
        .hotspots
        .into_iter()
        .filter(|h| {
            if critical_only {
                h.tdg_score > 2.5
            } else {
                h.tdg_score >= threshold
            }
        })
        .take(if top_files > 0 { top_files } else { usize::MAX })
        .collect();

    // Format output
    format_output_from_summary(&summary, format, include_components, verbose)
}