hanzo-agents 1.1.21

Specialized AI agents for development workflows - architect, CTO, code reviewer
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

//! Explorer Agent - Codebase exploration and documentation

use crate::prompts::EXPLORER_PROMPT;
use crate::tools::ToolRegistry;
use crate::traits::{
    AgentConfig, AgentError, AgentOutput, Result, SpecializedAgent, ToolDefinition, Usage,
};
use async_trait::async_trait;
use std::sync::Arc;

/// Explorer Agent for codebase exploration and understanding
pub struct ExplorerAgent {
    #[allow(dead_code)] // Reserved for tool execution integration
    tool_registry: Arc<ToolRegistry>,
}

impl ExplorerAgent {
    pub fn new(tool_registry: Arc<ToolRegistry>) -> Self {
        Self { tool_registry }
    }

    pub fn default_agent() -> Self {
        Self::new(Arc::new(ToolRegistry::with_defaults()))
    }
}

#[async_trait]
impl SpecializedAgent for ExplorerAgent {
    fn name(&self) -> &str {
        "explorer"
    }

    fn description(&self) -> &str {
        "Expert codebase analyst for exploration and documentation"
    }

    fn system_prompt(&self) -> &str {
        EXPLORER_PROMPT
    }

    fn tools(&self) -> Vec<ToolDefinition> {
        vec![
            ToolDefinition::new("read_file", "Read contents of a file").with_parameters(
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "path": { "type": "string" }
                    },
                    "required": ["path"]
                }),
            ),
            ToolDefinition::new("list_directory", "List files in a directory").with_parameters(
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "path": { "type": "string" },
                        "recursive": { "type": "boolean" },
                        "pattern": { "type": "string", "description": "Glob pattern" }
                    },
                    "required": ["path"]
                }),
            ),
            ToolDefinition::new("search_code", "Search for patterns").with_parameters(
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "pattern": { "type": "string" },
                        "path": { "type": "string" },
                        "file_type": { "type": "string", "description": "File extension filter" }
                    },
                    "required": ["pattern"]
                }),
            ),
            ToolDefinition::new("find_definition", "Find definition of a symbol").with_parameters(
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "symbol": { "type": "string" },
                        "path": { "type": "string" }
                    },
                    "required": ["symbol"]
                }),
            ),
            ToolDefinition::new("find_references", "Find all references to a symbol")
                .with_parameters(serde_json::json!({
                    "type": "object",
                    "properties": {
                        "symbol": { "type": "string" },
                        "path": { "type": "string" }
                    },
                    "required": ["symbol"]
                })),
            ToolDefinition::new("get_ast", "Get AST structure of a file").with_parameters(
                serde_json::json!({
                    "type": "object",
                    "properties": {
                        "path": { "type": "string" },
                        "depth": { "type": "integer", "description": "Max depth to show" }
                    },
                    "required": ["path"]
                }),
            ),
        ]
    }

    async fn run(&self, input: &str, _config: &AgentConfig) -> Result<AgentOutput> {
        tracing::info!("Explorer agent processing: {}", input);

        Ok(AgentOutput {
            output: format!(
                "Exploration results for: {}\n\n[This is a placeholder - implement LLM integration]",
                input
            ),
            data: None,
            tool_calls: vec![],
            usage: Usage::default(),
            metadata: [("agent".to_string(), "explorer".to_string())]
                .into_iter()
                .collect(),
        })
    }

    async fn run_streaming(
        &self,
        _input: &str,
        _config: &AgentConfig,
    ) -> Result<Box<dyn futures::Stream<Item = Result<String>> + Send + Unpin>> {
        Err(AgentError::Other(
            "Streaming not yet implemented".to_string(),
        ))
    }
}