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

/// Handle `pmat oracle fix` - Run PDCA fix loop
async fn handle_oracle_fix(
    path: &Path,
    max_iterations: usize,
    auto_apply_threshold: f32,
    review_threshold: f32,
    dry_run: bool,
    format: OracleOutputFormat,
    output: Option<&Path>,
) -> Result<()> {
    println!("🔮 PMAT Oracle - PDCA Quality Improvement Loop");
    println!("   Path: {}", path.display());
    println!("   Max iterations: {}", max_iterations);
    println!(
        "   Thresholds: auto={:.2}, review={:.2}",
        auto_apply_threshold, review_threshold
    );
    if dry_run {
        println!("   Mode: DRY RUN (no changes will be applied)");
    }
    println!();

    // Validate path
    if !path.exists() {
        anyhow::bail!("Project path does not exist: {}", path.display());
    }

    // Create config
    let config = OracleConfig {
        max_iterations,
        auto_apply_threshold,
        review_threshold,
        ..Default::default()
    };
    let targets = ConvergenceTargets::default();

    // Create and run PDCA loop
    let pdca = PdcaLoop::with_config(config, targets.clone());

    if dry_run {
        println!("🔍 Dry run: Collecting signals only...\n");
        // Just run one iteration without applying fixes
        let results = pdca.run_iterations(path, 1).await?;
        if let Some(result) = results.first() {
            format_iteration_result(result, &format, output)?;
        }
    } else {
        println!("🚀 Starting PDCA loop...\n");
        let results = pdca.run(path).await?;

        // Format and output results
        let formatted = format_pdca_results(&results, &targets, format)?;

        if let Some(output_path) = output {
            std::fs::write(output_path, &formatted)?;
            println!("✅ Results written to: {}", output_path.display());
        } else {
            println!("{}", formatted);
        }
    }

    Ok(())
}

/// Handle `pmat oracle status` - Show current quality status
async fn handle_oracle_status(path: &Path, format: OracleOutputFormat) -> Result<()> {
    println!("📊 PMAT Oracle - Project Quality Status");
    println!("   Path: {}", path.display());
    println!();

    // Validate path
    if !path.exists() {
        anyhow::bail!("Project path does not exist: {}", path.display());
    }

    let targets = ConvergenceTargets::default();

    // Collect current metrics (simplified for now - would integrate with actual PMAT commands)
    let metrics = collect_project_metrics(path).await?;
    let status = targets.check(&metrics);

    let formatted = format_status(&metrics, &targets, &status, format)?;
    println!("{}", formatted);

    Ok(())
}

/// Handle `pmat oracle single` - Run single PDCA iteration
async fn handle_oracle_single(
    path: &Path,
    format: OracleOutputFormat,
    output: Option<&Path>,
) -> Result<()> {
    println!("⚡ PMAT Oracle - Single PDCA Iteration");
    println!("   Path: {}", path.display());
    println!();

    // Validate path
    if !path.exists() {
        anyhow::bail!("Project path does not exist: {}", path.display());
    }

    let pdca = PdcaLoop::new();
    let result = pdca.run_single(path).await?;

    let formatted = format_single_result(&result, format)?;

    if let Some(output_path) = output {
        std::fs::write(output_path, &formatted)?;
        println!("✅ Results written to: {}", output_path.display());
    } else {
        println!("{}", formatted);
    }

    Ok(())
}

/// Collect project metrics (simplified implementation)
///
/// Returns default metrics. Full implementation would run:
/// - `pmat tdg` for TDG score
/// - `pmat analyze complexity` for cyclomatic/cognitive complexity
/// - `pmat analyze satd` for SATD markers
/// - `pmat analyze dead-code` for dead code items
/// - `cargo test` for test coverage/failures
///
/// Oracle-driven convergence uses these metrics to guide iterative improvements.
async fn collect_project_metrics(_path: &Path) -> Result<ProjectMetrics> {
    // Stub implementation - full metrics collection would be expensive
    // and is meant for CI/CD pipelines, not interactive use.
    Ok(ProjectMetrics::default())
}