prometheus-mcp 0.0.1

use crate::mcp::types::*;
use crate::mcp::{PROTOCOL_VERSION, SERVER_NAME, SERVER_VERSION};
use rpc_router::HandlerResult;
use serde_json::json;

/// handler for `initialize` request from client
pub async fn initialize(_request: InitializeRequest) -> HandlerResult<InitializeResult> {
    let result = InitializeResult {
        protocol_version: PROTOCOL_VERSION.to_string(),
        server_info: Implementation {
            name: SERVER_NAME.to_string(),
            version: SERVER_VERSION.to_string(),
        },
        capabilities: ServerCapabilities {
            experimental: None,
            prompts: None,
            resources: None,
            tools: Some(json!({})),
            roots: None,
            sampling: None,
            logging: None,
        },
        instructions: None,
    };
    Ok(result)
}

/// handler for SIGINT by client
pub fn graceful_shutdown() {
    // shutdown server
}

/// handler for `notifications/initialized` from client
pub fn notifications_initialized() {}

/// handler for `notifications/cancelled` from client
pub fn notifications_cancelled(_params: CancelledNotification) {
    // cancel request
}

pub async fn ping(_request: PingRequest) -> HandlerResult<EmptyResult> {
    Ok(EmptyResult {})
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_initialize() {
        let req = InitializeRequest {
            protocol_version: "1.0".into(),
            capabilities: ClientCapabilities::default(),
            client_info: Implementation {
                name: "test".into(),
                version: "0".into(),
            },
        };
        let res = super::initialize(req).await.unwrap();
        assert_eq!(res.server_info.name, crate::mcp::SERVER_NAME);
    }
}