mixtape-tools 0.4.0

Ready-to-use tool implementations for the mixtape agent framework
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

// Integration tests for mixtape-tools
//
// These tests verify that the tools work correctly when used together
// and integrate properly with the mixtape framework.

use mixtape_core::Tool;
use mixtape_tools::filesystem::*;
use mixtape_tools::process::*;
use mixtape_tools::search::*;
use tempfile::TempDir;

/// Test that filesystem tools integrate correctly
#[tokio::test]
async fn test_filesystem_tools_integration() {
    let temp_dir = TempDir::new().unwrap();
    let base_path = temp_dir.path().to_path_buf();

    // Test reading and writing
    let write_tool = WriteFileTool::with_base_path(base_path.clone());
    let read_tool = ReadFileTool::with_base_path(base_path.clone());

    // Write a file
    let write_input = serde_json::json!({
        "path": "test.txt",
        "content": "Hello, World!",
        "mode": "rewrite"
    });
    let write_input_typed = serde_json::from_value(write_input).unwrap();
    let write_result = write_tool.execute(write_input_typed).await;
    assert!(write_result.is_ok());

    // Read it back
    let read_input = serde_json::json!({
        "path": "test.txt"
    });
    let read_input_typed = serde_json::from_value(read_input).unwrap();
    let read_result = read_tool.execute(read_input_typed).await.unwrap();
    assert_eq!(read_result.as_text(), "Hello, World!");
}

/// Test that process tools work correctly
#[tokio::test]
async fn test_process_tools_basic() {
    let list_tool = ListProcessesTool;

    // List processes
    let input = serde_json::json!({});
    let input_typed = serde_json::from_value(input).unwrap();
    let result = list_tool.execute(input_typed).await;

    assert!(result.is_ok());
    let output = result.unwrap().as_text();
    assert!(output.contains("PID"));
    assert!(output.contains("NAME"));
}

/// Test that search tools integrate with filesystem
#[tokio::test]
async fn test_search_integration() {
    let temp_dir = TempDir::new().unwrap();
    let base_path = temp_dir.path().to_path_buf();

    // Create some test files
    std::fs::write(
        temp_dir.path().join("test1.rs"),
        "fn main() { println!(\"hello\"); }",
    )
    .unwrap();
    std::fs::write(
        temp_dir.path().join("test2.rs"),
        "fn greet() { println!(\"world\"); }",
    )
    .unwrap();
    std::fs::write(temp_dir.path().join("readme.md"), "# Documentation").unwrap();

    let search_tool = SearchTool::with_base_path(base_path);

    // Search for Rust files
    let input = serde_json::json!({
        "root_path": ".",
        "pattern": "fn",
        "search_type": "content",
        "file_pattern": "*.rs"
    });
    let input_typed = serde_json::from_value(input).unwrap();
    let result = search_tool.execute(input_typed).await;

    assert!(result.is_ok());
    let output = result.unwrap().as_text();
    assert!(output.contains("test1.rs") || output.contains("test2.rs"));
}

/// Test tool schema generation
#[test]
fn test_tool_schemas_are_valid() {
    let read_tool = ReadFileTool::new();
    let schema = read_tool.input_schema();

    // Verify schema is valid JSON
    assert!(schema.is_object());

    // Verify it has expected fields
    let schema_obj = schema.as_object().unwrap();
    assert!(schema_obj.contains_key("$schema") || schema_obj.contains_key("definitions"));
}