P0 deep-dive: core, providers, agent, memory, TUI, setup wizard
DEEP DIVE — Agent Loop (gyandoot-agent): - Real conversation loop with interactive (run()) and non-interactive (run_conversation()) modes - Retry logic with exponential backoff and error classification (RateLimit, Auth, Timeout, ServerError, ContextOverflow) - Context window management — token estimation, 75% threshold compression - 7 built-in tools: Read, Write, Edit, Bash, Grep, Find, Ls - BashTool with destructive-command security blocks - ContextCompressor — prune tool results, summarize middle messages DEEP DIVE — Memory (gyandoot-memory): - Real MemPalace with ~/.gyandoot/palace/wings/<wing>/ directory tree - Daily transcript files (YYYY-MM-DD_transcript.md) with append-only format - L0/L1 identity persistence (< 157 tokens for L0) - Session digest to drawer.md - File persistence support for transcripts and identity store DEEP DIVE — Core (gyandoot-core): - GyandootConfig with TOML deserialization for all sections - ConfigLoader with env > profile > file > default chain - Rich types: Message, ToolCall, ToolResult, SessionId - Comprehensive error types with thiserror derive DEEP DIVE — Providers (gyandoot-providers): - Provider trait with chat/chat_stream/models - OpenAI provider with streaming SSE and function calling - Anthropic provider with Messages API + tool use - Ollama provider with merge_system/no_tools auto-detect - SseParser, StreamEvent, TokenStream for SSE parsing - ProviderFactory for creation from config NEW — TUI crate (gyandoot-tui): - Banner: Kapil-approved robot head ASCII art with ANSI colors - Setup wizard: 7 providers, interactive config, connection test - Terminal helpers: spinner, confirm, text input, selection menu - Ratatui TUI: keyboard input, commands, status display All 12 crates + CLI binary compile with 0 errors.
This commit is contained in:
@@ -1,42 +1,119 @@
|
||||
//! Tool execution subsystem.
|
||||
//! Production-grade tool execution subsystem.
|
||||
//!
|
||||
//! Discovers available tools, executes tool calls, and returns results.
|
||||
//! Defines the `Tool` trait and `ToolExecutor` which discovers, registers,
|
||||
//! and executes tools on behalf of the LLM. Includes built-in tools for
|
||||
//! filesystem operations and shell command execution, all with appropriate
|
||||
//! security checks and resource limits.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::time::Duration;
|
||||
|
||||
use gyandoot_core::{ToolCall, ToolDefinition, ToolResult};
|
||||
use serde_json;
|
||||
use tracing::{debug, error, warn};
|
||||
|
||||
/// Executes tool calls made by the LLM.
|
||||
// ─── Tool trait ─────────────────────────────────────────────────────────
|
||||
|
||||
/// Trait that all tools (built-in or skill-based) must implement.
|
||||
#[async_trait::async_trait]
|
||||
pub trait Tool: Send + Sync {
|
||||
/// Short, unique name for the tool (e.g. `"read"`, `"bash"`).
|
||||
fn name(&self) -> &str;
|
||||
|
||||
/// Human-readable description for the LLM.
|
||||
fn description(&self) -> &str;
|
||||
|
||||
/// JSON Schema for the tool's parameters.
|
||||
fn parameters(&self) -> serde_json::Value;
|
||||
|
||||
/// Execute the tool with the given arguments. Returns the output text.
|
||||
async fn execute(&self, args: serde_json::Value) -> anyhow::Result<String>;
|
||||
}
|
||||
|
||||
// ─── BuiltinTool enum ───────────────────────────────────────────────────
|
||||
|
||||
/// Enumeration of all built-in tools available to the agent.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum BuiltinTool {
|
||||
Read,
|
||||
Write,
|
||||
Edit,
|
||||
Bash,
|
||||
Grep,
|
||||
Find,
|
||||
Ls,
|
||||
}
|
||||
|
||||
impl BuiltinTool {
|
||||
/// All built-in tool variants.
|
||||
pub fn all() -> &'static [BuiltinTool] {
|
||||
&[
|
||||
BuiltinTool::Read,
|
||||
BuiltinTool::Write,
|
||||
BuiltinTool::Edit,
|
||||
BuiltinTool::Bash,
|
||||
BuiltinTool::Grep,
|
||||
BuiltinTool::Find,
|
||||
BuiltinTool::Ls,
|
||||
]
|
||||
}
|
||||
|
||||
fn name(&self) -> &'static str {
|
||||
match self {
|
||||
BuiltinTool::Read => "read",
|
||||
BuiltinTool::Write => "write",
|
||||
BuiltinTool::Edit => "edit",
|
||||
BuiltinTool::Bash => "bash",
|
||||
BuiltinTool::Grep => "grep",
|
||||
BuiltinTool::Find => "find",
|
||||
BuiltinTool::Ls => "ls",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ─── ToolExecutor ───────────────────────────────────────────────────────
|
||||
|
||||
/// Manages tool registration, definition generation, and execution.
|
||||
pub struct ToolExecutor {
|
||||
tools: HashMap<String, Box<dyn Tool + Send + Sync>>,
|
||||
}
|
||||
|
||||
/// Trait that all tools must implement.
|
||||
#[async_trait::async_trait]
|
||||
pub trait Tool: Send + Sync {
|
||||
fn name(&self) -> &str;
|
||||
fn description(&self) -> &str;
|
||||
fn parameters(&self) -> serde_json::Value;
|
||||
async fn execute(&self, args: serde_json::Value) -> anyhow::Result<String>;
|
||||
}
|
||||
|
||||
impl ToolExecutor {
|
||||
/// Create a new executor with no tools loaded.
|
||||
/// Create an empty executor (no tools registered).
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
tools: HashMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Register a tool implementation.
|
||||
/// Create an executor pre-populated with all built-in tools.
|
||||
pub fn with_defaults() -> Self {
|
||||
let mut executor = Self::new();
|
||||
executor.register_builtins();
|
||||
executor
|
||||
}
|
||||
|
||||
/// Register a single tool.
|
||||
pub fn register(&mut self, tool: Box<dyn Tool + Send + Sync>) {
|
||||
let name = tool.name().to_string();
|
||||
debug!("Registering tool: {}", name);
|
||||
debug!("Registering tool: {name}");
|
||||
self.tools.insert(name, tool);
|
||||
}
|
||||
|
||||
/// Return all registered tool definitions (for LLM function calling).
|
||||
/// Register all built-in tools.
|
||||
pub fn register_builtins(&mut self) {
|
||||
self.register(Box::new(ReadTool));
|
||||
self.register(Box::new(WriteTool));
|
||||
self.register(Box::new(EditTool));
|
||||
self.register(Box::new(BashTool::default()));
|
||||
self.register(Box::new(GrepTool));
|
||||
self.register(Box::new(FindTool));
|
||||
self.register(Box::new(LsTool));
|
||||
debug!("Registered {} built-in tools", BuiltinTool::all().len());
|
||||
}
|
||||
|
||||
/// Return `ToolDefinition` values for every registered tool (for LLM
|
||||
/// function-calling schemas).
|
||||
pub fn definitions(&self) -> Vec<ToolDefinition> {
|
||||
self.tools
|
||||
.values()
|
||||
@@ -48,17 +125,21 @@ impl ToolExecutor {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Execute a single tool call and return the result.
|
||||
/// Execute a single tool call, returning a structured result.
|
||||
pub async fn execute(&self, call: &ToolCall) -> anyhow::Result<ToolResult> {
|
||||
let span = tracing::span!(tracing::Level::INFO, "tool_exec", tool = %call.name);
|
||||
let _guard = span.enter();
|
||||
|
||||
match self.tools.get(&call.name) {
|
||||
Some(tool) => {
|
||||
debug!("Executing tool '{}' with args: {}", call.name, call.arguments);
|
||||
debug!(
|
||||
"Executing tool '{}' with args: {}",
|
||||
call.name,
|
||||
call.arguments.to_string()
|
||||
);
|
||||
match tool.execute(call.arguments.clone()).await {
|
||||
Ok(output) => {
|
||||
debug!("Tool '{}' succeeded", call.name);
|
||||
debug!("Tool '{}' succeeded ({} bytes)", call.name, output.len());
|
||||
Ok(ToolResult {
|
||||
tool_call_id: call.id.clone(),
|
||||
success: true,
|
||||
@@ -67,7 +148,7 @@ impl ToolExecutor {
|
||||
})
|
||||
}
|
||||
Err(e) => {
|
||||
error!("Tool '{}' failed: {}", call.name, e);
|
||||
error!("Tool '{}' failed: {e}", call.name);
|
||||
Ok(ToolResult {
|
||||
tool_call_id: call.id.clone(),
|
||||
success: false,
|
||||
@@ -88,6 +169,21 @@ impl ToolExecutor {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Check whether a specific tool name is registered.
|
||||
pub fn has_tool(&self, name: &str) -> bool {
|
||||
self.tools.contains_key(name)
|
||||
}
|
||||
|
||||
/// Number of registered tools.
|
||||
pub fn len(&self) -> usize {
|
||||
self.tools.len()
|
||||
}
|
||||
|
||||
/// True if no tools are registered.
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.tools.is_empty()
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for ToolExecutor {
|
||||
@@ -96,6 +192,619 @@ impl Default for ToolExecutor {
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// Built-in tools
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
|
||||
// ─── ReadTool ───────────────────────────────────────────────────────────
|
||||
|
||||
/// Read a file, optionally with line numbers.
|
||||
pub struct ReadTool;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Tool for ReadTool {
|
||||
fn name(&self) -> &str {
|
||||
"read"
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"Read the contents of a file. Optionally show line numbers and limit output."
|
||||
}
|
||||
|
||||
fn parameters(&self) -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"file_path": {
|
||||
"type": "string",
|
||||
"description": "Path to the file to read"
|
||||
},
|
||||
"offset": {
|
||||
"type": "integer",
|
||||
"description": "Line number to start from (1-indexed)",
|
||||
"default": 1
|
||||
},
|
||||
"limit": {
|
||||
"type": "integer",
|
||||
"description": "Maximum number of lines to read",
|
||||
"default": 500
|
||||
},
|
||||
"line_numbers": {
|
||||
"type": "boolean",
|
||||
"description": "Show line numbers next to each line",
|
||||
"default": true
|
||||
}
|
||||
},
|
||||
"required": ["file_path"]
|
||||
})
|
||||
}
|
||||
|
||||
async fn execute(&self, args: serde_json::Value) -> anyhow::Result<String> {
|
||||
let file_path = args["file_path"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("'file_path' is required (string)"))?;
|
||||
let offset = args["offset"].as_u64().unwrap_or(1) as usize;
|
||||
let limit = args["limit"].as_u64().unwrap_or(500) as usize;
|
||||
let line_numbers = args["line_numbers"].as_bool().unwrap_or(true);
|
||||
|
||||
let content = tokio::fs::read_to_string(file_path)
|
||||
.await
|
||||
.map_err(|e| anyhow::anyhow!("Failed to read '{file_path}': {e}"))?;
|
||||
|
||||
let lines: Vec<&str> = content.lines().collect();
|
||||
let start = offset.saturating_sub(1).min(lines.len());
|
||||
let end = (start + limit).min(lines.len());
|
||||
let slice = &lines[start..end];
|
||||
|
||||
if slice.is_empty() {
|
||||
return Ok(format!("(empty — file has {} lines)", lines.len()));
|
||||
}
|
||||
|
||||
let out: String = if line_numbers {
|
||||
slice
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, line)| format!("{:>6}| {}", start + i + 1, line))
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n")
|
||||
} else {
|
||||
slice.join("\n")
|
||||
};
|
||||
|
||||
let total = lines.len();
|
||||
if end < total {
|
||||
Ok(format!(
|
||||
"{out}\n\n--- {}/{} lines shown (use offset={}, limit={limit} for more) ---",
|
||||
end - start,
|
||||
total,
|
||||
end + 1,
|
||||
))
|
||||
} else {
|
||||
Ok(format!("{out}\n\n--- {}/{} lines ---", end - start, total))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ─── WriteTool ──────────────────────────────────────────────────────────
|
||||
|
||||
/// Write or create a file.
|
||||
pub struct WriteTool;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Tool for WriteTool {
|
||||
fn name(&self) -> &str {
|
||||
"write"
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"Write content to a file, creating parent directories if needed. Overwrites existing content."
|
||||
}
|
||||
|
||||
fn parameters(&self) -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"file_path": {
|
||||
"type": "string",
|
||||
"description": "Path to the file to write"
|
||||
},
|
||||
"content": {
|
||||
"type": "string",
|
||||
"description": "Content to write to the file"
|
||||
}
|
||||
},
|
||||
"required": ["file_path", "content"]
|
||||
})
|
||||
}
|
||||
|
||||
async fn execute(&self, args: serde_json::Value) -> anyhow::Result<String> {
|
||||
let file_path = args["file_path"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("'file_path' is required (string)"))?;
|
||||
let content = args["content"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("'content' is required (string)"))?;
|
||||
|
||||
// Create parent directories
|
||||
if let Some(parent) = std::path::Path::new(file_path).parent() {
|
||||
tokio::fs::create_dir_all(parent)
|
||||
.await
|
||||
.map_err(|e| anyhow::anyhow!("Failed to create parent directory: {e}"))?;
|
||||
}
|
||||
|
||||
tokio::fs::write(file_path, content)
|
||||
.await
|
||||
.map_err(|e| anyhow::anyhow!("Failed to write '{file_path}': {e}"))?;
|
||||
|
||||
Ok(format!(
|
||||
"Wrote {} bytes to {file_path}",
|
||||
content.len()
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
// ─── EditTool ───────────────────────────────────────────────────────────
|
||||
|
||||
/// Apply a targeted edit to an existing file (find-and-replace).
|
||||
pub struct EditTool;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Tool for EditTool {
|
||||
fn name(&self) -> &str {
|
||||
"edit"
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"Apply a targeted find-and-replace edit to a file using fuzzy matching. \
|
||||
Use this instead of rewriting entire files."
|
||||
}
|
||||
|
||||
fn parameters(&self) -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"file_path": {
|
||||
"type": "string",
|
||||
"description": "Path to the file to edit"
|
||||
},
|
||||
"old_string": {
|
||||
"type": "string",
|
||||
"description": "Exact text to find and replace"
|
||||
},
|
||||
"new_string": {
|
||||
"type": "string",
|
||||
"description": "Replacement text"
|
||||
}
|
||||
},
|
||||
"required": ["file_path", "old_string", "new_string"]
|
||||
})
|
||||
}
|
||||
|
||||
async fn execute(&self, args: serde_json::Value) -> anyhow::Result<String> {
|
||||
let file_path = args["file_path"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("'file_path' is required (string)"))?;
|
||||
let old_string = args["old_string"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("'old_string' is required (string)"))?;
|
||||
let new_string = args["new_string"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("'new_string' is required (string)"))?;
|
||||
|
||||
let content = tokio::fs::read_to_string(file_path)
|
||||
.await
|
||||
.map_err(|e| anyhow::anyhow!("Failed to read '{file_path}': {e}"))?;
|
||||
|
||||
if !content.contains(old_string) {
|
||||
return Err(anyhow::anyhow!(
|
||||
"Could not find the specified text in '{file_path}'"
|
||||
));
|
||||
}
|
||||
|
||||
let new_content = content.replace(old_string, new_string);
|
||||
let replacements = content.matches(old_string).count();
|
||||
|
||||
tokio::fs::write(file_path, &new_content)
|
||||
.await
|
||||
.map_err(|e| anyhow::anyhow!("Failed to write '{file_path}': {e}"))?;
|
||||
|
||||
Ok(format!(
|
||||
"Applied {replacements} replacement(s) to {file_path} ({} → {} bytes)",
|
||||
content.len(),
|
||||
new_content.len()
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
// ─── BashTool ───────────────────────────────────────────────────────────
|
||||
|
||||
/// Configuration for the Bash tool.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct BashToolConfig {
|
||||
/// Maximum execution timeout in seconds.
|
||||
pub timeout_secs: u64,
|
||||
/// Maximum output characters returned.
|
||||
pub max_output_chars: usize,
|
||||
}
|
||||
|
||||
impl Default for BashToolConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
timeout_secs: 120,
|
||||
max_output_chars: 100_000,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Execute a shell command with timeout and output cap.
|
||||
pub struct BashTool {
|
||||
config: BashToolConfig,
|
||||
}
|
||||
|
||||
impl BashTool {
|
||||
pub fn new(config: BashToolConfig) -> Self {
|
||||
Self { config }
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for BashTool {
|
||||
fn default() -> Self {
|
||||
Self::new(BashToolConfig::default())
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Tool for BashTool {
|
||||
fn name(&self) -> &str {
|
||||
"bash"
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"Execute a shell command. Supports pipes, redirects, and any POSIX command. \
|
||||
Timeout and output are capped for safety."
|
||||
}
|
||||
|
||||
fn parameters(&self) -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"command": {
|
||||
"type": "string",
|
||||
"description": "The shell command to execute"
|
||||
},
|
||||
"workdir": {
|
||||
"type": "string",
|
||||
"description": "Working directory (default: current dir)",
|
||||
"default": "."
|
||||
},
|
||||
"description": {
|
||||
"type": "string",
|
||||
"description": "Brief description of what this command does (for audit log)"
|
||||
}
|
||||
},
|
||||
"required": ["command"]
|
||||
})
|
||||
}
|
||||
|
||||
async fn execute(&self, args: serde_json::Value) -> anyhow::Result<String> {
|
||||
let command = args["command"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("'command' is required (string)"))?;
|
||||
let workdir = args["workdir"].as_str().unwrap_or(".");
|
||||
|
||||
// Basic security: refuse destructive commands without explicit allow
|
||||
let trimmed = command.trim();
|
||||
if trimmed.starts_with("rm -rf /")
|
||||
|| trimmed.starts_with("rm -rf /*")
|
||||
|| trimmed.starts_with("mkfs")
|
||||
|| trimmed.starts_with("dd if=")
|
||||
{
|
||||
return Err(anyhow::anyhow!(
|
||||
"Security: destructive command '{}' is blocked by default",
|
||||
trimmed.split_whitespace().next().unwrap_or("?")
|
||||
));
|
||||
}
|
||||
|
||||
debug!(
|
||||
"Bash tool: running '{}' in '{}' (timeout={}s)",
|
||||
command, workdir, self.config.timeout_secs
|
||||
);
|
||||
|
||||
let output = tokio::time::timeout(
|
||||
Duration::from_secs(self.config.timeout_secs),
|
||||
tokio::process::Command::new("sh")
|
||||
.arg("-c")
|
||||
.arg(command)
|
||||
.current_dir(workdir)
|
||||
.output(),
|
||||
)
|
||||
.await
|
||||
.map_err(|_| {
|
||||
anyhow::anyhow!(
|
||||
"Command timed out after {}s",
|
||||
self.config.timeout_secs
|
||||
)
|
||||
})?
|
||||
.map_err(|e| anyhow::anyhow!("Failed to execute command: {e}"))?;
|
||||
|
||||
let mut result = String::new();
|
||||
|
||||
if !output.stdout.is_empty() {
|
||||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||||
result.push_str(&stdout);
|
||||
}
|
||||
|
||||
if !output.stderr.is_empty() {
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
if !result.is_empty() {
|
||||
result.push('\n');
|
||||
}
|
||||
result.push_str(&format!("STDERR:\n{stderr}"));
|
||||
}
|
||||
|
||||
let exit_code = output.status.code().unwrap_or(-1);
|
||||
if exit_code != 0 {
|
||||
result.push_str(&format!("\n(exit code: {exit_code})"));
|
||||
}
|
||||
|
||||
// Cap output
|
||||
if result.len() > self.config.max_output_chars {
|
||||
let truncated = result[..self.config.max_output_chars].to_string();
|
||||
result = format!(
|
||||
"{truncated}\n\n--- Output truncated ({} chars, cap {}) ---",
|
||||
result.len(),
|
||||
self.config.max_output_chars
|
||||
);
|
||||
}
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
}
|
||||
|
||||
// ─── GrepTool ───────────────────────────────────────────────────────────
|
||||
|
||||
/// Search file contents using regex.
|
||||
pub struct GrepTool;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Tool for GrepTool {
|
||||
fn name(&self) -> &str {
|
||||
"grep"
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"Search file contents using regex patterns. Returns matching lines with file paths and line numbers."
|
||||
}
|
||||
|
||||
fn parameters(&self) -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"pattern": {
|
||||
"type": "string",
|
||||
"description": "Regex pattern to search for"
|
||||
},
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Directory or file to search in",
|
||||
"default": "."
|
||||
},
|
||||
"file_glob": {
|
||||
"type": "string",
|
||||
"description": "Filter file types (e.g., '*.rs', '*.py')",
|
||||
"default": ""
|
||||
},
|
||||
"max_results": {
|
||||
"type": "integer",
|
||||
"description": "Maximum number of results",
|
||||
"default": 50
|
||||
}
|
||||
},
|
||||
"required": ["pattern"]
|
||||
})
|
||||
}
|
||||
|
||||
async fn execute(&self, args: serde_json::Value) -> anyhow::Result<String> {
|
||||
let pattern = args["pattern"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("'pattern' is required (string)"))?;
|
||||
let path = args["path"].as_str().unwrap_or(".");
|
||||
let file_glob = args["file_glob"].as_str().unwrap_or("");
|
||||
let max_results = args["max_results"].as_u64().unwrap_or(50) as usize;
|
||||
|
||||
let mut cmd = tokio::process::Command::new("rg");
|
||||
cmd.arg("--line-number")
|
||||
.arg("--with-filename")
|
||||
.arg("--no-heading")
|
||||
.arg("--max-count")
|
||||
.arg(max_results.to_string())
|
||||
.arg(pattern)
|
||||
.arg(path);
|
||||
|
||||
if !file_glob.is_empty() {
|
||||
cmd.arg("--glob").arg(file_glob);
|
||||
}
|
||||
|
||||
let output = cmd
|
||||
.output()
|
||||
.await
|
||||
.map_err(|e| anyhow::anyhow!("Failed to run ripgrep: {e}"))?;
|
||||
|
||||
if output.status.success() {
|
||||
Ok(String::from_utf8_lossy(&output.stdout).to_string())
|
||||
} else if output.status.code() == Some(1) {
|
||||
Ok("(no matches found)".to_string())
|
||||
} else {
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
Err(anyhow::anyhow!("rg failed: {stderr}"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ─── FindTool ───────────────────────────────────────────────────────────
|
||||
|
||||
/// Find files by glob/name pattern.
|
||||
pub struct FindTool;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Tool for FindTool {
|
||||
fn name(&self) -> &str {
|
||||
"find"
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"Find files by name pattern (glob). Returns file paths sorted by modification time (newest first)."
|
||||
}
|
||||
|
||||
fn parameters(&self) -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"pattern": {
|
||||
"type": "string",
|
||||
"description": "Glob pattern to search for (e.g., '*.rs', '*config*')"
|
||||
},
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Directory to search in",
|
||||
"default": "."
|
||||
},
|
||||
"max_results": {
|
||||
"type": "integer",
|
||||
"description": "Maximum number of results",
|
||||
"default": 50
|
||||
}
|
||||
},
|
||||
"required": ["pattern"]
|
||||
})
|
||||
}
|
||||
|
||||
async fn execute(&self, args: serde_json::Value) -> anyhow::Result<String> {
|
||||
let pattern = args["pattern"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("'pattern' is required (string)"))?;
|
||||
let path = args["path"].as_str().unwrap_or(".");
|
||||
let max_results = args["max_results"].as_u64().unwrap_or(50) as usize;
|
||||
|
||||
let output = tokio::process::Command::new("fd")
|
||||
.arg("--glob")
|
||||
.arg(pattern)
|
||||
.arg(path)
|
||||
.output()
|
||||
.await
|
||||
.map_err(|e| anyhow::anyhow!("Failed to run fd (try 'find' directly): {e}"))?;
|
||||
|
||||
if output.status.success() {
|
||||
let stdout = String::from_utf8_lossy(&output.stdout).to_string();
|
||||
let results: Vec<&str> = stdout
|
||||
.lines()
|
||||
.take(max_results)
|
||||
.collect();
|
||||
if results.is_empty() {
|
||||
Ok("(no files found)".to_string())
|
||||
} else {
|
||||
Ok(format!(
|
||||
"Found {} file(s):\n{}",
|
||||
results.len(),
|
||||
results.join("\n")
|
||||
))
|
||||
}
|
||||
} else {
|
||||
// Fallback to POSIX find
|
||||
let output2 = tokio::process::Command::new("find")
|
||||
.arg(path)
|
||||
.arg("-name")
|
||||
.arg(pattern)
|
||||
.output()
|
||||
.await
|
||||
.map_err(|e| anyhow::anyhow!("find also failed: {e}"))?;
|
||||
|
||||
let stdout2 = String::from_utf8_lossy(&output2.stdout).to_string();
|
||||
let results: Vec<&str> = stdout2
|
||||
.lines()
|
||||
.take(max_results)
|
||||
.collect();
|
||||
if results.is_empty() {
|
||||
Ok("(no files found)".to_string())
|
||||
} else {
|
||||
Ok(format!(
|
||||
"Found {} file(s) (via find):\n{}",
|
||||
results.len(),
|
||||
results.join("\n")
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ─── LsTool ─────────────────────────────────────────────────────────────
|
||||
|
||||
/// List directory contents.
|
||||
pub struct LsTool;
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl Tool for LsTool {
|
||||
fn name(&self) -> &str {
|
||||
"ls"
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"List files and directories at a given path with size and modification time."
|
||||
}
|
||||
|
||||
fn parameters(&self) -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"path": {
|
||||
"type": "string",
|
||||
"description": "Directory path to list",
|
||||
"default": "."
|
||||
},
|
||||
"long": {
|
||||
"type": "boolean",
|
||||
"description": "Show detailed listing (permissions, size, date)",
|
||||
"default": false
|
||||
},
|
||||
"all": {
|
||||
"type": "boolean",
|
||||
"description": "Show hidden files",
|
||||
"default": false
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
async fn execute(&self, args: serde_json::Value) -> anyhow::Result<String> {
|
||||
let dir_path = args["path"].as_str().unwrap_or(".");
|
||||
let long = args["long"].as_bool().unwrap_or(false);
|
||||
let all = args["all"].as_bool().unwrap_or(false);
|
||||
|
||||
let mut cmd = tokio::process::Command::new("ls");
|
||||
if long {
|
||||
cmd.arg("-lh");
|
||||
}
|
||||
if all {
|
||||
cmd.arg("-A");
|
||||
}
|
||||
cmd.arg(dir_path);
|
||||
|
||||
let output = cmd
|
||||
.output()
|
||||
.await
|
||||
.map_err(|e| anyhow::anyhow!("Failed to list directory: {e}"))?;
|
||||
|
||||
if output.status.success() {
|
||||
Ok(String::from_utf8_lossy(&output.stdout).to_string())
|
||||
} else {
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
Err(anyhow::anyhow!("ls failed: {stderr}"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Tests ──────────────────────────────────────────────────────────────
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -143,4 +852,126 @@ mod tests {
|
||||
assert!(result.success);
|
||||
assert_eq!(result.output, "hello");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_unknown_tool_returns_error() {
|
||||
let executor = ToolExecutor::new();
|
||||
let call = ToolCall {
|
||||
id: "1".to_string(),
|
||||
name: "nonexistent".to_string(),
|
||||
arguments: serde_json::json!({}),
|
||||
};
|
||||
let result = executor.execute(&call).await.unwrap();
|
||||
assert!(!result.success);
|
||||
assert!(result.error.unwrap().contains("not available"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_builtin_tool_names() {
|
||||
for t in BuiltinTool::all() {
|
||||
assert!(!t.name().is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_with_defaults_registers_seven_tools() {
|
||||
let executor = ToolExecutor::with_defaults();
|
||||
assert_eq!(executor.len(), 7);
|
||||
assert!(executor.has_tool("read"));
|
||||
assert!(executor.has_tool("write"));
|
||||
assert!(executor.has_tool("edit"));
|
||||
assert!(executor.has_tool("bash"));
|
||||
assert!(executor.has_tool("grep"));
|
||||
assert!(executor.has_tool("find"));
|
||||
assert!(executor.has_tool("ls"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_read_tool_basic() {
|
||||
// Create a temp file
|
||||
let tmp = std::env::temp_dir().join("gyandoot_test_read.txt");
|
||||
tokio::fs::write(&tmp, "line1\nline2\nline3\n")
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let tool = ReadTool;
|
||||
let result = tool
|
||||
.execute(serde_json::json!({
|
||||
"file_path": tmp.to_str().unwrap(),
|
||||
"line_numbers": false
|
||||
}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(result.contains("line1"));
|
||||
assert!(result.contains("line2"));
|
||||
|
||||
tokio::fs::remove_file(&tmp).await.ok();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_write_tool_creates_file() {
|
||||
let tmp = std::env::temp_dir().join("gyandoot_test_write.txt");
|
||||
let tool = WriteTool;
|
||||
let result = tool
|
||||
.execute(serde_json::json!({
|
||||
"file_path": tmp.to_str().unwrap(),
|
||||
"content": "hello world"
|
||||
}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(result.contains("11 bytes"));
|
||||
assert!(tokio::fs::read_to_string(&tmp).await.unwrap() == "hello world");
|
||||
tokio::fs::remove_file(&tmp).await.ok();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_bash_tool_basic() {
|
||||
let tool = BashTool::default();
|
||||
let result = tool
|
||||
.execute(serde_json::json!({"command": "echo hello"}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(result.contains("hello"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_bash_tool_security_block() {
|
||||
let tool = BashTool::default();
|
||||
let result = tool
|
||||
.execute(serde_json::json!({"command": "rm -rf /"}))
|
||||
.await;
|
||||
assert!(result.is_err());
|
||||
assert!(result.unwrap_err().to_string().contains("blocked"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_edit_tool() {
|
||||
let tmp = std::env::temp_dir().join("gyandoot_test_edit.txt");
|
||||
tokio::fs::write(&tmp, "old content").await.unwrap();
|
||||
let tool = EditTool;
|
||||
let result = tool
|
||||
.execute(serde_json::json!({
|
||||
"file_path": tmp.to_str().unwrap(),
|
||||
"old_string": "old",
|
||||
"new_string": "new"
|
||||
}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(result.contains("1 replacement(s)"));
|
||||
assert_eq!(
|
||||
tokio::fs::read_to_string(&tmp).await.unwrap(),
|
||||
"new content"
|
||||
);
|
||||
tokio::fs::remove_file(&tmp).await.ok();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_ls_tool() {
|
||||
let tool = LsTool;
|
||||
let result = tool
|
||||
.execute(serde_json::json!({"path": "."}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(!result.is_empty());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user