♻️ Centralize tool registration with attach_core_tools macro

Introduce a registry module with attach_core_tools! macro that attaches
the standard 7-tool set (git_status, git_diff, git_log, git_changed_files,
file_read, code_search, project_docs) to any agent builder. This prevents
tool list drift between main agents and subagents.

Additional improvements:
- Replace hand-rolled error types with define_tool_error! macro in
  workspace, docs, and parallel_analyze tools
- Convert CodeSearch and Workspace args to use typed enums (SearchType,
  WorkspaceAction, TaskPriority, TaskStatus) with schemars derivation
- Generate tool schemas from Rust types via parameters_schema::<T>()
- Remove unused DynClientBuilder from IrisAgent and AgentSetupService
- Extract inject_style_instructions() from execute_task() in iris.rs
- Delegate commit/PR formatting to types module helpers

Author: hyperb1iss

src/agents/iris.rs

@@ -4,7 +4,6 @@
 //! including configuration loading, client creation, and agent setup.
 
 use anyhow::Result;
-use rig::client::builder::DynClientBuilder;
 use std::sync::Arc;
 
 use crate::agents::context::TaskContext;
@@ -19,7 +18,6 @@ use crate::providers::Provider;
 pub struct AgentSetupService {
     config: Config,
     git_repo: Option<GitRepo>,
-    client_builder: Option<DynClientBuilder>,
 }
 
 impl AgentSetupService {
@@ -28,7 +26,6 @@ impl AgentSetupService {
         Self {
             config,
             git_repo: None,
-            client_builder: None,
         }
     }
 
@@ -59,10 +56,10 @@ impl AgentSetupService {
     /// Create a configured Iris agent
     pub fn create_iris_agent(&mut self) -> Result<IrisAgent> {
         let backend = AgentBackend::from_config(&self.config)?;
-        let client_builder = self.create_client_builder(&backend)?;
+        // Validate environment (API keys etc) before creating agent
+        self.validate_provider(&backend)?;
 
         let mut agent = IrisAgentBuilder::new()
-            .with_client(client_builder)
             .with_provider(&backend.provider_name)
             .with_model(&backend.model)
             .build()?;
@@ -74,9 +71,8 @@ impl AgentSetupService {
         Ok(agent)
     }
 
-    /// Create a Rig client builder based on the backend configuration
-    fn create_client_builder(&mut self, backend: &AgentBackend) -> Result<DynClientBuilder> {
-        // Parse and validate provider
+    /// Validate provider configuration (API keys etc)
+    fn validate_provider(&self, backend: &AgentBackend) -> Result<()> {
         let provider: Provider = backend
             .provider_name
             .parse()
@@ -96,11 +92,7 @@ impl AgentSetupService {
             ));
         }
 
-        // Create client builder - Rig will read from environment variables
-        let client_builder = DynClientBuilder::new();
-        self.client_builder = Some(DynClientBuilder::new());
-
-        Ok(client_builder)
+        Ok(())
     }
 
     /// Get the git repository instance
@@ -112,11 +104,6 @@ impl AgentSetupService {
     pub fn config(&self) -> &Config {
         &self.config
     }
-
-    /// Get the client builder
-    pub fn client_builder(&self) -> Option<&DynClientBuilder> {
-        self.client_builder.as_ref()
-    }
 }
 
 /// High-level function to handle tasks with agents using a common pattern
@@ -147,10 +134,7 @@ where
 
 /// Simple factory function for creating agents with minimal configuration
 pub fn create_agent_with_defaults(provider: &str, model: &str) -> Result<IrisAgent> {
-    let client_builder = DynClientBuilder::new();
-
     IrisAgentBuilder::new()
-        .with_client(client_builder)
         .with_provider(provider)
         .with_model(model)
         .build()
@@ -312,10 +296,7 @@ impl IrisAgentService {
 
     /// Create a configured Iris agent
     fn create_agent(&self) -> Result<IrisAgent> {
-        let client_builder = DynClientBuilder::new();
-
         let mut agent = IrisAgentBuilder::new()
-            .with_client(client_builder)
             .with_provider(&self.provider)
             .with_model(&self.model)
             .build()?;

src/agents/setup.rs

@@ -7,10 +7,10 @@ use anyhow::Result;
 use rig::completion::ToolDefinition;
 use rig::tool::Tool;
 use serde::{Deserialize, Serialize};
-use serde_json::json;
 use std::path::Path;
 use std::process::Command;
 
+use super::common::parameters_schema;
 use crate::define_tool_error;
 
 define_tool_error!(CodeSearchError);
@@ -142,12 +142,52 @@ pub struct SearchResult {
     pub context_lines: usize,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+/// Search type for code search
+#[derive(Debug, Clone, Serialize, Deserialize, schemars::JsonSchema, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum SearchType {
+    /// Search for function definitions
+    Function,
+    /// Search for class/struct definitions
+    Class,
+    /// Search for variable assignments
+    Variable,
+    /// General text search (case-insensitive)
+    #[default]
+    Text,
+    /// Regex pattern search
+    Pattern,
+}
+
+impl SearchType {
+    fn as_str(&self) -> &'static str {
+        match self {
+            SearchType::Function => "function",
+            SearchType::Class => "class",
+            SearchType::Variable => "variable",
+            SearchType::Text => "text",
+            SearchType::Pattern => "pattern",
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize, schemars::JsonSchema)]
 pub struct CodeSearchArgs {
+    /// Search query - function name, class name, variable, or pattern
     pub query: String,
-    pub search_type: String, // "function", "class", "variable", "text", "pattern"
+    /// Type of search to perform
+    #[serde(default)]
+    pub search_type: SearchType,
+    /// Optional file glob pattern to limit scope (e.g., "*.rs", "*.js")
+    #[serde(default)]
     pub file_pattern: Option<String>,
-    pub max_results: Option<usize>,
+    /// Maximum results to return (default: 20, max: 100)
+    #[serde(default = "default_max_results")]
+    pub max_results: usize,
+}
+
+fn default_max_results() -> usize {
+    20
 }
 
 impl Tool for CodeSearch {
@@ -157,55 +197,29 @@ impl Tool for CodeSearch {
     type Output = String;
 
     async fn definition(&self, _: String) -> ToolDefinition {
-        serde_json::from_value(json!({
-            "name": "code_search",
-            "description": "Search for code patterns, functions, classes, and related files in the repository using ripgrep. Supports multiple search types and file filtering.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "query": {
-                        "type": "string",
-                        "description": "Search query - can be function name, class name, variable, or text pattern"
-                    },
-                    "search_type": {
-                        "type": "string",
-                        "enum": ["function", "class", "variable", "text", "pattern"],
-                        "description": "Type of search to perform (default: text)"
-                    },
-                    "file_pattern": {
-                        "type": ["string", "null"],
-                        "description": "Optional file glob pattern to limit search scope (e.g., '*.rs', '*.js')"
-                    },
-                    "max_results": {
-                        "type": ["integer", "null"],
-                        "description": "Maximum number of results to return (default: 20, max: 100)",
-                        "default": 20,
-                        "minimum": 1,
-                        "maximum": 100
-                    }
-                },
-                "required": ["query", "search_type", "file_pattern", "max_results"]
-            }
-        }))
-        .expect("code_search tool definition should be valid JSON")
+        ToolDefinition {
+            name: "code_search".to_string(),
+            description: "Search for code patterns, functions, classes, and related files in the repository using ripgrep. Supports multiple search types and file filtering.".to_string(),
+            parameters: parameters_schema::<CodeSearchArgs>(),
+        }
     }
 
     async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
         let current_dir = std::env::current_dir().map_err(CodeSearchError::from)?;
-        let max_results = args.max_results.unwrap_or(20);
+        let max_results = args.max_results.min(100); // Cap at 100
 
         let results = Self::execute_ripgrep_search(
             &args.query,
             &current_dir,
             args.file_pattern.as_deref(),
-            &args.search_type,
+            args.search_type.as_str(),
             max_results,
         )
         .map_err(CodeSearchError::from)?;
 
         let result = serde_json::json!({
             "query": args.query,
-            "search_type": args.search_type,
+            "search_type": args.search_type.as_str(),
             "results": results,
             "total_found": results.len(),
             "max_results": max_results,

src/agents/tools/code_search.rs

@@ -11,15 +11,8 @@ use std::path::PathBuf;
 
 use super::common::parameters_schema;
 
-#[derive(Debug, thiserror::Error)]
-#[error("Docs error: {0}")]
-pub struct DocsError(String);
-
-impl From<std::io::Error> for DocsError {
-    fn from(err: std::io::Error) -> Self {
-        DocsError(err.to_string())
-    }
-}
+// Use standard tool error macro for consistency
+crate::define_tool_error!(DocsError);
 
 /// Tool for fetching project documentation files
 #[derive(Debug, Clone, Serialize, Deserialize)]

src/agents/tools/docs.rs

@@ -7,6 +7,10 @@
 pub mod common;
 pub use common::{get_current_repo, parameters_schema};
 
+// Tool registry for consistent attachment
+pub mod registry;
+pub use registry::CORE_TOOLS;
+
 // Tool modules with Rig-based implementations
 pub mod git;
 

src/agents/tools/mod.rs

@@ -17,9 +17,7 @@ use serde_json::json;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 
-use super::{CodeSearch, FileRead, GitChangedFiles, GitDiff, GitLog, GitStatus, ProjectDocs};
 use crate::agents::debug as agent_debug;
-use crate::agents::debug_tool::DebugTool;
 
 /// Arguments for parallel analysis
 #[derive(Debug, Deserialize, JsonSchema)]
@@ -102,37 +100,16 @@ impl SubagentRunner {
             - Return a clear, structured summary\n\
             - Be concise but comprehensive";
 
+        // Use shared tool registry for consistent tool attachment
         let result = match self {
             Self::OpenAI { client, model } => {
-                let agent = client
-                    .agent(model)
-                    .preamble(preamble)
-                    .max_tokens(4096)
-                    .tool(DebugTool::new(GitStatus))
-                    .tool(DebugTool::new(GitDiff))
-                    .tool(DebugTool::new(GitLog))
-                    .tool(DebugTool::new(GitChangedFiles))
-                    .tool(DebugTool::new(FileRead))
-                    .tool(DebugTool::new(CodeSearch))
-                    .tool(DebugTool::new(ProjectDocs))
-                    .build();
-
+                let builder = client.agent(model).preamble(preamble).max_tokens(4096);
+                let agent = crate::attach_core_tools!(builder).build();
                 agent.prompt(task).await
             }
             Self::Anthropic { client, model } => {
-                let agent = client
-                    .agent(model)
-                    .preamble(preamble)
-                    .max_tokens(4096)
-                    .tool(DebugTool::new(GitStatus))
-                    .tool(DebugTool::new(GitDiff))
-                    .tool(DebugTool::new(GitLog))
-                    .tool(DebugTool::new(GitChangedFiles))
-                    .tool(DebugTool::new(FileRead))
-                    .tool(DebugTool::new(CodeSearch))
-                    .tool(DebugTool::new(ProjectDocs))
-                    .build();
-
+                let builder = client.agent(model).preamble(preamble).max_tokens(4096);
+                let agent = crate::attach_core_tools!(builder).build();
                 agent.prompt(task).await
             }
         };
@@ -179,9 +156,8 @@ impl ParallelAnalyze {
     }
 }
 
-#[derive(Debug, thiserror::Error)]
-#[error("Parallel analysis error: {0}")]
-pub struct ParallelAnalyzeError(String);
+// Use standard tool error macro for consistency
+crate::define_tool_error!(ParallelAnalyzeError);
 
 impl Tool for ParallelAnalyze {
     const NAME: &'static str = "parallel_analyze";
@@ -228,7 +204,10 @@ impl Tool for ParallelAnalyze {
 
         agent_debug::debug_context_management(
             "ParallelAnalyze",
-            &format!("Spawning {} subagents (fast model: {})", num_tasks, self.model),
+            &format!(
+                "Spawning {} subagents (fast model: {})",
+                num_tasks, self.model
+            ),
         );
 
         // Collect results using Arc<Mutex> for thread-safe access
@@ -268,7 +247,10 @@ impl Tool for ParallelAnalyze {
 
         agent_debug::debug_context_management(
             "ParallelAnalyze",
-            &format!("{}/{} successful in {}ms", successful, num_tasks, execution_time_ms),
+            &format!(
+                "{}/{} successful in {}ms",
+                successful, num_tasks, execution_time_ms
+            ),
         );
 
         Ok(ParallelAnalyzeResult {