zesdex/crates/zesdex-backend/src/tool/search.rs

//! Text search tools: `grep` (line matching) and `glob` (filename pattern matching).
//!
//! Both tools use `ignore::Walk` under the hood, which respects `.gitignore` and skips
//! heavy directories (`.git/`, `node_modules/`, etc.), matching what agents expect
//! when searching real codebases.
use super::resolve_path;
use super::Tool;
use super::ToolCtx;
use anyhow::{anyhow, Result};
use globset::{GlobBuilder, GlobSetBuilder};
use ignore::Walk;
use serde_json::{json, Value};
use std::fs;
use tracing;

/// Tool that recursively searches text files under a directory for a literal substring.
pub struct Grep;

impl Tool for Grep {
    fn name(&self) -> &'static str {
        "grep"
    }

    fn description(&self) -> &'static str {
        "Search for a pattern in files using recursive text search"
    }

    fn parameters(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "pattern": {
                    "type": "string",
                    "description": "Text pattern to search for"
                },
                "path": {
                    "type": "string",
                    "description": "Path to search in (relative to workspace root)"
                }
            },
            "required": ["pattern", "path"]
        })
    }

    /// Recursively walk the resolved directory and collect matching lines.
    ///
    /// Flow: extract `pattern` + `path` → `resolve_path` (workspace-scoped) → bail if
    ///       missing/not a dir → `ignore::Walk` the tree → for each file, `read_to_string`
    ///       and substring-match each line → emit `<rel_path>:<line_no>:<text>` rows.
    ///
    /// Why: `ignore::Walk` respects `.gitignore` and skips heavy dirs (e.g. `.git/`)
    /// which is what the agent expects when running in real repos.
    ///
    /// Return: "no matches found" if empty, else a header + `path:line:text` rows.
    fn run(&self, ctx: &ToolCtx, args: &Value) -> Result<String> {
        let pattern = crate::tool::arg_str(args, "pattern")?;
        let rel = crate::tool::arg_str(args, "path")?;
        let path = resolve_path(&ctx.workspaces, &rel)?;
        tracing::debug!(pattern = %pattern, path = %rel, "Grep::run invoked");
        if !path.exists() {
            anyhow::bail!("path '{rel}' does not exist");
        }
        if !path.is_dir() {
            anyhow::bail!("path '{rel}' is not a directory");
        }
        let mut results: Vec<(String, usize, String)> = Vec::new(); // (relative_path, line_no, text)
        for entry in Walk::new(&path).flatten() {
            let file_path = entry.path();
            if !file_path.is_file() {
                continue;
            }
            if let Ok(content) = fs::read_to_string(file_path) {
                for (i, line) in content.lines().enumerate() {
                    if line.contains(&pattern) {
                        let rel_path = file_path
                            .strip_prefix(&path)
                            .unwrap_or(file_path)
                            .display()
                            .to_string();
                        results.push((rel_path, i + 1, line.to_string()));
                    }
                }
            }
        }
        if results.is_empty() {
            tracing::debug!(pattern = %pattern, "Grep: no matches found");
            return Ok(format!("no matches found for '{pattern}' in {rel}"));
        }
        let output = results
            .iter()
            .map(|(f, line, text)| format!("{f}:{line}:{text}"))
            .collect::<Vec<_>>()
            .join("\n");
        tracing::debug!(count = results.len(), "Grep: matches found");
        Ok(format!("found {} matches:\n{}", results.len(), output))
    }
}

/// Tool that lists files under a directory matching a glob pattern.
pub struct Glob;

impl Tool for Glob {
    fn name(&self) -> &'static str {
        "glob"
    }

    fn description(&self) -> &'static str {
        "List files matching a glob pattern"
    }

    fn parameters(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "pattern": {
                    "type": "string",
                    "description": "Glob pattern to match files (e.g. '**/*.rs')"
                },
                "path": {
                    "type": "string",
                    "description": "Root path to search from (relative to workspace root)"
                }
            },
            "required": ["pattern", "path"]
        })
    }

    /// Walk the resolved directory and collect entries matching the glob pattern.
    ///
    /// Flow: extract pattern + path → `resolve_path` → build a `GlobSet` from the
    ///       joined absolute pattern → `ignore::Walk` the tree → keep entries that
    ///       match → sort → join with newlines, appending `/` for directories.
    ///
    /// Why: joining the workspace-relative pattern onto the resolved root lets users
    /// supply familiar glob shapes (`**/*.rs`) while the sandbox still controls the
    /// boundary.
    ///
    /// Return: sorted newline-joined matches; "no files match" sentinel if empty.
    fn run(&self, ctx: &ToolCtx, args: &Value) -> Result<String> {
        let pat_str = crate::tool::arg_str(args, "pattern")?;
        let rel = crate::tool::arg_str(args, "path")?;
        let root = resolve_path(&ctx.workspaces, &rel)?;
        tracing::debug!(pattern = %pat_str, root = %rel, "Glob::run invoked");
        if !root.exists() || !root.is_dir() {
            anyhow::bail!("path '{rel}' is not a valid directory");
        }
        let mut builder = GlobSetBuilder::new();
        let full_pattern = root.join(&pat_str).display().to_string();
        builder.add(
            GlobBuilder::new(&full_pattern)
                .build()
                .map_err(|e| anyhow!("invalid glob pattern '{pat_str}': {e}"))?,
        );
        let glob_set = builder
            .build()
            .map_err(|e| anyhow!("failed to build glob set: {e}"))?;
        let mut matches: Vec<String> = Vec::new();
        for entry in Walk::new(&root).flatten() {
            let p = entry.path();
            if glob_set.is_match(p) {
                let rel_path = p.strip_prefix(&root).unwrap_or(p).display().to_string();
                matches.push(format!("{}{}", rel_path, if p.is_dir() { "/" } else { "" }));
            }
        }
        matches.sort();
        if matches.is_empty() {
            tracing::debug!(pattern = %pat_str, "Glob: no files match");
            return Ok(format!("no files match '{pat_str}' in {rel}"));
        }
        tracing::debug!(count = matches.len(), "Glob: files matched");
        Ok(matches.join("\n"))
    }
}