cats 0.1.20

Coding Agent ToolS - A comprehensive toolkit for building AI-powered coding 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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Assistant content generation for tool calls
//!
//! Generates human-friendly descriptions of tool calls, similar to
//! professional AI assistants (Zed, VS Code Copilot).

use serde_json::Value;

/// Simple tool call representation for assistant content generation
#[derive(Debug, Clone)]
pub struct ToolCallInfo {
    pub name: String,
    pub arguments: String,
}

impl ToolCallInfo {
    pub fn new(name: impl Into<String>, arguments: impl Into<String>) -> Self {
        Self {
            name: name.into(),
            arguments: arguments.into(),
        }
    }
}

/// Generate meaningful assistant content based on actual tool calls
///
/// This replaces generic "I'll execute the requested tools." with specific descriptions
/// like professional AI assistants do.
///
/// # Arguments
/// * `tool_calls` - Slice of tool call information
///
/// # Returns
/// * `String` - Human-friendly description of what the tools will do
pub fn generate_assistant_content(tool_calls: &[ToolCallInfo]) -> String {
    if tool_calls.is_empty() {
        return String::new(); // Empty content for tool-only responses
    }

    match tool_calls.len() {
        1 => {
            let tool_call = &tool_calls[0];
            match tool_call.name.as_str() {
                "classify_task" => {
                    "I'll analyze and classify this task to determine the best approach."
                        .to_string()
                }
                "read_file" | "open" => {
                    if let Ok(args) = serde_json::from_str::<Value>(&tool_call.arguments) {
                        if let Some(path) = args.get("path").and_then(|p| p.as_str()) {
                            format!("I'll read the file at `{}`.", path)
                        } else {
                            "I'll read the specified file.".to_string()
                        }
                    } else {
                        "I'll read the file for you.".to_string()
                    }
                }
                "write_file" | "create_file" | "overwrite_file" => {
                    if let Ok(args) = serde_json::from_str::<Value>(&tool_call.arguments) {
                        if let Some(path) = args.get("path").and_then(|p| p.as_str()) {
                            format!("I'll write content to `{}`.", path)
                        } else {
                            "I'll write to the specified file.".to_string()
                        }
                    } else {
                        "I'll write the file for you.".to_string()
                    }
                }
                "create_directory" => "I'll create the directory structure you need.".to_string(),
                "run_command" | "execute_command" => {
                    if let Ok(args) = serde_json::from_str::<Value>(&tool_call.arguments) {
                        if let Some(command) = args.get("command").and_then(|c| c.as_str()) {
                            format!("I'll execute the command: `{}`", command)
                        } else {
                            "I'll execute the specified command.".to_string()
                        }
                    } else {
                        "I'll execute the command for you.".to_string()
                    }
                }
                "submit" => "Task completed successfully.".to_string(),
                _ => format!(
                    "I'll use the {} tool to help with your request.",
                    tool_call.name
                ),
            }
        }
        2 => {
            let tool_names: Vec<&str> = tool_calls.iter().map(|tc| tc.name.as_str()).collect();
            format!(
                "I'll help you with that by using {} and {}.",
                tool_names[0], tool_names[1]
            )
        }
        _ => {
            let tool_names: Vec<&str> = tool_calls.iter().map(|tc| tc.name.as_str()).collect();
            format!(
                "I'll work on this using multiple tools: {}.",
                tool_names.join(", ")
            )
        }
    }
}

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

    #[test]
    fn test_generate_assistant_content_single() {
        let tool_call = ToolCallInfo::new("read_file", r#"{"path": "/test/file.txt"}"#);

        let content = generate_assistant_content(&[tool_call]);
        assert!(content.contains("I'll read the file at `/test/file.txt`"));
    }

    #[test]
    fn test_generate_assistant_content_multiple() {
        let tool_calls = vec![
            ToolCallInfo::new("read_file", "{}"),
            ToolCallInfo::new("write_file", "{}"),
        ];

        let content = generate_assistant_content(&tool_calls);
        assert!(content.contains("I'll help you with that by using read_file and write_file"));
    }

    #[test]
    fn test_generate_assistant_content_classify() {
        let tool_call = ToolCallInfo::new("classify_task", r#"{"task_type": "bug_fix"}"#);

        let content = generate_assistant_content(&[tool_call]);
        assert!(content.contains("analyze and classify"));
    }

    #[test]
    fn test_generate_assistant_content_empty() {
        let content = generate_assistant_content(&[]);
        assert_eq!(content, "");
    }
}