gavindiaz/mt5-quant
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: Remove .windsurf from git tracking (already in .gitignore)

Browse Source
This commit is contained in:
Devid HW
2026-04-19 04:55:21 +07:00
parent 27261db5d0
commit a3705f2aca
1 changed files with 0 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.windsurf/workflows/create-mcp-tool.md
-218
View File
@@ -1,218 +0,0 @@
---
description: Create a new MCP tool for MT5-Quant with full build, install, and test cycle
---
# MCP Tool Development Workflow
Complete workflow for adding a new MCP tool to MT5-Quant.
## Step 1: Define Tool Schema
Add the tool definition to `src/tools/definitions.rs`:
1. Create a function `tool_<your_tool_name>()` that returns `serde_json::Value`
2. Add the tool to the `get_tools_list()` vector
3. Follow the JSON schema format:
- `name`: Tool identifier (snake_case)
- `description`: Clear purpose statement
- `inputSchema`: JSON Schema with `required` and `properties`
**Template:**
```rust
fn tool_<your_tool_name>() -> Value {
json!({
"name": "<tool_name>",
"description": "<clear description of what it does>",
"inputSchema": {
"type": "object",
"required": ["<param1>"],
"properties": {
"<param1>": { "type": "string", "description": "..." },
"<param2>": { "type": "integer", "description": "..." }
}
}
})
}
```
## Step 2: Implement Handler
Add the handler implementation in `src/tools/handlers.rs`:
1. Add a match arm in `ToolHandler::handle()` dispatch
2. Implement `handle_<your_tool_name>()` method
3. Return `Result<Value>` with proper MCP response format:
```rust
async fn handle_<your_tool_name>(&self, args: &Value) -> Result<Value> {
// Extract parameters
let param = args.get("param").and_then(|v| v.as_str())
.ok_or_else(|| anyhow::anyhow!("Missing required parameter: param"))?;
// Implementation logic here
let result = /* ... */;
Ok(json!({
"content": [{
"type": "text",
"text": json!({
"success": true,
"data": result
}).to_string()
}],
"isError": false
}))
}
```
## Step 3: Build Release
// turbo
Run the release build script:
```bash
./scripts/build-release.sh
```
This creates `dist/mt5-quant-{platform}.tar.gz` with the binary and config.
## Step 4: Install
Extract and install the new binary:
```bash
tar -xzf dist/mt5-quant-*.tar.gz
cp mt5-quant-*/mt5-quant ~/.cargo/bin/mt5-quant
```
Or install directly from cargo:
```bash
cargo install --path . --force
```
## Step 5: Test with MCP Request
Test the tool using the MCP server. Start the server and send a request:
```bash
# Start the MCP server
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | mt5-quant
# List tools to verify registration
echo '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' | mt5-quant
# Call your new tool
echo '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"<your_tool_name>","arguments":{"<param>":"value"}}}' | mt5-quant
```
**Expected output format:**
```json
{
"jsonrpc": "2.0",
"id": 3,
"result": {
"content": [{"type": "text", "text": "{\"success\":true,...}"}],
"isError": false
}
}
```
## Example: Complete Tool Implementation
**In `src/tools/definitions.rs`:**
```rust
fn tool_healthcheck() -> Value {
json!({
"name": "healthcheck",
"description": "System health check with OS detection and configuration validation",
"inputSchema": {
"type": "object",
"properties": {
"detailed": { "type": "boolean", "description": "Include detailed system info" }
}
}
})
}
```
**Add to `get_tools_list()`:**
```rust
let tools = vec![
// ... existing tools
tool_healthcheck(), // Add here
];
```
**In `src/tools/handlers.rs` - add match arm:**
```rust
"healthcheck" => self.handle_healthcheck(args).await,
```
**Add handler method with OS detection:**
```rust
async fn handle_healthcheck(&self, args: &Value) -> Result<Value> {
let detailed = args.get("detailed").and_then(|v| v.as_bool()).unwrap_or(false);
// OS Detection
let platform = std::env::consts::OS;
let arch = std::env::consts::ARCH;
// Configuration validation
let config_path = Config::writable_config_path();
let config_exists = config_path.exists();
let wine_found = self.config.wine_executable.as_ref()
.map(|p| Path::new(p).exists())
.unwrap_or(false);
let mt5_dir_found = self.config.terminal_dir.as_ref()
.map(|p| Path::new(p).is_dir())
.unwrap_or(false);
let healthy = config_exists && wine_found && mt5_dir_found;
let mut response = json!({
"success": true,
"healthy": healthy,
"timestamp": chrono::Utc::now().to_rfc3339(),
"os": {
"platform": platform,
"arch": arch,
},
"configuration": {
"config_exists": config_exists,
"wine_found": wine_found,
"mt5_dir_found": mt5_dir_found,
},
});
if detailed {
response["detailed"] = json!({
"exe_path": std::env::current_exe()
.map(|p| p.to_string_lossy().to_string())
.unwrap_or_else(|_| "unknown".to_string()),
});
}
Ok(json!({
"content": [{ "type": "text", "text": response.to_string() }],
"isError": false
}))
}
```
**Test the tool:**
```bash
# Basic healthcheck
echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"healthcheck","arguments":{}}}' | mt5-quant
# Detailed healthcheck with system info
echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"healthcheck","arguments":{"detailed":true}}}' | mt5-quant
```
## Testing Checklist
- [ ] Tool appears in `tools/list` output
- [ ] Required parameters are validated
- [ ] Error responses have `isError: true`
- [ ] Success responses have `isError: false`
- [ ] Output is valid JSON in the `text` field
- [ ] Handler doesn't panic on invalid input