refactor: make tool registry thread-safe with Arc<RwLock>

- Use Arc<RwLock<HashMap>> for concurrent access
- Tools stored as Arc<dyn Tool> for sharing
- Registry is now Clone (just clones the Arc)
- Safe to use across multiple threads
- Add concurrency tests
- Remove mut from registry declarations (register no longer needs &mut)

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <[e-mail]>
Co-Authored-By: Happy <[e-mail]>

src/planning/mod.rs

···
 use crate::llm::anthropic::AnthropicClient;
 use crate::tools::{ToolRegistry, file::{ReadFileTool, WriteFileTool, ListFilesTool}, shell::RunCommandTool};
 use std::io::{self, Write};
+use std::sync::Arc;
 
 /// Planning agent for interactive spec creation
 pub struct PlanningAgent {
···
         };
 
         // Create and populate tool registry
-        let mut registry = ToolRegistry::new();
-        registry.register(Box::new(ReadFileTool));
-        registry.register(Box::new(WriteFileTool));
-        registry.register(Box::new(ListFilesTool));
-        registry.register(Box::new(RunCommandTool));
+        let registry = ToolRegistry::new();
+        registry.register(Arc::new(ReadFileTool));
+        registry.register(Arc::new(WriteFileTool));
+        registry.register(Arc::new(ListFilesTool));
+        registry.register(Arc::new(RunCommandTool));
 
         // Initialize conversation with system message
         let system_message = Message {

src/ralph/mod.rs

···
         };
 
         // Register tools
-        let mut tools = ToolRegistry::new();
-        tools.register(Box::new(ReadFileTool));
-        tools.register(Box::new(WriteFileTool));
-        tools.register(Box::new(ListFilesTool));
-        tools.register(Box::new(RunCommandTool));
+        let tools = ToolRegistry::new();
+        tools.register(Arc::new(ReadFileTool));
+        tools.register(Arc::new(WriteFileTool));
+        tools.register(Arc::new(ListFilesTool));
+        tools.register(Arc::new(RunCommandTool));
 
         let max_iterations = max_iterations
             .or(config.rustagent.max_iterations)

src/tools/mod.rs

···
-use async_trait::async_trait;
 use anyhow::Result;
+use async_trait::async_trait;
 use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
 
 use crate::llm::ToolDefinition;
 
···
 
 /// Registry for managing available tools
 pub struct ToolRegistry {
-    tools: HashMap<String, Box<dyn Tool>>,
+    tools: Arc<RwLock<HashMap<String, Arc<dyn Tool>>>>,
 }
 
 impl ToolRegistry {
     /// Creates a new empty tool registry
     pub fn new() -> Self {
         Self {
-            tools: HashMap::new(),
+            tools: Arc::new(RwLock::new(HashMap::new())),
         }
     }
 
     /// Registers a new tool in the registry
-    pub fn register(&mut self, tool: Box<dyn Tool>) {
-        let name = tool.name().to_string();
-        self.tools.insert(name, tool);
+    pub fn register(&self, tool: Arc<dyn Tool>) {
+        let mut tools = self.tools.write().unwrap();
+        tools.insert(tool.name().to_string(), tool);
     }
 
     /// Gets a tool by name
-    pub fn get(&self, name: &str) -> Option<&dyn Tool> {
-        self.tools.get(name).map(|b| &**b)
+    pub fn get(&self, name: &str) -> Option<Arc<dyn Tool>> {
+        let tools = self.tools.read().unwrap();
+        tools.get(name).cloned()
     }
 
     /// Lists all registered tool names
-    pub fn list(&self) -> Vec<&str> {
-        self.tools.keys().map(|s| s.as_str()).collect()
+    pub fn list(&self) -> Vec<String> {
+        let tools = self.tools.read().unwrap();
+        tools.keys().cloned().collect()
     }
 
     /// Converts all registered tools to LLM tool definitions
     pub fn definitions(&self) -> Vec<ToolDefinition> {
-        self.tools
+        let tools = self.tools.read().unwrap();
+        tools
             .values()
             .map(|tool| ToolDefinition {
                 name: tool.name().to_string(),
···
                 parameters: tool.parameters(),
             })
             .collect()
+    }
+}
+
+impl Clone for ToolRegistry {
+    fn clone(&self) -> Self {
+        Self {
+            tools: Arc::clone(&self.tools),
+        }
     }
 }
 

tests/tools_test.rs

···
-use rustagent::tools::{Tool, ToolRegistry};
-use async_trait::async_trait;
 use anyhow::Result;
+use async_trait::async_trait;
+use rustagent::tools::{Tool, ToolRegistry};
 
 struct MockTool;
 
···
 
 #[tokio::test]
 async fn test_tool_registry() {
-    let mut registry = ToolRegistry::new();
-    registry.register(Box::new(MockTool));
+    let registry = ToolRegistry::new();
+    registry.register(Arc::new(MockTool));
 
     assert!(registry.get("mock_tool").is_some());
     assert!(registry.get("nonexistent").is_none());
···
     assert_eq!(result, "success");
 }
 
-use rustagent::tools::file::{ReadFileTool, WriteFileTool, ListFilesTool};
+use rustagent::tools::file::{ListFilesTool, ReadFileTool, WriteFileTool};
 use rustagent::tools::shell::RunCommandTool;
 use serde_json::json;
-use tempfile::TempDir;
 use std::fs;
+use tempfile::TempDir;
 
 #[tokio::test]
 async fn test_read_file_tool() {
···
     fs::write(&file_path, "hello world").unwrap();
 
     let tool = ReadFileTool;
-    let result = tool.execute(json!({
-        "path": file_path.to_str().unwrap()
-    })).await.unwrap();
+    let result = tool
+        .execute(json!({
+            "path": file_path.to_str().unwrap()
+        }))
+        .await
+        .unwrap();
 
     assert!(result.contains("hello world"));
 }
···
     tool.execute(json!({
         "path": file_path.to_str().unwrap(),
         "content": "test content"
-    })).await.unwrap();
+    }))
+    .await
+    .unwrap();
 
     let content = fs::read_to_string(&file_path).unwrap();
     assert_eq!(content, "test content");
