Method search_files

src-tauri/src/tools/executor.rs:334–402

(&self, input: &serde_json::Value)

    }

    async fn search_files(&self, input: &serde_json::Value) -> AppResult<String> {
        let pattern_str = input["pattern"]
            .as_str()
            .ok_or_else(|| AppError::Validation("Missing 'pattern' field".to_string()))?;
        let path_str = input["path"]
            .as_str()
            .ok_or_else(|| AppError::Validation("Missing 'path' field".to_string()))?;
        let safe_path = self.validate_path(path_str)?;
        let sandbox_canonical = self.sandbox.canonicalize().map_err(AppError::from)?;
        let regex = Regex::new(pattern_str)
            .map_err(|error| AppError::Validation(format!("Invalid regex: {error}")))?;

        let mut results = Vec::new();
        let walker = WalkDir::new(&safe_path)
            .into_iter()
            .filter_entry(|e| {
                if e.file_type().is_dir() {
                    if let Some(name) = e.file_name().to_str() {
                        return !should_skip_dir(name);
                    }
                }
                true
            });

        for entry_result in walker {
            let entry = match entry_result {
                Ok(entry) => entry,
                Err(_) => continue,
            };
            if !entry.file_type().is_file() {
                continue;
            }

            let canonical = match entry.path().canonicalize() {
                Ok(canonical) => canonical,
                Err(_) => continue,
            };
            if !canonical.starts_with(&sandbox_canonical) {
                continue;
            }

            let content = match tokio::fs::read_to_string(&canonical).await {
                Ok(content) => content,
                Err(_) => continue,
            };

            for (line_index, line) in content.lines().enumerate() {
                if regex.is_match(line) {
                    let rel = canonical
                        .strip_prefix(&sandbox_canonical)
                        .map_err(|e| AppError::Internal(format!("strip_prefix failed: {e}")))?;
                    results.push(format!("{}:{}: {}", rel.display(), line_index + 1, line));
                    if results.len() >= 100 {
                        break;
                    }
                }
            }