devboy-mcp 0.27.0

MCP (Model Context Protocol) server for devboy-tools — JSON-RPC 2.0 over stdio, exposing every devboy provider as MCP tools to AI agents.
Documentation 
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

//! MCP tool definitions.

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Tool {
    pub name: String,
    pub description: String,
    pub parameters: serde_json::Value,
}

/// Available MCP tools.
pub fn available_tools() -> Vec<Tool> {
    vec![
        Tool {
            name: "get_issues".to_string(),
            description: "Get issues from configured git providers".to_string(),
            parameters: serde_json::json!({
                "type": "object",
                "properties": {
                    "state": {
                        "type": "string",
                        "enum": ["open", "closed", "all"],
                        "description": "Filter by issue state"
                    }
                }
            }),
        },
        Tool {
            name: "get_merge_requests".to_string(),
            description: "Get merge requests / pull requests from configured git providers"
                .to_string(),
            parameters: serde_json::json!({
                "type": "object",
                "properties": {
                    "state": {
                        "type": "string",
                        "enum": ["open", "closed", "merged", "all"],
                        "description": "Filter by MR/PR state"
                    }
                }
            }),
        },
    ]
}

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

    #[test]
    fn test_available_tools_not_empty() {
        let tools = available_tools();
        assert!(!tools.is_empty(), "should have at least one tool");
    }

    #[test]
    fn test_available_tools_contain_expected_names() {
        let tools = available_tools();
        let names: Vec<&str> = tools.iter().map(|t| t.name.as_str()).collect();
        assert!(names.contains(&"get_issues"), "missing get_issues tool");
        assert!(
            names.contains(&"get_merge_requests"),
            "missing get_merge_requests tool"
        );
    }

    #[test]
    fn test_available_tools_have_descriptions() {
        let tools = available_tools();
        for tool in &tools {
            assert!(
                !tool.description.is_empty(),
                "tool '{}' has empty description",
                tool.name
            );
        }
    }

    #[test]
    fn test_available_tools_have_valid_parameters() {
        let tools = available_tools();
        for tool in &tools {
            assert_eq!(
                tool.parameters["type"], "object",
                "tool '{}' parameters should be object type",
                tool.name
            );
            assert!(
                tool.parameters["properties"].is_object(),
                "tool '{}' should have properties object",
                tool.name
            );
        }
    }

    #[test]
    fn test_tool_serialization_roundtrip() {
        let tools = available_tools();
        let json = serde_json::to_string(&tools).unwrap();
        let parsed: Vec<Tool> = serde_json::from_str(&json).unwrap();
        assert_eq!(parsed.len(), tools.len());
        let parsed_names: Vec<&str> = parsed.iter().map(|t| t.name.as_str()).collect();
        for tool in &tools {
            assert!(parsed_names.contains(&tool.name.as_str()));
        }
    }
}