initial search implemented to find file containing pattern

Author: gcclinux

images/menu-guide.png

@@ -220,6 +220,71 @@ func (f *AgenticCodeFixer) IsFixRequest(message string) FixDetectionResult {
 	}
 }
 
+// IsSearchRequest determines if a user message is asking to find or search for a file
+func (f *AgenticCodeFixer) IsSearchRequest(message string) bool {
+	lowerMsg := strings.ToLower(strings.TrimSpace(message))
+
+	searchPrefixes := []string{
+		"/search ",
+		"/find ",
+		"find where ",
+		"where do i ",
+		"where can i ",
+		"search for ",
+		"where is ",
+		"find file ",
+		"how to find ",
+		"which file ",
+		"locate file ",
+		"what file ",
+	}
+
+	for _, prefix := range searchPrefixes {
+		if strings.HasPrefix(lowerMsg, prefix) {
+			return true
+		}
+	}
+
+	if strings.Contains(lowerMsg, "find where") || strings.Contains(lowerMsg, "where is") || strings.Contains(lowerMsg, "which file") || strings.Contains(lowerMsg, "locate file") || strings.Contains(lowerMsg, "what file") {
+		return true
+	}
+
+	return false
+}
+
+// ExtractSearchTerms uses the AI model to extract search term variations from a natural language request
+func (f *AgenticCodeFixer) ExtractSearchTerms(message string) ([]string, error) {
+	prompt := fmt.Sprintf("Analyze the following user request to find a specific file or code snippet.\n\nUser Request: %q\n\nExtract a comma-separated list of search queries to try, ordered from most specific to least specific. Include base variations of words (e.g., 'tokenized' -> 'token', 'prefixes' -> 'prefix') and synonyms. Output ONLY the raw comma-separated list without quotes, explanations, or markdown. Example: tokenized search pattern, token search pattern, search pattern, token, search", message)
+
+	responseChan, err := f.aiClient.Generate(prompt, f.model, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var termBuilder strings.Builder
+	for chunk := range responseChan {
+		termBuilder.WriteString(chunk)
+	}
+
+	termString := strings.TrimSpace(termBuilder.String())
+	termString = strings.Trim(termString, "\"'`")
+
+	rawTerms := strings.Split(termString, ",")
+	var terms []string
+	for _, t := range rawTerms {
+		t = strings.TrimSpace(t)
+		if t != "" {
+			terms = append(terms, t)
+		}
+	}
+
+	if len(terms) == 0 {
+		return nil, fmt.Errorf("no search terms generated")
+	}
+
+	return terms, nil
+}
+
 // BuildPrompt constructs a structured prompt for the AI model
 // It combines the user's request with file context and provides clear instructions
 // for generating code fixes.

internal/agentic/fixer.go

@@ -264,6 +264,121 @@ func (fm *FileManager) ListFiles() ([]string, error) {
 	return files, nil
 }
 
+// SearchFilesContent searches for text within the workspace, trying multiple search terms in order of specificity.
+func (fm *FileManager) SearchFilesContent(searchTerms []string) ([]string, error) {
+	var exactResults []string
+	var tokenResults []string
+
+	var lowerTerms []string
+	var tokenSets [][]string
+
+	for _, term := range searchTerms {
+		lower := strings.ToLower(term)
+		lowerTerms = append(lowerTerms, lower)
+
+		// Clean up tokens by removing common delimiters
+		cleanTerm := lower
+		cleanTerm = strings.ReplaceAll(cleanTerm, "_", " ")
+		cleanTerm = strings.ReplaceAll(cleanTerm, "-", " ")
+		cleanTerm = strings.ReplaceAll(cleanTerm, ".", " ")
+		tokens := strings.Fields(cleanTerm)
+		if len(tokens) > 0 {
+			tokenSets = append(tokenSets, tokens)
+		}
+	}
+
+	// Extensions to exclude
+	excludedExts := map[string]bool{
+		".ico": true, ".png": true, ".jpg": true, ".jpeg": true, ".bmp": true,
+		".gif": true, ".svg": true, ".webp": true, ".exe": true, ".dll": true,
+		".pdf": true, ".zip": true, ".tar": true, ".gz": true, ".bin": true,
+		".so": true, ".dylib": true, ".class": true, ".obj": true, ".o": true,
+	}
+
+	err := filepath.Walk(fm.workspaceDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Skip directories and hidden files/folders
+		if info.IsDir() {
+			name := filepath.Base(path)
+			// Skip hidden dirs, node_modules, vendor etc. to speed up search
+			if name[0] == '.' || name == "node_modules" || name == "vendor" || name == ".git" {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		// Skip hidden files
+		if filepath.Base(path)[0] == '.' {
+			return nil
+		}
+
+		// Skip excluded file types
+		ext := strings.ToLower(filepath.Ext(path))
+		if excludedExts[ext] {
+			return nil
+		}
+
+		// Skip large files (> 1MB)
+		if info.Size() > 1024*1024 {
+			return nil
+		}
+
+		content, err := os.ReadFile(path)
+		if err != nil {
+			return nil
+		}
+
+		lowerContent := strings.ToLower(string(content))
+		relPath, err := filepath.Rel(fm.workspaceDir, path)
+		if err != nil {
+			return nil
+		}
+
+		// 1. Exact Match on any term
+		matchedExact := false
+		for _, term := range lowerTerms {
+			if strings.Contains(lowerContent, term) {
+				exactResults = append(exactResults, relPath)
+				matchedExact = true
+				break
+			}
+		}
+
+		if matchedExact {
+			return nil
+		}
+
+		// 2. Tokenized/Fuzzy match on any token set (fallback)
+		for _, tokens := range tokenSets {
+			allMatched := true
+			for _, token := range tokens {
+				if !strings.Contains(lowerContent, token) {
+					allMatched = false
+					break
+				}
+			}
+			if allMatched {
+				tokenResults = append(tokenResults, relPath)
+				break
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to search files: %w", err)
+	}
+
+	if len(exactResults) > 0 {
+		return exactResults, nil
+	}
+	return tokenResults, nil
+}
+
 // ListDirectories returns a list of subdirectories in the given directory
 func (fm *FileManager) ListDirectories(dirPath string) ([]string, error) {
 	entries, err := os.ReadDir(dirPath)

internal/filemanager/filemanager.go

@@ -545,6 +545,39 @@ func (a *App) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 		return a, nil
 
+	case SearchCompleteMsg:
+		a.aiPane.streaming = false
+		if len(msg.Results) > 0 {
+			// Open the first matching file
+			fullPath := filepath.Join(a.config.WorkspaceDir, msg.Results[0])
+			err := a.editorPane.LoadFile(fullPath)
+			if err != nil {
+				a.statusMessage = "Error opening found file: " + err.Error()
+				a.aiPane.DisplayNotification("Found matches for '" + msg.SearchTerm + "', but failed to open " + msg.Results[0])
+			} else {
+				a.statusMessage = "Opened: " + msg.Results[0]
+				a.aiPane.SetWorkingDir(filepath.Dir(a.editorPane.currentFile.Filepath))
+
+				// Switch to editor pane
+				a.activePane = types.EditorPaneType
+				a.editorPane.focused = true
+				a.aiPane.focused = false
+
+				var chatMsg strings.Builder
+				chatMsg.WriteString(fmt.Sprintf("🔍 Found '%s' in %d file(s):\n", msg.SearchTerm, len(msg.Results)))
+				for i, res := range msg.Results {
+					if i >= 5 {
+						chatMsg.WriteString(fmt.Sprintf("- ... and %d more\n", len(msg.Results)-5))
+						break
+					}
+					chatMsg.WriteString("- " + res + "\n")
+				}
+				chatMsg.WriteString("\nOpening the first match: " + msg.Results[0])
+				a.aiPane.DisplayNotification(chatMsg.String())
+			}
+		}
+		return a, nil
+
 	case TerminalOutputMsg, TerminalDoneMsg, AIResponseMsg, AINotificationMsg, AIAvailabilityMsg, ClearStatusMsg:
 		// Handle ClearStatusMsg
 		if _, ok := msg.(ClearStatusMsg); ok {
@@ -2138,6 +2171,53 @@ func (a *App) handleAIMessage(message string) tea.Cmd {
 		cleanMessage = strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(message), "/preview"))
 	}
 
+	// Check if this is a search request
+	isSearch := a.agenticFixer.IsSearchRequest(cleanMessage)
+	if isSearch {
+		a.aiPane.AddFixRequest(message, filePath)
+		a.aiPane.streaming = true
+
+		return func() tea.Msg {
+			// Extract search terms using AI
+			terms, err := a.agenticFixer.ExtractSearchTerms(cleanMessage)
+			if err != nil || len(terms) == 0 {
+				return AgenticFixResultMsg{
+					Result: &agentic.FixResult{
+						Success:          false,
+						ErrorMessage:     "Could not extract search terms.",
+						IsConversational: false,
+					},
+				}
+			}
+
+			results, err := a.fileManager.SearchFilesContent(terms)
+			if err != nil {
+				return AgenticFixResultMsg{
+					Result: &agentic.FixResult{
+						Success:          false,
+						ErrorMessage:     "Search failed: " + err.Error(),
+						IsConversational: false,
+					},
+				}
+			}
+
+			if len(results) == 0 {
+				return AgenticFixResultMsg{
+					Result: &agentic.FixResult{
+						Success:          false,
+						ErrorMessage:     "No files found containing variations of: " + terms[0],
+						IsConversational: false,
+					},
+				}
+			}
+
+			return SearchCompleteMsg{
+				SearchTerm: strings.Join(terms, ", "),
+				Results:    results,
+			}
+		}
+	}
+
 	isFixDetection := a.agenticFixer.IsFixRequest(cleanMessage)
 
 	// Step 3: Handle conversational mode immediately

internal/ui/app.go

@@ -12,3 +12,9 @@ type WindowSizeMsg = tea.WindowSizeMsg
 type AgenticFixResultMsg struct {
 	Result *agentic.FixResult
 }
+
+// SearchCompleteMsg is sent when a workspace search completes.
+type SearchCompleteMsg struct {
+	SearchTerm string
+	Results    []string
+}