···
     fs::write(temp.path().join("file2.txt"), "b").unwrap();
 
     let tool = ListFilesTool;
-    let result = tool.execute(json!({
-        "path": temp.path().to_str().unwrap()
-    })).await.unwrap();
+    let result = tool
+        .execute(json!({
+            "path": temp.path().to_str().unwrap()
+        }))
+        .await
+        .unwrap();
 
     assert!(result.contains("file1.txt"));
     assert!(result.contains("file2.txt"));
···
 #[tokio::test]
 async fn test_run_command_tool() {
     let tool = RunCommandTool;
-    let result = tool.execute(json!({
-        "command": "echo hello"
-    })).await.unwrap();
+    let result = tool
+        .execute(json!({
+            "command": "echo hello"
+        }))
+        .await
+        .unwrap();
 
     assert!(result.contains("hello"));
 }
···
     let temp = TempDir::new().unwrap();
 
     let tool = RunCommandTool;
-    let result = tool.execute(json!({
-        "command": "pwd",
-        "working_dir": temp.path().to_str().unwrap()
-    })).await.unwrap();
+    let result = tool
+        .execute(json!({
+            "command": "pwd",
+            "working_dir": temp.path().to_str().unwrap()
+        }))
+        .await
+        .unwrap();
 
     assert!(result.contains(temp.path().to_str().unwrap()));
 }
+
+use std::sync::Arc;
+use std::thread;
+
+#[test]
+fn test_registry_clone_and_concurrent_access() {
+    let mut registry = ToolRegistry::new();
+    registry.register(Arc::new(MockTool));
+
+    let registry1 = registry.clone();
+    let registry2 = registry.clone();
+
+    let handle1 = thread::spawn(move || {
+        registry1.get("mock_tool").is_some()
+    });
+
+    let handle2 = thread::spawn(move || {
+        registry2.get("mock_tool").is_some()
+    });
+
+    assert!(handle1.join().unwrap());
+    assert!(handle2.join().unwrap());
+}
+
+#[test]
+fn test_registry_register_while_reading() {
+    let registry = ToolRegistry::new();
+    let registry_clone = registry.clone();
+
+    let handle = thread::spawn(move || {
+        registry_clone.register(Arc::new(MockTool));
+    });
+
+    // Should be able to read while another thread is registering
+    let _ = registry.list();
+
+    handle.join().unwrap();
+}