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

// TDG handler - main entry point and orchestration

#[allow(clippy::too_many_arguments)]
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "path_exists")]
pub async fn handle_analyze_tdg(
    path: PathBuf,
    file: Option<PathBuf>,
    files: Vec<PathBuf>,
    threshold: f64,
    top: usize,
    format: TdgOutputFormat,
    _include_components: bool,
    output: Option<PathBuf>,
    _critical_only: bool,
    _verbose: bool,
    include: Vec<String>,
    watch: bool,
) -> Result<()> {
    use crate::services::tdg_calculator::TDGCalculator;

    if watch {
        #[cfg(feature = "watch")]
        {
            return run_tdg_watch_mode(
                path,
                threshold,
                top,
                format,
                _include_components,
                output,
                _critical_only,
                _verbose,
            )
            .await;
        }
        #[cfg(not(feature = "watch"))]
        {
            anyhow::bail!("Watch mode requires the 'watch' feature. Rebuild with: cargo build --features watch");
        }
    }

    eprintln!("🔍 Analyzing Technical Debt Gradient...");

    // Create TDG calculator
    let calculator = TDGCalculator::new();

    // Determine analysis mode and generate output
    let output_content = run_tdg_analysis(
        &calculator,
        &path,
        file,
        files,
        include,
        threshold,
        top,
        format,
        _include_components,
        _critical_only,
        _verbose,
    )
    .await?;

    // Output results
    write_tdg_output(output, &output_content).await?;

    eprintln!("✅ TDG analysis complete");
    Ok(())
}

/// Run the appropriate TDG analysis based on input mode
#[allow(clippy::too_many_arguments)]
async fn run_tdg_analysis(
    calculator: &crate::services::tdg_calculator::TDGCalculator,
    path: &Path,
    file: Option<PathBuf>,
    files: Vec<PathBuf>,
    include: Vec<String>,
    threshold: f64,
    top: usize,
    format: TdgOutputFormat,
    include_components: bool,
    critical_only: bool,
    verbose: bool,
) -> Result<String> {
    if let Some(single_file) = file {
        // Single file mode
        analyze_single_file(
            calculator,
            path,
            single_file,
            threshold,
            format,
            include_components,
            critical_only,
            verbose,
        )
        .await
    } else if !files.is_empty() {
        // Multiple files mode (MCP tool composition)
        analyze_multiple_files(
            calculator,
            path,
            files,
            threshold,
            top,
            format,
            include_components,
            critical_only,
            verbose,
        )
        .await
    } else {
        // Project mode
        analyze_project(
            calculator,
            path,
            include,
            threshold,
            top,
            format,
            include_components,
            critical_only,
            verbose,
        )
        .await
    }
}

/// Write TDG output to file or stdout
async fn write_tdg_output(output: Option<PathBuf>, content: &str) -> Result<()> {
    if let Some(output_path) = output {
        tokio::fs::write(&output_path, content).await?;
        eprintln!("📝 Results written to {}", output_path.display());
    } else {
        println!("{content}");
    }
    Ok(())
}