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

#![cfg_attr(coverage_nightly, coverage(off))]
//! Execution mode, refactor mode, demo protocol, and WASM-related enums

use clap::ValueEnum;
use std::fmt;

/// Execution mode for the CLI
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ExecutionMode {
    Cli,
    Mcp,
}

impl fmt::Display for ExecutionMode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ExecutionMode::Cli => write!(f, "cli"),
            ExecutionMode::Mcp => write!(f, "mcp"),
        }
    }
}

/// Refactor mode
#[derive(Clone, Debug, ValueEnum, PartialEq)]
pub enum RefactorMode {
    Batch,
    Interactive,
}

impl fmt::Display for RefactorMode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            RefactorMode::Batch => write!(f, "batch"),
            RefactorMode::Interactive => write!(f, "interactive"),
        }
    }
}

/// Demo protocol selection
#[derive(Clone, Debug, ValueEnum, PartialEq)]
pub enum DemoProtocol {
    Cli,
    Http,
    Mcp,
    #[cfg(feature = "tui")]
    Tui,
    All,
}

impl fmt::Display for DemoProtocol {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DemoProtocol::Cli => write!(f, "cli"),
            DemoProtocol::Http => write!(f, "http"),
            DemoProtocol::Mcp => write!(f, "mcp"),
            #[cfg(feature = "tui")]
            DemoProtocol::Tui => write!(f, "tui"),
            DemoProtocol::All => write!(f, "all"),
        }
    }
}

/// Output format for WASM analysis
#[derive(Clone, Debug, ValueEnum, PartialEq)]
pub enum WasmOutputFormat {
    /// Summary output with key metrics
    Summary,
    /// Detailed analysis with all components
    Detailed,
    /// JSON format for programmatic use
    Json,
    /// SARIF format for security results
    Sarif,
}

impl fmt::Display for WasmOutputFormat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            WasmOutputFormat::Summary => write!(f, "summary"),
            WasmOutputFormat::Detailed => write!(f, "detailed"),
            WasmOutputFormat::Json => write!(f, "json"),
            WasmOutputFormat::Sarif => write!(f, "sarif"),
        }
    }
}

/// Deep WASM source language
#[derive(Clone, Debug, ValueEnum, PartialEq)]
pub enum DeepWasmLanguage {
    /// Rust language
    Rust,
    /// Ruchy language
    Ruchy,
}

impl fmt::Display for DeepWasmLanguage {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DeepWasmLanguage::Rust => write!(f, "rust"),
            DeepWasmLanguage::Ruchy => write!(f, "ruchy"),
        }
    }
}

/// Deep WASM analysis focus
#[derive(Clone, Debug, ValueEnum, PartialEq)]
pub enum DeepWasmFocus {
    /// Full pipeline analysis
    Full,
    /// Source code only
    Source,
    /// Compilation pipeline
    Compilation,
    /// Runtime behavior
    Runtime,
    /// JavaScript interop
    Interop,
}

impl fmt::Display for DeepWasmFocus {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DeepWasmFocus::Full => write!(f, "full"),
            DeepWasmFocus::Source => write!(f, "source"),
            DeepWasmFocus::Compilation => write!(f, "compilation"),
            DeepWasmFocus::Runtime => write!(f, "runtime"),
            DeepWasmFocus::Interop => write!(f, "interop"),
        }
    }
}

/// Deep WASM output format
#[derive(Clone, Debug, ValueEnum, PartialEq)]
pub enum DeepWasmOutputFormat {
    /// Markdown report
    Markdown,
    /// JSON data
    Json,
    /// HTML report
    Html,
}

impl fmt::Display for DeepWasmOutputFormat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DeepWasmOutputFormat::Markdown => write!(f, "markdown"),
            DeepWasmOutputFormat::Json => write!(f, "json"),
            DeepWasmOutputFormat::Html => write!(f, "html"),
        }
    }
}