use crate::registry::{ToolEntry, ToolPermission};
use regex::Regex;
use serde_json::{json, Value};
use std::fs;
use std::path::{Path, PathBuf};
const MAX_FILE_BYTES: usize = 512 * 1024;
pub fn entries() -> Vec<ToolEntry> {
vec![
ToolEntry::builtin(car_ir::builtins::read_file()).with_category("filesystem"),
ToolEntry::builtin(car_ir::builtins::list_dir()).with_category("filesystem"),
ToolEntry::builtin(car_ir::builtins::find_files()).with_category("filesystem"),
ToolEntry::builtin(car_ir::builtins::grep_files()).with_category("filesystem"),
ToolEntry::builtin(car_ir::builtins::calculate()).with_category("utility"),
ToolEntry::builtin(car_ir::builtins::write_file())
.with_permission(ToolPermission::AskUser)
.with_side_effects(true)
.with_category("filesystem"),
ToolEntry::builtin(car_ir::builtins::edit_file())
.with_permission(ToolPermission::AskUser)
.with_side_effects(true)
.with_category("filesystem"),
]
}
pub async fn execute(tool: &str, params: &Value) -> Option<Result<Value, String>> {
let result = match tool {
"read_file" => exec_read_file(params),
"write_file" => exec_write_file(params),
"edit_file" => exec_edit_file(params),
"list_dir" => exec_list_dir(params),
"find_files" => exec_find_files(params),
"grep_files" => exec_grep_files(params),
"calculate" => exec_calculate(params),
_ => return None,
};
Some(result)
}
fn resolve_path(path: &str) -> Result<PathBuf, String> {
let candidate = PathBuf::from(path);
if candidate.is_absolute() {
Ok(candidate)
} else {
std::env::current_dir()
.map(|cwd| cwd.join(candidate))
.map_err(|e| format!("failed to resolve working directory: {e}"))
}
}
fn exec_read_file(params: &Value) -> Result<Value, String> {
let path = params
.get("path")
.and_then(|v| v.as_str())
.ok_or("missing 'path' parameter")?;
let offset = params.get("offset").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
let limit = params
.get("limit")
.and_then(|v| v.as_u64())
.map(|v| v as usize);
let full_path = resolve_path(path)?;
let content = fs::read_to_string(&full_path)
.map_err(|e| format!("failed to read file '{}': {e}", full_path.display()))?;
let size_bytes = content.len();
let total_lines = content.lines().count();
let returned = if offset > 0 || limit.is_some() {
let lines: Vec<&str> = content.lines().collect();
let start = offset.min(lines.len());
let end = limit
.map(|line_count| (start + line_count).min(lines.len()))
.unwrap_or(lines.len());
lines[start..end].join("\n")
} else {
content
};
Ok(json!({
"path": full_path.display().to_string(),
"content": returned,
"size_bytes": size_bytes,
"total_lines": total_lines,
}))
}
fn exec_write_file(params: &Value) -> Result<Value, String> {
let path = params
.get("path")
.and_then(|v| v.as_str())
.ok_or("missing 'path' parameter")?;
let content = params
.get("content")
.and_then(|v| v.as_str())
.ok_or("missing 'content' parameter")?;
let append = params
.get("append")
.and_then(|v| v.as_bool())
.unwrap_or(false);
let full_path = resolve_path(path)?;
if let Some(parent) = full_path.parent() {
fs::create_dir_all(parent)
.map_err(|e| format!("failed to create parent dir '{}': {e}", parent.display()))?;
}
if append {
use std::io::Write;
let mut file = fs::OpenOptions::new()
.create(true)
.append(true)
.open(&full_path)
.map_err(|e| format!("failed to open file '{}': {e}", full_path.display()))?;
file.write_all(content.as_bytes())
.map_err(|e| format!("failed to append file '{}': {e}", full_path.display()))?;
} else {
fs::write(&full_path, content)
.map_err(|e| format!("failed to write file '{}': {e}", full_path.display()))?;
}
Ok(json!({
"path": full_path.display().to_string(),
"bytes_written": content.len(),
"append": append,
}))
}
fn exec_edit_file(params: &Value) -> Result<Value, String> {
let path = params
.get("path")
.and_then(|v| v.as_str())
.ok_or("missing 'path' parameter")?;
let old_text = params
.get("old_text")
.and_then(|v| v.as_str())
.ok_or("missing 'old_text' parameter")?;
let new_text = params
.get("new_text")
.and_then(|v| v.as_str())
.ok_or("missing 'new_text' parameter")?;
let full_path = resolve_path(path)?;
let content = fs::read_to_string(&full_path)
.map_err(|e| format!("failed to read file '{}': {e}", full_path.display()))?;
let count = content.matches(old_text).count();
if count == 0 {
return Err(format!("old_text not found in '{}'", full_path.display()));
}
if count > 1 {
return Err(format!(
"old_text found {count} times in '{}' and must match uniquely",
full_path.display()
));
}
let new_content = content.replacen(old_text, new_text, 1);
fs::write(&full_path, new_content)
.map_err(|e| format!("failed to write file '{}': {e}", full_path.display()))?;
Ok(json!({
"edited": full_path.display().to_string(),
"diff_summary": format!(
"replaced {} lines with {} lines",
old_text.lines().count(),
new_text.lines().count()
),
}))
}
fn exec_list_dir(params: &Value) -> Result<Value, String> {
let path = params.get("path").and_then(|v| v.as_str()).unwrap_or(".");
let full_path = resolve_path(path)?;
let mut entries = Vec::new();
let read_dir = fs::read_dir(&full_path)
.map_err(|e| format!("failed to read dir '{}': {e}", full_path.display()))?;
for entry in read_dir {
let entry = entry.map_err(|e| format!("failed to read dir entry: {e}"))?;
let file_name = entry.file_name().to_string_lossy().to_string();
if should_skip_name(&file_name) {
continue;
}
let metadata = entry
.metadata()
.map_err(|e| format!("failed to read metadata for '{}': {e}", file_name))?;
entries.push(json!({
"name": file_name,
"path": entry.path().display().to_string(),
"is_dir": metadata.is_dir(),
"size_bytes": if metadata.is_file() { Some(metadata.len()) } else { None::<u64> },
}));
}
Ok(json!({
"path": full_path.display().to_string(),
"entries": entries,
}))
}
fn exec_find_files(params: &Value) -> Result<Value, String> {
let pattern = params
.get("pattern")
.and_then(|v| v.as_str())
.ok_or("missing 'pattern' parameter")?;
let root = params.get("path").and_then(|v| v.as_str()).unwrap_or(".");
let max_results = params
.get("max_results")
.and_then(|v| v.as_u64())
.unwrap_or(50) as usize;
let root_path = resolve_path(root)?;
let matcher = glob_to_regex(pattern)?;
let mut files = Vec::new();
walk_files(&root_path, &mut |path| {
if files.len() >= max_results {
return;
}
if let Some(name) = path.file_name().and_then(|v| v.to_str()) {
if matcher.is_match(name) {
files.push(path.display().to_string());
}
}
})?;
Ok(json!({
"files": files,
"count": files.len(),
"truncated": files.len() >= max_results,
}))
}
fn exec_grep_files(params: &Value) -> Result<Value, String> {
let pattern = params
.get("pattern")
.and_then(|v| v.as_str())
.ok_or("missing 'pattern' parameter")?;
let root = params.get("path").and_then(|v| v.as_str()).unwrap_or(".");
let max_results = params
.get("max_results")
.and_then(|v| v.as_u64())
.unwrap_or(50) as usize;
let root_path = resolve_path(root)?;
let regex = Regex::new(pattern).map_err(|e| format!("invalid regex pattern: {e}"))?;
let mut matches = Vec::new();
walk_files(&root_path, &mut |path| {
if matches.len() >= max_results || !is_text_file(path) {
return;
}
let Ok(content) = fs::read_to_string(path) else {
return;
};
if content.len() > MAX_FILE_BYTES {
return;
}
for (idx, line) in content.lines().enumerate() {
if regex.is_match(line) {
matches.push(json!({
"path": path.display().to_string(),
"line": idx + 1,
"text": line,
}));
if matches.len() >= max_results {
break;
}
}
}
})?;
Ok(json!({
"matches": matches,
"count": matches.len(),
"truncated": matches.len() >= max_results,
}))
}
fn exec_calculate(params: &Value) -> Result<Value, String> {
let expression = params
.get("expression")
.and_then(|v| v.as_str())
.ok_or("missing 'expression' parameter")?;
let result =
meval::eval_str(expression).map_err(|e| format!("failed to evaluate expression: {e}"))?;
Ok(json!({ "result": result }))
}
fn should_skip_name(name: &str) -> bool {
name.starts_with('.') || matches!(name, "node_modules" | "__pycache__" | "target")
}
fn is_text_file(path: &Path) -> bool {
matches!(
path.extension().and_then(|v| v.to_str()),
Some(
"c" | "cc"
| "cpp"
| "cs"
| "css"
| "go"
| "h"
| "html"
| "ini"
| "java"
| "js"
| "json"
| "jsx"
| "kt"
| "md"
| "py"
| "rb"
| "rs"
| "sh"
| "sql"
| "toml"
| "ts"
| "tsx"
| "txt"
| "xml"
| "yaml"
| "yml"
)
)
}
fn walk_files(root: &Path, visit: &mut dyn FnMut(&Path)) -> Result<(), String> {
if root.is_file() {
visit(root);
return Ok(());
}
let read_dir =
fs::read_dir(root).map_err(|e| format!("failed to read dir '{}': {e}", root.display()))?;
for entry in read_dir {
let entry = entry.map_err(|e| format!("failed to read dir entry: {e}"))?;
let path = entry.path();
let file_name = entry.file_name().to_string_lossy().to_string();
if should_skip_name(&file_name) {
continue;
}
let metadata = entry
.metadata()
.map_err(|e| format!("failed to read metadata for '{}': {e}", path.display()))?;
if metadata.is_dir() {
walk_files(&path, visit)?;
} else if metadata.is_file() {
visit(&path);
}
}
Ok(())
}
fn glob_to_regex(pattern: &str) -> Result<Regex, String> {
let mut escaped = String::from("^");
for ch in pattern.chars() {
match ch {
'*' => escaped.push_str(".*"),
'?' => escaped.push('.'),
_ => escaped.push_str(®ex::escape(&ch.to_string())),
}
}
escaped.push('$');
Regex::new(&escaped).map_err(|e| format!("invalid glob pattern: {e}"))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn glob_patterns_match_file_names() {
let regex = glob_to_regex("*.rs").unwrap();
assert!(regex.is_match("lib.rs"));
assert!(!regex.is_match("lib.ts"));
}
}