ricecoder_agents/

tool_invokers.rs

//! Tool invoker implementations for ricecoder-tools
//!
//! This module provides implementations of the ToolInvoker trait for each tool
//! provided by ricecoder-tools (webfetch, patch, todowrite, todoread, websearch).

use crate::tool_registry::{ToolInvoker, ToolMetadata};
use serde_json::json;
use tracing::{debug, info};

/// Webfetch tool invoker
///
/// Invokes the webfetch tool to fetch web content from URLs.
pub struct WebfetchToolInvoker;

#[async_trait::async_trait]
impl ToolInvoker for WebfetchToolInvoker {
    async fn invoke(&self, input: serde_json::Value) -> Result<serde_json::Value, String> {
        debug!("Invoking webfetch tool");

        // Extract URL from input
        let url = input
            .get("url")
            .and_then(|v| v.as_str())
            .ok_or_else(|| "Missing 'url' field in input".to_string())?;

        info!(url = %url, "Fetching web content");

        // TODO: Implement actual webfetch invocation
        // For now, return a placeholder response
        Ok(json!({
            "success": true,
            "content": "Web content would be fetched here",
            "url": url,
            "metadata": {
                "provider": "builtin",
                "truncated": false,
                "size": 0
            }
        }))
    }

    fn metadata(&self) -> ToolMetadata {
        ToolMetadata {
            id: "webfetch".to_string(),
            name: "Webfetch".to_string(),
            description: "Fetch and process web content from URLs".to_string(),
            input_schema: json!({
                "type": "object",
                "properties": {
                    "url": {
                        "type": "string",
                        "description": "URL to fetch"
                    },
                    "max_size": {
                        "type": "integer",
                        "description": "Maximum content size in bytes (optional)"
                    }
                },
                "required": ["url"]
            }),
            output_schema: json!({
                "type": "object",
                "properties": {
                    "success": { "type": "boolean" },
                    "content": { "type": "string" },
                    "url": { "type": "string" },
                    "metadata": {
                        "type": "object",
                        "properties": {
                            "provider": { "type": "string" },
                            "truncated": { "type": "boolean" },
                            "size": { "type": "integer" }
                        }
                    }
                }
            }),
            available: true,
        }
    }
}

/// Patch tool invoker
///
/// Invokes the patch tool to apply unified diff patches to files.
pub struct PatchToolInvoker;

#[async_trait::async_trait]
impl ToolInvoker for PatchToolInvoker {
    async fn invoke(&self, input: serde_json::Value) -> Result<serde_json::Value, String> {
        debug!("Invoking patch tool");

        // Extract file path and patch content from input
        let file_path = input
            .get("file_path")
            .and_then(|v| v.as_str())
            .ok_or_else(|| "Missing 'file_path' field in input".to_string())?;

        let _patch_content = input
            .get("patch_content")
            .and_then(|v| v.as_str())
            .ok_or_else(|| "Missing 'patch_content' field in input".to_string())?;

        info!(file_path = %file_path, "Applying patch");

        // TODO: Implement actual patch invocation
        // For now, return a placeholder response
        Ok(json!({
            "success": true,
            "applied_hunks": 0,
            "failed_hunks": 0,
            "file_path": file_path,
            "metadata": {
                "provider": "builtin"
            }
        }))
    }

    fn metadata(&self) -> ToolMetadata {
        ToolMetadata {
            id: "patch".to_string(),
            name: "Patch".to_string(),
            description: "Apply unified diff patches to files safely".to_string(),
            input_schema: json!({
                "type": "object",
                "properties": {
                    "file_path": {
                        "type": "string",
                        "description": "Path to the file to patch"
                    },
                    "patch_content": {
                        "type": "string",
                        "description": "Unified diff patch content"
                    }
                },
                "required": ["file_path", "patch_content"]
            }),
            output_schema: json!({
                "type": "object",
                "properties": {
                    "success": { "type": "boolean" },
                    "applied_hunks": { "type": "integer" },
                    "failed_hunks": { "type": "integer" },
                    "file_path": { "type": "string" },
                    "metadata": {
                        "type": "object",
                        "properties": {
                            "provider": { "type": "string" }
                        }
                    }
                }
            }),
            available: true,
        }
    }
}

/// Todowrite tool invoker
///
/// Invokes the todowrite tool to create or update todos.
pub struct TodowriteToolInvoker;

#[async_trait::async_trait]
impl ToolInvoker for TodowriteToolInvoker {
    async fn invoke(&self, input: serde_json::Value) -> Result<serde_json::Value, String> {
        debug!("Invoking todowrite tool");

        // Extract todos from input
        let todos = input
            .get("todos")
            .ok_or_else(|| "Missing 'todos' field in input".to_string())?;

        info!(todo_count = todos.as_array().map(|a| a.len()).unwrap_or(0), "Writing todos");

        // TODO: Implement actual todowrite invocation
        // For now, return a placeholder response
        Ok(json!({
            "success": true,
            "created": 0,
            "updated": 0,
            "metadata": {
                "provider": "builtin"
            }
        }))
    }

