fix: Implement missing FileSearch tool methods

- Remove unused imports (io/fs, os, path/filepath)
- Implement executeFileSearchTool method with regex pattern matching
- Implement validateFileSearchTool method with pattern validation
- Add helper methods for file search functionality
- Follow existing tool patterns for consistency
- Respect security exclusions and file size limits

Co-authored-by: Eden Reich <edenreich@users.noreply.github.com>

Author: claude[bot]

internal/services/tool.go

@@ -3,7 +3,6 @@ package services
 import (
 	"context"
 	"fmt"
-	"io/fs"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -680,3 +679,259 @@ func (s *LLMToolService) validateWebSearchTool(args map[string]interface{}) erro
 
 	return nil
 }
+
+// executeFileSearchTool handles FileSearch tool execution
+func (s *LLMToolService) executeFileSearchTool(args map[string]interface{}) (*domain.ToolExecutionResult, error) {
+	start := time.Now()
+	pattern, ok := args["pattern"].(string)
+	if !ok {
+		return &domain.ToolExecutionResult{
+			ToolName:  "FileSearch",
+			Arguments: args,
+			Success:   false,
+			Duration:  time.Since(start),
+			Error:     "pattern parameter is required and must be a string",
+		}, nil
+	}
+
+	// Get optional parameters with defaults
+	includeDirs := false
+	if includeDirsVal, ok := args["include_dirs"].(bool); ok {
+		includeDirs = includeDirsVal
+	}
+
+	caseSensitive := true
+	if caseSensitiveVal, ok := args["case_sensitive"].(bool); ok {
+		caseSensitive = caseSensitiveVal
+	}
+
+	searchResult, err := s.searchFiles(pattern, includeDirs, caseSensitive)
+	success := err == nil
+
+	result := &domain.ToolExecutionResult{
+		ToolName:  "FileSearch",
+		Arguments: args,
+		Success:   success,
+		Duration:  time.Since(start),
+		Data:      searchResult,
+	}
+
+	if err != nil {
+		result.Error = err.Error()
+	}
+
+	return result, nil
+}
+
+// validateFileSearchTool validates FileSearch tool arguments
+func (s *LLMToolService) validateFileSearchTool(args map[string]interface{}) error {
+	pattern, ok := args["pattern"].(string)
+	if !ok {
+		return fmt.Errorf("pattern parameter is required and must be a string")
+	}
+
+	if strings.TrimSpace(pattern) == "" {
+		return fmt.Errorf("pattern cannot be empty")
+	}
+
+	// Validate regex pattern
+	if _, err := regexp.Compile(pattern); err != nil {
+		return fmt.Errorf("invalid regex pattern: %w", err)
+	}
+
+	return nil
+}
+
+// searchFiles performs the actual file search using regex patterns
+func (s *LLMToolService) searchFiles(pattern string, includeDirs bool, caseSensitive bool) (*FileSearchResult, error) {
+	start := time.Now()
+
+	// Compile regex pattern with proper flags
+	var regex *regexp.Regexp
+	var err error
+	if caseSensitive {
+		regex, err = regexp.Compile(pattern)
+	} else {
+		regex, err = regexp.Compile("(?i)" + pattern)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("failed to compile regex: %w", err)
+	}
+
+	var matches []FileSearchMatch
+	cwd, err := os.Getwd()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get current directory: %w", err)
+	}
+
+	// Walk the directory tree
+	err = filepath.WalkDir(cwd, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return nil // Skip errors and continue
+		}
+
+		relPath, err := filepath.Rel(cwd, path)
+		if err != nil {
+			return nil
+		}
+
+		// Handle directories
+		if d.IsDir() {
+			return s.handleSearchDirectory(d, relPath, regex, includeDirs, &matches)
+		}
+
+		// Handle files
+		if s.shouldIncludeInSearch(d, relPath, regex) {
+			info, err := d.Info()
+			if err == nil {
+				matches = append(matches, FileSearchMatch{
+					Path:    path,
+					Size:    info.Size(),
+					IsDir:   false,
+					RelPath: relPath,
+				})
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to search files: %w", err)
+	}
+
+	return &FileSearchResult{
+		Pattern:  pattern,
+		Matches:  matches,
+		Total:    len(matches),
+		Duration: time.Since(start).String(),
+	}, nil
+}
+
+// handleSearchDirectory handles directory processing during search
+func (s *LLMToolService) handleSearchDirectory(d os.DirEntry, relPath string, regex *regexp.Regexp, includeDirs bool, matches *[]FileSearchMatch) error {
+	// Check depth limit (reuse same logic as FileService)
+	depth := strings.Count(relPath, string(filepath.Separator))
+	if depth >= 10 { // maxDepth from LocalFileService
+		return filepath.SkipDir
+	}
+
+	// Check if directory should be excluded (same logic as FileService)
+	excludeDirs := map[string]bool{
+		".git":         true,
+		".github":      true,
+		"node_modules": true,
+		".infer":       true,
+		"vendor":       true,
+		".flox":        true,
+		"dist":         true,
+		"build":        true,
+		"bin":          true,
+		".vscode":      true,
+		".idea":        true,
+	}
+
+	if excludeDirs[d.Name()] {
+		return filepath.SkipDir
+	}
+
+	if strings.HasPrefix(d.Name(), ".") && relPath != "." {
+		return filepath.SkipDir
+	}
+
+	// Check if path is excluded by configuration
+	if s.isPathExcluded(relPath) {
+		return filepath.SkipDir
+	}
+
+	// If includeDirs is true and directory name matches pattern, add it
+	if includeDirs && regex.MatchString(d.Name()) {
+		*matches = append(*matches, FileSearchMatch{
+			Path:    filepath.Join(filepath.Dir(relPath), d.Name()),
+			Size:    0, // Directories have size 0
+			IsDir:   true,
+			RelPath: relPath,
+		})
+	}
+
+	return nil
+}
+
+// shouldIncludeInSearch determines if a file should be included in search results
+func (s *LLMToolService) shouldIncludeInSearch(d os.DirEntry, relPath string, regex *regexp.Regexp) bool {
+	if !d.Type().IsRegular() {
+		return false
+	}
+
+	// Skip hidden files
+	if strings.HasPrefix(d.Name(), ".") {
+		return false
+	}
+
+	// Check if path is excluded by configuration
+	if s.isPathExcluded(relPath) {
+		return false
+	}
+
+	// Check file extension exclusions (same as FileService)
+	excludeExts := map[string]bool{
+		".exe":   true, ".bin": true, ".dll": true, ".so": true, ".dylib": true,
+		".a": true, ".o": true, ".obj": true, ".pyc": true, ".class": true,
+		".jar": true, ".war": true, ".zip": true, ".tar": true, ".gz": true,
+		".rar": true, ".7z": true, ".png": true, ".jpg": true, ".jpeg": true,
+		".gif": true, ".bmp": true, ".ico": true, ".svg": true, ".pdf": true,
+		".mov": true, ".mp4": true, ".avi": true, ".mp3": true, ".wav": true,
+	}
+
+	ext := strings.ToLower(filepath.Ext(relPath))
+	if excludeExts[ext] {
+		return false
+	}
+
+	// Check file size (same as FileService)
+	if info, err := d.Info(); err == nil && info.Size() > 100*1024 { // 100KB limit
+		return false
+	}
+
+	// Check if filename or relative path matches the regex pattern
+	return regex.MatchString(d.Name()) || regex.MatchString(relPath)
+}
+
+// isPathExcluded checks if a file path should be excluded based on configuration
+func (s *LLMToolService) isPathExcluded(path string) bool {
+	if s.config == nil {
+		return false
+	}
+
+	cleanPath := filepath.Clean(path)
+	normalizedPath := filepath.ToSlash(cleanPath)
+
+	for _, excludePattern := range s.config.Tools.ExcludePaths {
+		cleanPattern := filepath.Clean(excludePattern)
+		normalizedPattern := filepath.ToSlash(cleanPattern)
+
+		if normalizedPath == normalizedPattern {
+			return true
+		}
+
+		if strings.HasSuffix(normalizedPattern, "/*") {
+			dirPattern := strings.TrimSuffix(normalizedPattern, "/*")
+			if strings.HasPrefix(normalizedPath, dirPattern+"/") || normalizedPath == dirPattern {
+				return true
+			}
+		}
+
+		if strings.HasSuffix(normalizedPattern, "/") {
+			dirPattern := strings.TrimSuffix(normalizedPattern, "/")
+			if strings.HasPrefix(normalizedPath, dirPattern+"/") || normalizedPath == dirPattern {
+				return true
+			}
+		}
+
+		if strings.HasPrefix(normalizedPath, normalizedPattern) {
+			return true
+		}
+	}
+
+	return false
+}