bevy_debugger_mcp 0.1.8

AI-assisted debugging for Bevy games through Claude Code using Model Context Protocol
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use async_trait::async_trait;
use serde_json::Value;
use std::sync::Arc;
use tokio::sync::RwLock;

use crate::brp_client::BrpClient;
use crate::error::Result;
use crate::tool_orchestration::{ToolContext, ToolExecutor};

/// Tool executor for the observe tool
pub struct ObserveExecutor;

#[async_trait]
impl ToolExecutor for ObserveExecutor {
    async fn execute(
        &self,
        arguments: Value,
        brp_client: Arc<RwLock<BrpClient>>,
        _context: &mut ToolContext,
    ) -> Result<Value> {
        crate::tools::observe::handle(arguments, brp_client).await
    }
}

/// Tool executor for the experiment tool
pub struct ExperimentExecutor;

#[async_trait]
impl ToolExecutor for ExperimentExecutor {
    async fn execute(
        &self,
        arguments: Value,
        brp_client: Arc<RwLock<BrpClient>>,
        _context: &mut ToolContext,
    ) -> Result<Value> {
        crate::tools::experiment::handle(arguments, brp_client).await
    }
}

/// Tool executor for the hypothesis tool
pub struct HypothesisExecutor;

#[async_trait]
impl ToolExecutor for HypothesisExecutor {
    async fn execute(
        &self,
        arguments: Value,
        brp_client: Arc<RwLock<BrpClient>>,
        _context: &mut ToolContext,
    ) -> Result<Value> {
        crate::tools::hypothesis::handle(arguments, brp_client).await
    }
}

/// Tool executor for the stress tool
pub struct StressExecutor;

#[async_trait]
impl ToolExecutor for StressExecutor {
    async fn execute(
        &self,
        arguments: Value,
        brp_client: Arc<RwLock<BrpClient>>,
        _context: &mut ToolContext,
    ) -> Result<Value> {
        crate::tools::stress::handle(arguments, brp_client).await
    }
}

/// Tool executor for the replay tool
pub struct ReplayExecutor;

#[async_trait]
impl ToolExecutor for ReplayExecutor {
    async fn execute(
        &self,
        arguments: Value,
        brp_client: Arc<RwLock<BrpClient>>,
        _context: &mut ToolContext,
    ) -> Result<Value> {
        crate::tools::replay::handle(arguments, brp_client).await
    }
}

/// Tool executor for the anomaly tool
pub struct AnomalyExecutor;

#[async_trait]
impl ToolExecutor for AnomalyExecutor {
    async fn execute(
        &self,
        arguments: Value,
        brp_client: Arc<RwLock<BrpClient>>,
        _context: &mut ToolContext,
    ) -> Result<Value> {
        crate::tools::anomaly::handle(arguments, brp_client).await
    }
}

/// Create and configure a tool orchestrator with all available tools
pub fn create_orchestrator(
    brp_client: Arc<RwLock<BrpClient>>,
) -> crate::tool_orchestration::ToolOrchestrator {
    let mut orchestrator = crate::tool_orchestration::ToolOrchestrator::new(brp_client);

    // Register all tool executors
    orchestrator.register_tool("observe".to_string(), Arc::new(ObserveExecutor));
    orchestrator.register_tool("experiment".to_string(), Arc::new(ExperimentExecutor));
    orchestrator.register_tool("hypothesis".to_string(), Arc::new(HypothesisExecutor));
    orchestrator.register_tool("stress".to_string(), Arc::new(StressExecutor));
    orchestrator.register_tool("replay".to_string(), Arc::new(ReplayExecutor));
    orchestrator.register_tool("anomaly".to_string(), Arc::new(AnomalyExecutor));

    // Register common pipeline templates
    orchestrator.register_pipeline_template(
        crate::tool_orchestration::WorkflowDSL::observe_experiment_replay(),
    );
    orchestrator
        .register_pipeline_template(crate::tool_orchestration::WorkflowDSL::debug_performance());

    orchestrator
}