    fn metadata(&self) -> ToolMetadata {
        ToolMetadata {
            id: "todowrite".to_string(),
            name: "Todowrite".to_string(),
            description: "Create or update todos in the task list".to_string(),
            input_schema: json!({
                "type": "object",
                "properties": {
                    "todos": {
                        "type": "array",
                        "description": "List of todos to create or update",
                        "items": {
                            "type": "object",
                            "properties": {
                                "id": { "type": "string" },
                                "title": { "type": "string" },
                                "description": { "type": "string" },
                                "status": { "type": "string" },
                                "priority": { "type": "string" }
                            }
                        }
                    }
                },
                "required": ["todos"]
            }),
            output_schema: json!({
                "type": "object",
                "properties": {
                    "success": { "type": "boolean" },
                    "created": { "type": "integer" },
                    "updated": { "type": "integer" },
                    "metadata": {
                        "type": "object",
                        "properties": {
                            "provider": { "type": "string" }
                        }
                    }
                }
            }),
            available: true,
        }
    }
}

/// Todoread tool invoker
///
/// Invokes the todoread tool to read todos from the task list.
pub struct TodoreadToolInvoker;

#[async_trait::async_trait]
impl ToolInvoker for TodoreadToolInvoker {
    async fn invoke(&self, input: serde_json::Value) -> Result<serde_json::Value, String> {
        debug!("Invoking todoread tool");

        // Extract optional filters from input
        let status_filter = input.get("status").and_then(|v| v.as_str());
        let priority_filter = input.get("priority").and_then(|v| v.as_str());

        info!(
            status_filter = ?status_filter,
            priority_filter = ?priority_filter,
            "Reading todos"
        );

        // TODO: Implement actual todoread invocation
        // For now, return a placeholder response
        Ok(json!({
            "success": true,
            "todos": [],
            "metadata": {
                "provider": "builtin"
            }
        }))
    }

    fn metadata(&self) -> ToolMetadata {
        ToolMetadata {
            id: "todoread".to_string(),
            name: "Todoread".to_string(),
            description: "Read todos from the task list with optional filtering".to_string(),
            input_schema: json!({
                "type": "object",
                "properties": {
                    "status": {
                        "type": "string",
                        "description": "Filter by status (optional)"
                    },
                    "priority": {
                        "type": "string",
                        "description": "Filter by priority (optional)"
                    }
                }
            }),
            output_schema: json!({
                "type": "object",
                "properties": {
                    "success": { "type": "boolean" },
                    "todos": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "id": { "type": "string" },
                                "title": { "type": "string" },
                                "description": { "type": "string" },
                                "status": { "type": "string" },
                                "priority": { "type": "string" }
                            }
                        }
                    },
                    "metadata": {
                        "type": "object",
                        "properties": {
                            "provider": { "type": "string" }
                        }
                    }
                }
            }),
            available: true,
        }
    }
}

/// Websearch tool invoker
///
/// Invokes the websearch tool to search the web.
pub struct WebsearchToolInvoker;

#[async_trait::async_trait]
impl ToolInvoker for WebsearchToolInvoker {
    async fn invoke(&self, input: serde_json::Value) -> Result<serde_json::Value, String> {
        debug!("Invoking websearch tool");

        // Extract query from input
        let query = input
            .get("query")
            .and_then(|v| v.as_str())
            .ok_or_else(|| "Missing 'query' field in input".to_string())?;

        let limit = input
            .get("limit")
            .and_then(|v| v.as_u64())
            .unwrap_or(10);

        let offset = input
            .get("offset")
            .and_then(|v| v.as_u64())
            .unwrap_or(0);

        info!(query = %query, limit = %limit, offset = %offset, "Searching web");

        // TODO: Implement actual websearch invocation
        // For now, return a placeholder response
        Ok(json!({
            "success": true,
            "results": [],
            "total_count": 0,
            "query": query,
            "metadata": {
                "provider": "builtin",
                "limit": limit,
                "offset": offset
            }
        }))
    }

