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

/// MCP Adapter implementation
pub struct McpAdapter;

#[async_trait]
impl ProtocolAdapter for McpAdapter {
    type Request = JsonRpcRequest;
    type Response = JsonRpcResponse;

    fn decode(&self, raw: &[u8]) -> Result<UnifiedRequest, ProtocolError> {
        let json_rpc: JsonRpcRequest = serde_json::from_slice(raw)?;

        // Map JSON-RPC method to Operation
        let method = json_rpc.method.clone();
        let params = json_rpc.params.clone();
        let operation = match method.as_str() {
            "analyze_complexity" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::AnalyzeComplexity(p)
            }
            "analyze_satd" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::AnalyzeSatd(p)
            }
            "analyze_dead_code" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::AnalyzeDeadCode(p)
            }
            "generate_context" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::GenerateContext(p)
            }
            "quality_gate" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::QualityGate(p)
            }
            "quality_proxy" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::QualityProxy(p)
            }
            "refactor_start" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::RefactorStart(p)
            }
            "refactor_next" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::RefactorNext(p)
            }
            "refactor_stop" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::RefactorStop(p)
            }
            "scaffold_project" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::ScaffoldProject(p)
            }
            "scaffold_agent" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::ScaffoldAgent(p)
            }
            "pdmt_todos" => {
                let p = serde_json::from_value(params.clone())?;
                Operation::PdmtTodos(p)
            }
            _ => return Err(ProtocolError::UnknownMethod(method)),
        };

        Ok(UnifiedRequest {
            operation,
            params,
            context: RequestContext::from_json_rpc(&json_rpc),
        })
    }

    fn encode(&self, response: UnifiedResponse) -> Result<Vec<u8>, ProtocolError> {
        let json_rpc = JsonRpcResponse {
            jsonrpc: "2.0".to_string(),
            result: response.result,
            error: response.error.map(Into::into),
            id: response.metadata.request_id.into(),
        };

        Ok(serde_json::to_vec(&json_rpc)?)
    }

    async fn handle(&self, request: Self::Request) -> Self::Response {
        // This would be implemented to process the request
        // For now, return a placeholder response
        JsonRpcResponse {
            jsonrpc: "2.0".to_string(),
            result: Some(serde_json::json!({"status": "ok"})),
            error: None,
            id: request.id,
        }
    }
}