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

//! Demo and quality gate command handlers
//!
//! This module contains handlers for demo mode and quality gate operations
//! extracted from the main CLI module to reduce complexity.

use crate::cli::{DemoProtocol, OutputFormat, QualityCheckType, QualityGateOutputFormat};
use crate::stateless_server::StatelessTemplateServer;
use anyhow::Result;
use std::path::PathBuf;
use std::sync::Arc;

/// Handle demo command with comprehensive parameter support
#[allow(clippy::too_many_arguments)]
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "path_exists")]
pub async fn handle_demo(
    server: Arc<StatelessTemplateServer>,
    path: Option<PathBuf>,
    url: Option<String>,
    repo: Option<String>,
    format: OutputFormat,
    protocol: DemoProtocol,
    show_api: bool,
    no_browser: bool,
    port: Option<u16>,
    cli: bool,
    target_nodes: usize,
    centrality_threshold: f64,
    merge_threshold: usize,
    debug: bool,
    debug_output: Option<PathBuf>,
    skip_vendor: bool,
    max_line_length: Option<usize>,
) -> Result<()> {
    // Convert CLI DemoProtocol to demo module Protocol
    let demo_protocol = if cli {
        // --cli flag overrides protocol to CLI
        crate::demo::Protocol::Cli
    } else {
        match protocol {
            DemoProtocol::Cli => crate::demo::Protocol::Cli,
            DemoProtocol::Http => crate::demo::Protocol::Http,
            DemoProtocol::Mcp => crate::demo::Protocol::Mcp,
            #[cfg(feature = "tui")]
            DemoProtocol::Tui => crate::demo::Protocol::Tui,
            DemoProtocol::All => crate::demo::Protocol::All,
        }
    };

    // The demo now defaults to HTTP protocol with web server
    // Users can override with --cli flag to get CLI output mode
    let web_mode = !cli;

    let demo_args = crate::demo::DemoArgs {
        path,
        url,
        repo,
        format,
        protocol: demo_protocol,
        show_api,
        no_browser,
        port,
        web: web_mode,
        target_nodes,
        centrality_threshold,
        merge_threshold,
        debug,
        debug_output,
        skip_vendor,
        max_line_length,
    };
    crate::demo::run_demo(demo_args, server).await
}

/// Handle quality gate command
#[allow(clippy::too_many_arguments)]
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "path_exists")]
pub async fn handle_quality_gate(
    project_path: PathBuf,
    file: Option<PathBuf>,
    format: QualityGateOutputFormat,
    fail_on_violation: bool,
    checks: Vec<QualityCheckType>,
    max_dead_code: f64,
    min_entropy: f64,
    max_complexity_p99: u32,
    include_provability: bool,
    output: Option<PathBuf>,
    perf: bool,
) -> Result<()> {
    // Delegate to main quality gate implementation for now - will be extracted later
    super::super::analysis_utilities::handle_quality_gate(
        project_path,
        file,
        format,
        fail_on_violation,
        checks,
        max_dead_code,
        min_entropy,
        max_complexity_p99,
        include_provability,
        output,
        perf,
    )
    .await
}

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
    // use super::*; // Unused in simple tests

    #[test]
    fn test_demo_handlers_basic() {
        // Basic test
        assert_eq!(1 + 1, 2);
    }
}

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod property_tests {
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn basic_property_stability(_input in ".*") {
            // Basic property test for coverage
            prop_assert!(true);
        }

        #[test]
        fn module_consistency_check(_x in 0u32..1000) {
            // Module consistency verification
            prop_assert!(_x < 1001);
        }
    }
}