    fn metadata(&self) -> ToolMetadata {
        ToolMetadata {
            id: "websearch".to_string(),
            name: "Websearch".to_string(),
            description: "Search the web and return ranked results".to_string(),
            input_schema: json!({
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Search query"
                    },
                    "limit": {
                        "type": "integer",
                        "description": "Maximum number of results (optional, default: 10)"
                    },
                    "offset": {
                        "type": "integer",
                        "description": "Result offset for pagination (optional, default: 0)"
                    }
                },
                "required": ["query"]
            }),
            output_schema: json!({
                "type": "object",
                "properties": {
                    "success": { "type": "boolean" },
                    "results": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "title": { "type": "string" },
                                "url": { "type": "string" },
                                "snippet": { "type": "string" },
                                "rank": { "type": "integer" }
                            }
                        }
                    },
                    "total_count": { "type": "integer" },
                    "query": { "type": "string" },
                    "metadata": {
                        "type": "object",
                        "properties": {
                            "provider": { "type": "string" },
                            "limit": { "type": "integer" },
                            "offset": { "type": "integer" }
                        }
                    }
                }
            }),
            available: true,
        }
    }
}

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

    #[tokio::test]
    async fn test_webfetch_invoker() {
        let invoker = WebfetchToolInvoker;
        let input = json!({
            "url": "https://example.com"
        });

        let result = invoker.invoke(input).await;
        assert!(result.is_ok());

        let output = result.unwrap();
        assert_eq!(output["success"], true);
        assert_eq!(output["url"], "https://example.com");
    }

    #[tokio::test]
    async fn test_webfetch_missing_url() {
        let invoker = WebfetchToolInvoker;
        let input = json!({});

        let result = invoker.invoke(input).await;
        assert!(result.is_err());
    }

    #[test]
    fn test_webfetch_metadata() {
        let invoker = WebfetchToolInvoker;
        let metadata = invoker.metadata();

        assert_eq!(metadata.id, "webfetch");
        assert_eq!(metadata.name, "Webfetch");
        assert!(metadata.available);
    }

    #[tokio::test]
    async fn test_patch_invoker() {
        let invoker = PatchToolInvoker;
        let input = json!({
            "file_path": "src/main.rs",
            "patch_content": "--- a/src/main.rs\n+++ b/src/main.rs\n"
        });

        let result = invoker.invoke(input).await;
        assert!(result.is_ok());

        let output = result.unwrap();
        assert_eq!(output["success"], true);
    }

    #[tokio::test]
    async fn test_patch_missing_fields() {
        let invoker = PatchToolInvoker;
        let input = json!({
            "file_path": "src/main.rs"
        });

        let result = invoker.invoke(input).await;
        assert!(result.is_err());
    }

    #[test]
    fn test_patch_metadata() {
        let invoker = PatchToolInvoker;
        let metadata = invoker.metadata();

        assert_eq!(metadata.id, "patch");
        assert_eq!(metadata.name, "Patch");
        assert!(metadata.available);
    }

    #[tokio::test]
    async fn test_todowrite_invoker() {
        let invoker = TodowriteToolInvoker;
        let input = json!({
            "todos": [
                {
                    "id": "1",
                    "title": "Task 1",
                    "description": "Description",
                    "status": "pending",
                    "priority": "high"
                }
            ]
        });

        let result = invoker.invoke(input).await;
        assert!(result.is_ok());

        let output = result.unwrap();
        assert_eq!(output["success"], true);
    }

    #[tokio::test]
    async fn test_todowrite_missing_todos() {
        let invoker = TodowriteToolInvoker;
        let input = json!({});

        let result = invoker.invoke(input).await;
        assert!(result.is_err());
    }

    #[test]
    fn test_todowrite_metadata() {
        let invoker = TodowriteToolInvoker;
        let metadata = invoker.metadata();

        assert_eq!(metadata.id, "todowrite");
        assert_eq!(metadata.name, "Todowrite");
        assert!(metadata.available);
    }

    #[tokio::test]
    async fn test_todoread_invoker() {
        let invoker = TodoreadToolInvoker;
        let input = json!({
            "status": "pending"
        });

        let result = invoker.invoke(input).await;
        assert!(result.is_ok());

        let output = result.unwrap();
        assert_eq!(output["success"], true);
    }

    #[tokio::test]
    async fn test_todoread_no_filters() {
        let invoker = TodoreadToolInvoker;
        let input = json!({});

        let result = invoker.invoke(input).await;
        assert!(result.is_ok());
    }

    #[test]
    fn test_todoread_metadata() {
        let invoker = TodoreadToolInvoker;
        let metadata = invoker.metadata();

        assert_eq!(metadata.id, "todoread");
        assert_eq!(metadata.name, "Todoread");
        assert!(metadata.available);
    }

    #[tokio::test]
    async fn test_websearch_invoker() {
        let invoker = WebsearchToolInvoker;
        let input = json!({
            "query": "rust programming",
            "limit": 10
        });

        let result = invoker.invoke(input).await;
        assert!(result.is_ok());

        let output = result.unwrap();
        assert_eq!(output["success"], true);
        assert_eq!(output["query"], "rust programming");
    }

    #[tokio::test]
    async fn test_websearch_missing_query() {
        let invoker = WebsearchToolInvoker;
        let input = json!({});

        let result = invoker.invoke(input).await;
        assert!(result.is_err());
    }

    #[test]
    fn test_websearch_metadata() {
        let invoker = WebsearchToolInvoker;
        let metadata = invoker.metadata();

        assert_eq!(metadata.id, "websearch");
        assert_eq!(metadata.name, "Websearch");
        assert!(metadata.available);
    }
}