pmat 3.17.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

//! Example: MCP Server using pmcp SDK
//!
//! This example demonstrates how to run the pmat MCP server using the pmcp Rust SDK.
//! The pmcp SDK provides a more idiomatic Rust interface for implementing MCP servers
//! with proper type safety and async support.
//!
//! Note: This example requires the pmcp crate and full MCP integration.
//! Currently serves as a reference implementation.
//!
//! # Usage
//!
//! ```bash
//! cargo run --example mcp_server_pmcp
//! ```
//!
//! Then connect with an MCP client:
//! ```bash
//! # Using npx
//! npx @modelcontextprotocol/inspector tcp://127.0.0.1:3000
//!
//! # Or use any MCP-compatible client
//! ```

use anyhow::Result;
use std::collections::HashMap;
use tracing::{info, Level};
use tracing_subscriber::FmtSubscriber;

#[tokio::main]
async fn main() -> Result<()> {
    // Initialize logging
    let subscriber = FmtSubscriber::builder()
        .with_max_level(Level::INFO)
        .finish();
    tracing::subscriber::set_global_default(subscriber)?;

    info!("MCP Server with pmcp SDK - Reference Implementation");
    info!("This example demonstrates the intended pmcp integration architecture");

    // For now, show the conceptual server setup
    let tools = create_tool_registry();
    info!("Would register {} MCP tools", tools.len());

    // Simulate server binding
    info!("Would bind to tcp://127.0.0.1:3000");
    info!("Would accept MCP client connections");
    info!("Connect with: npx @modelcontextprotocol/inspector tcp://127.0.0.1:3000");

    // Show tool list
    println!("\nAvailable MCP Tools:");
    for (name, description) in &tools {
        println!("  • {} - {}", name, description);
    }

    println!("\nNote: Full pmcp integration pending. This demonstrates the intended architecture.");
    println!("See docs/features/mcp-protocol.md for current MCP server usage:");
    println!("  pmat --mode mcp");

    Ok(())
}

/// Creates a registry of all pmat MCP tools
fn create_tool_registry() -> HashMap<String, String> {
    let mut tools = HashMap::new();

    // Analysis tools
    tools.insert(
        "analyze_complexity".to_string(),
        "Analyze code complexity metrics".to_string(),
    );
    tools.insert(
        "analyze_satd".to_string(),
        "Detect self-admitted technical debt".to_string(),
    );
    tools.insert(
        "analyze_dead_code".to_string(),
        "Find potentially dead code".to_string(),
    );
    tools.insert(
        "analyze_lint_hotspot".to_string(),
        "Find files with most lint violations".to_string(),
    );
    tools.insert(
        "analyze_duplicates".to_string(),
        "Detect duplicate code blocks".to_string(),
    );

    // Quality gate tools
    tools.insert(
        "quality_gate".to_string(),
        "Run comprehensive quality checks".to_string(),
    );
    tools.insert(
        "quality_gate_file".to_string(),
        "Run quality checks on specific file".to_string(),
    );

    // Refactoring tools
    tools.insert(
        "refactor_start".to_string(),
        "Start an automated refactoring session".to_string(),
    );
    tools.insert(
        "refactor_next_iteration".to_string(),
        "Continue refactoring iteration".to_string(),
    );
    tools.insert(
        "refactor_get_state".to_string(),
        "Get current refactoring state".to_string(),
    );
    tools.insert(
        "refactor_stop".to_string(),
        "Stop refactoring session".to_string(),
    );

    // Context analysis
    tools.insert(
        "deep_context".to_string(),
        "Perform deep context analysis".to_string(),
    );
    tools.insert(
        "generate_context".to_string(),
        "Generate project context".to_string(),
    );

    // Visualization
    tools.insert(
        "generate_dag".to_string(),
        "Generate dependency graph visualization".to_string(),
    );

    tools
}