pomera-ai-commander 0.1.0

package/tools/find_replace.py

@@ -0,0 +1,1751 @@
+"""
+Find & Replace Tool Module for Promera AI Commander
+
+This module contains all the logic and UI components for the Find & Replace functionality,
+extracted from the main application for better modularity and maintainability.
+"""
+
+import tkinter as tk
+from tkinter import ttk, messagebox
+import re
+import logging
+import time
+from typing import Optional, Tuple, Dict, Any, List
+
+# Import optimized components if available
+try:
+    from core.optimized_search_highlighter import get_search_highlighter, OptimizedSearchHighlighter, HighlightMode
+    from core.optimized_find_replace import get_find_replace_processor, OptimizedFindReplace, ProcessingMode
+    from core.search_operation_manager import get_operation_manager, SearchOperationManager, CancellationReason
+    PROGRESSIVE_SEARCH_AVAILABLE = True
+except ImportError as e:
+    PROGRESSIVE_SEARCH_AVAILABLE = False
+    print(f"Progressive search not available: {e}")
+
+# Import AI Tools if available
+try:
+    from .ai_tools import AIToolsWidget
+    AI_TOOLS_AVAILABLE = True
+except ImportError:
+    AI_TOOLS_AVAILABLE = False
+
+
+class FindReplaceWidget:
+    """
+    A comprehensive Find & Replace widget with advanced features including:
+    - Text and Regex modes
+    - Case sensitivity options
+    - Whole words, prefix, and suffix matching
+    - Progressive search and highlighting
+    - Pattern library integration
+    - History tracking
+    - Single replace and skip functionality
+    """
+    
+    def __init__(self, parent, settings_manager, logger=None, dialog_manager=None):
+        """
+        Initialize the Find & Replace widget.
+        
+        Args:
+            parent: Parent widget/window
+            settings_manager: Object that handles settings persistence
+            logger: Logger instance for debugging
+            dialog_manager: DialogManager instance for consistent dialog handling
+        """
+        self.parent = parent
+        self.settings_manager = settings_manager
+        self.logger = logger or logging.getLogger(__name__)
+        self.dialog_manager = dialog_manager
+        
+        # Initialize optimized components if available
+        if PROGRESSIVE_SEARCH_AVAILABLE:
+            self.search_highlighter = get_search_highlighter()
+            self.find_replace_processor = get_find_replace_processor()
+            self.operation_manager = get_operation_manager()
+            self.active_search_operations = {}
+        else:
+            self.search_highlighter = None
+            self.find_replace_processor = None
+            self.operation_manager = None
+            self.active_search_operations = {}
+        
+        # Internal state
+        self._regex_cache = {}
+        self._regex_cache_max_size = 100  # Limit cache size
+        self.current_match_index = 0
+        self.current_matches = []
+        self.input_matches = []
+        self.replaced_count = 0
+        self.skipped_matches = set()
+        self.all_matches_processed = False
+        self.loop_start_position = None
+        self.undo_stack = []  # For undo functionality
+        self.max_undo_stack = 10  # Limit undo history
+        
+        # UI components (will be created by create_widgets)
+        self.find_text_field = None
+        self.replace_text_field = None
+        self.match_count_label = None
+        self.replaced_count_label = None
+        self.regex_mode_var = None
+        self.match_case_var = None
+        self.fr_option_var = None
+        self.option_radiobuttons = {}
+        self.pattern_library_button = None
+    
+    def _show_info(self, title, message, category="success"):
+        """Show info dialog using DialogManager if available, otherwise use messagebox."""
+        if self.dialog_manager:
+            return self.dialog_manager.show_info(title, message, category, parent=self.parent)
+        else:
+            messagebox.showinfo(title, message, parent=self.parent)
+            return True
+    
+    def _show_warning(self, title, message, category="warning"):
+        """Show warning dialog using DialogManager if available, otherwise use messagebox."""
+        if self.dialog_manager:
+            return self.dialog_manager.show_warning(title, message, category, parent=self.parent)
+        else:
+            messagebox.showwarning(title, message, parent=self.parent)
+            return True
+        
+    def create_widgets(self, parent_frame, settings: Dict[str, Any]):
+        """
+        Creates the Find & Replace UI widgets.
+        
+        Args:
+            parent_frame: Parent frame to contain the widgets
+            settings: Current tool settings
+        """
+        # Left side controls frame (under Input)
+        left_frame = ttk.Frame(parent_frame)
+        left_frame.pack(side=tk.LEFT, fill=tk.Y, padx=5)
+        
+        # Options frame (middle)
+        options_frame = ttk.Frame(parent_frame)
+        options_frame.pack(side=tk.LEFT, fill=tk.Y, padx=5)
+        
+        # Right side controls frame (right of Options)
+        right_frame = ttk.Frame(parent_frame)
+        right_frame.pack(side=tk.LEFT, fill=tk.Y, padx=5)
+
+        self.match_count_label = ttk.Label(left_frame, text="Found matches: 0")
+        self.match_count_label.pack(anchor="w")
+
+        # Find field with history button (left side)
+        find_frame = ttk.Frame(left_frame)
+        find_frame.pack(fill=tk.X, pady=2)
+        ttk.Label(find_frame, text="Find:").pack(side=tk.LEFT)
+        find_input_frame = ttk.Frame(find_frame)
+        find_input_frame.pack(side=tk.LEFT, expand=True, fill=tk.X)
+        self.find_text_field = tk.Entry(find_input_frame, width=30)
+        self.find_text_field.insert(0, settings.get("find", ""))
+        self.find_text_field.pack(side=tk.LEFT, expand=True, fill=tk.X)
+        self.find_text_field.bind('<KeyRelease>', self._on_find_text_change)
+        ttk.Button(find_input_frame, text="History", command=self.show_find_history, width=8).pack(side=tk.RIGHT, padx=(2,0))
+
+        # Buttons under Find field (left side)
+        find_buttons_frame = ttk.Frame(left_frame)
+        find_buttons_frame.pack(fill=tk.X, pady=2)
+        ttk.Button(find_buttons_frame, text="Find All", command=self.preview_find_replace).pack(side=tk.LEFT, padx=5)
+        ttk.Button(find_buttons_frame, text="Previous", command=self.find_previous).pack(side=tk.LEFT, padx=5)
+        ttk.Button(find_buttons_frame, text="Next", command=self.find_next).pack(side=tk.LEFT, padx=5)
+
+        # Regex mode checkbox below Search button (left side)
+        self.regex_mode_var = tk.BooleanVar(value=settings.get("mode", "Text") == "Regex")
+        regex_checkbox = ttk.Checkbutton(left_frame, text="Regex mode", variable=self.regex_mode_var, command=self.on_regex_mode_change)
+        regex_checkbox.pack(anchor="w", pady=(2,5))
+        
+        # Pattern Library button below Regex mode checkbox
+        self.pattern_library_button = ttk.Button(left_frame, text="Pattern Library", command=self.show_pattern_library)
+        self.pattern_library_button.pack(anchor="w", pady=(2,5))
+        
+        # Info label for escape sequences
+        info_label = ttk.Label(left_frame, text="Tip: Use \\n \\t \\r in text mode", 
+                              font=("Arial", 8), foreground="gray")
+        info_label.pack(anchor="w", pady=(0,2))
+
+        # Options in the middle
+        ttk.Label(options_frame, text="Options:").pack(anchor="w", pady=(0,5))
+        
+        # Match case checkbox (can be combined with other options)
+        current_option = settings.get("option", "ignore_case")
+        
+        # Determine if match case is enabled
+        is_match_case = current_option == "match_case" or "_match_case" in current_option
+        self.match_case_var = tk.BooleanVar(value=is_match_case)
+        self.match_case_checkbox = ttk.Checkbutton(options_frame, text="Match case", variable=self.match_case_var, command=self.on_find_replace_option_change)
+        self.match_case_checkbox.pack(anchor="w")
+        
+        # Separator
+        ttk.Separator(options_frame, orient='horizontal').pack(fill='x', pady=5)
+        
+        # Text matching options (radio buttons)
+        # Extract base option (remove case sensitivity suffix)
+        base_option = current_option.replace("_match_case", "") if "_match_case" in current_option else current_option
+        if base_option in ["match_case", "ignore_case"]:
+            base_option = "none"
+        self.fr_option_var = tk.StringVar(value=base_option)
+        text_options = {
+            "none": "No special matching",
+            "whole_words": "Find whole words only",
+            "match_prefix": "Match prefix", 
+            "match_suffix": "Match suffix"
+        }
+        
+        self.option_radiobuttons = {}
+        for key, text in text_options.items():
+            rb = ttk.Radiobutton(options_frame, text=text, variable=self.fr_option_var, value=key, command=self.on_find_replace_option_change)
+            rb.pack(anchor="w")
+            self.option_radiobuttons[key] = rb
+
+        # Replaced matches counter (right side)
+        self.replaced_count_label = ttk.Label(right_frame, text="Replaced matches: 0")
+        self.replaced_count_label.pack(anchor="w")
+
+        # Replace field with history button (right side)
+        replace_frame = ttk.Frame(right_frame)
+        replace_frame.pack(fill=tk.X, pady=2)
+        ttk.Label(replace_frame, text="Replace:").pack(side=tk.LEFT)
+        replace_input_frame = ttk.Frame(replace_frame)
+        replace_input_frame.pack(side=tk.LEFT, expand=True, fill=tk.X)
+        self.replace_text_field = tk.Entry(replace_input_frame, width=30)
+        self.replace_text_field.insert(0, settings.get("replace", ""))
+        self.replace_text_field.pack(side=tk.LEFT, expand=True, fill=tk.X)
+        self.replace_text_field.bind('<KeyRelease>', self._on_replace_text_change)
+        ttk.Button(replace_input_frame, text="History", command=self.show_replace_history, width=8).pack(side=tk.RIGHT, padx=(2,0))
+
+        # Buttons under Replace field (right side) - Row 1
+        replace_buttons_frame = ttk.Frame(right_frame)
+        replace_buttons_frame.pack(fill=tk.X, pady=2)
+        ttk.Button(replace_buttons_frame, text="Replace All", command=self.trigger_replace_all).pack(side=tk.LEFT, padx=5)
+        ttk.Button(replace_buttons_frame, text="Replace > Find", command=self.replace_single).pack(side=tk.LEFT, padx=5)
+        ttk.Button(replace_buttons_frame, text="Skip", command=self.skip_single).pack(side=tk.LEFT, padx=5)
+        
+        # Buttons under Replace field (right side) - Row 2
+        replace_buttons_frame2 = ttk.Frame(right_frame)
+        replace_buttons_frame2.pack(fill=tk.X, pady=2)
+        self.undo_button = ttk.Button(replace_buttons_frame2, text="Undo", command=self.undo_replace_all, state="disabled")
+        self.undo_button.pack(side=tk.LEFT, padx=5)
+
+        # Initialize search state
+        self.current_match_index = 0
+        self.current_matches = []
+        self.input_matches = []
+        self.replaced_count = 0
+        self.skipped_matches = set()
+        self.all_matches_processed = False
+        self.loop_start_position = None
+        
+        # Initialize history if not exists
+        if "find_history" not in settings:
+            settings["find_history"] = []
+        if "replace_history" not in settings:
+            settings["replace_history"] = []
+        
+        # Set initial state of options based on regex mode
+        self.on_regex_mode_change()
+        
+        # Setup keyboard shortcuts
+        self._setup_keyboard_shortcuts()
+    
+    def get_settings(self) -> Dict[str, Any]:
+        """
+        Get current Find & Replace settings.
+        
+        Returns:
+            Dictionary containing current settings
+        """
+        if not self.find_text_field:
+            return {}
+            
+        settings = {
+            "find": self.find_text_field.get(),
+            "replace": self.replace_text_field.get(),
+            "mode": "Regex" if self.regex_mode_var.get() else "Text"
+        }
+        
+        # Combine case sensitivity with text matching option
+        if self.match_case_var.get():
+            if self.fr_option_var.get() == "none":
+                settings["option"] = "match_case"
+            else:
+                settings["option"] = f"{self.fr_option_var.get()}_match_case"
+        else:
+            if self.fr_option_var.get() == "none":
+                settings["option"] = "ignore_case"
+            else:
+                settings["option"] = self.fr_option_var.get()
+        
+        return settings
+    
+    def set_text_widgets(self, input_tabs, output_tabs, input_notebook, output_notebook):
+        """
+        Set the text widgets that this Find & Replace tool will operate on.
+        
+        Args:
+            input_tabs: List of input tab objects with .text attribute
+            output_tabs: List of output tab objects with .text attribute
+            input_notebook: Input notebook widget for getting current selection
+            output_notebook: Output notebook widget for getting current selection
+        """
+        self.input_tabs = input_tabs
+        self.output_tabs = output_tabs
+        self.input_notebook = input_notebook
+        self.output_notebook = output_notebook
+    
+    def _setup_keyboard_shortcuts(self):
+        """Setup keyboard shortcuts for Find & Replace operations."""
+        if not self.find_text_field or not self.replace_text_field:
+            return
+        
+        # Bind shortcuts to both find and replace fields
+        for widget in [self.find_text_field, self.replace_text_field]:
+            # F3 - Find Next
+            widget.bind('<F3>', lambda e: self.find_next())
+            # Shift+F3 - Find Previous
+            widget.bind('<Shift-F3>', lambda e: self.find_previous())
+            # Ctrl+Enter - Search/Preview
+            widget.bind('<Control-Return>', lambda e: self.preview_find_replace())
+            # Ctrl+H - Focus Replace field
+            widget.bind('<Control-h>', lambda e: self.replace_text_field.focus_set())
+            # Ctrl+F - Focus Find field
+            widget.bind('<Control-f>', lambda e: self.find_text_field.focus_set())
+            # Escape - Clear highlights
+            widget.bind('<Escape>', lambda e: self._clear_all_highlights())
+    
+    def _clear_all_highlights(self):
+        """Clear all search highlights from input and output tabs."""
+        if not self.input_tabs or not self.output_tabs:
+            return
+        
+        try:
+            active_input_tab, active_output_tab = self._get_active_tabs()
+            
+            # Clear highlights
+            active_input_tab.text.tag_remove("yellow_highlight", "1.0", tk.END)
+            active_input_tab.text.tag_remove("current_match", "1.0", tk.END)
+            active_output_tab.text.tag_remove("pink_highlight", "1.0", tk.END)
+            active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+            
+            # Reset match count
+            self.match_count_label.config(text="Found matches: 0")
+        except Exception as e:
+            self.logger.warning(f"Error clearing highlights: {e}")
+    
+    def _get_active_tabs(self) -> Tuple[Any, Any]:
+        """Get the currently active input and output tabs."""
+        try:
+            if not self.input_tabs or not self.output_tabs:
+                raise ValueError("No tabs available")
+            
+            input_selection = self.input_notebook.select()
+            output_selection = self.output_notebook.select()
+            
+            if not input_selection or not output_selection:
+                raise ValueError("No tab selected")
+            
+            active_input_tab = self.input_tabs[self.input_notebook.index(input_selection)]
+            active_output_tab = self.output_tabs[self.output_notebook.index(output_selection)]
+            return active_input_tab, active_output_tab
+        except (IndexError, ValueError, tk.TclError) as e:
+            self.logger.error(f"Error getting active tabs: {e}")
+            raise
+    
+    def _get_search_pattern(self) -> str:
+        """
+        Helper to build the regex pattern for Find & Replace.
+        
+        Returns:
+            Compiled regex pattern string
+        """
+        find_str = self.find_text_field.get().strip()
+        
+        # Process escape sequences if not in regex mode
+        if not self.regex_mode_var.get():
+            find_str = self._process_escape_sequences(find_str)
+        
+        # Determine case sensitivity and base option
+        is_case_sensitive = self.match_case_var.get()
+        base_option = self.fr_option_var.get()
+        
+        # Check cache with size limit
+        cache_key = (find_str, base_option, is_case_sensitive, self.regex_mode_var.get())
+        if cache_key in self._regex_cache:
+            return self._regex_cache[cache_key]
+        
+        # Clear cache if it's too large
+        if len(self._regex_cache) >= self._regex_cache_max_size:
+            # Remove oldest entries (simple FIFO)
+            keys_to_remove = list(self._regex_cache.keys())[:self._regex_cache_max_size // 2]
+            for key in keys_to_remove:
+                del self._regex_cache[key]
+        
+        if self.regex_mode_var.get():
+            pattern = find_str
+        else:
+            search_term = re.escape(find_str)
+            if base_option == "whole_words": 
+                search_term = r'\b' + search_term + r'\b'
+            elif base_option == "match_prefix": 
+                search_term = r'\b' + search_term
+            elif base_option == "match_suffix": 
+                search_term = search_term + r'\b'
+            pattern = search_term
+        
+        self._regex_cache[cache_key] = pattern
+        return pattern
+    
+    def _process_escape_sequences(self, text: str) -> str:
+        """Process escape sequences like \\n, \\t, \\r in text mode."""
+        # Only process if the text contains backslash
+        if '\\' not in text:
+            return text
+        
+        # Replace common escape sequences
+        replacements = {
+            '\\n': '\n',
+            '\\t': '\t',
+            '\\r': '\r',
+            '\\\\': '\\',
+        }
+        
+        result = text
+        for escape, char in replacements.items():
+            result = result.replace(escape, char)
+        
+        return result
+
+    def preview_find_replace(self):
+        """Highlights matches in input and output without replacing using progressive search."""
+        if not self.input_tabs or not self.output_tabs:
+            self.logger.warning("Text widgets not set for Find & Replace")
+            return
+            
+        active_input_tab, active_output_tab = self._get_active_tabs()
+
+        # Reset replacement count and skip tracking when starting new search
+        self.replaced_count = 0
+        self.replaced_count_label.config(text="Replaced matches: 0")
+        self.skipped_matches = set()
+        self.all_matches_processed = False
+        self.loop_start_position = None
+
+        # Clear existing highlights
+        if PROGRESSIVE_SEARCH_AVAILABLE and self.search_highlighter:
+            self.search_highlighter.clear_highlights(active_input_tab.text, "yellow_highlight")
+            self.search_highlighter.clear_highlights(active_output_tab.text, "pink_highlight")
+        else:
+            active_input_tab.text.tag_remove("yellow_highlight", "1.0", tk.END)
+            active_output_tab.text.tag_remove("pink_highlight", "1.0", tk.END)
+        
+        active_output_tab.text.config(state="normal")
+        input_content = active_input_tab.text.get("1.0", tk.END)
+        active_output_tab.text.delete("1.0", tk.END)
+        active_output_tab.text.insert("1.0", input_content)
+
+        find_str = self.find_text_field.get()
+        if not find_str:
+            active_output_tab.text.config(state="disabled")
+            self.match_count_label.config(text="Found matches: 0")
+            return
+        
+        # Use progressive search if available
+        if PROGRESSIVE_SEARCH_AVAILABLE and self.search_highlighter and self.find_replace_processor:
+            self._preview_with_progressive_search(active_input_tab, active_output_tab, find_str)
+        else:
+            self._preview_with_basic_search(active_input_tab, active_output_tab, find_str)
+        
+        active_output_tab.text.config(state="disabled")
+    
+    def _preview_with_progressive_search(self, input_tab, output_tab, find_str):
+        """Use progressive search for preview highlighting."""
+        pattern = self._get_search_pattern()
+        replace_str = self.replace_text_field.get()
+        case_sensitive = self.match_case_var.get()
+        use_regex = True  # Always use regex since we generate regex patterns
+        
+        # Cancel any existing operations for these widgets
+        self.operation_manager.cancel_widget_operations(input_tab.text)
+        self.operation_manager.cancel_widget_operations(output_tab.text)
+        
+        # Progress callback for updating match count
+        def progress_callback(operation):
+            if hasattr(operation, 'progress') and hasattr(operation.progress, 'matches_found'):
+                self.match_count_label.config(text=f"Found matches: {operation.progress.matches_found}")
+        
+        # Completion callback
+        def completion_callback(operation):
+            if hasattr(operation, 'matches'):
+                self.match_count_label.config(text=f"Found matches: {len(operation.matches)}")
+        
+        # Error callback
+        def error_callback(operation, error_msg):
+            self.logger.error(f"Progressive search error: {error_msg}")
+            self.match_count_label.config(text="Search Error")
+        
+        try:
+            # Start progressive highlighting for input (find matches)
+            input_op_id = self.search_highlighter.search_and_highlight(
+                text_widget=input_tab.text,
+                pattern=pattern,
+                tag_name="yellow_highlight",
+                mode=HighlightMode.PROGRESSIVE,
+                flags=0 if case_sensitive else re.IGNORECASE,
+                progress_callback=progress_callback,
+                completion_callback=completion_callback
+            )
+            
+            # Generate preview with find/replace processor
+            if replace_str:
+                preview_op_id = self.find_replace_processor.generate_preview(
+                    text_widget=output_tab.text,
+                    find_pattern=pattern,
+                    replace_text=replace_str,
+                    case_sensitive=case_sensitive,
+                    use_regex=use_regex,
+                    progress_callback=progress_callback
+                )
+                
+                # Track operations
+                self.active_search_operations[input_op_id] = 'input_highlight'
+                self.active_search_operations[preview_op_id] = 'preview_generation'
+            else:
+                # Just highlight matches in output too
+                output_op_id = self.search_highlighter.search_and_highlight(
+                    text_widget=output_tab.text,
+                    pattern=pattern,
+                    tag_name="pink_highlight",
+                    mode=HighlightMode.PROGRESSIVE,
+                    flags=0 if case_sensitive else re.IGNORECASE
+                )
+                
+                self.active_search_operations[input_op_id] = 'input_highlight'
+                self.active_search_operations[output_op_id] = 'output_highlight'
+                
+        except Exception as e:
+            self.logger.error(f"Error starting progressive search: {e}")
+            self._preview_with_basic_search(input_tab, output_tab, find_str)
+    
+    def _preview_with_basic_search(self, input_tab, output_tab, find_str):
+        """Fallback to basic search for preview highlighting."""
+        pattern = self._get_search_pattern()
+        flags = 0 if self.match_case_var.get() else re.IGNORECASE
+
+        match_count = 0
+        try:
+            input_content = input_tab.text.get("1.0", tk.END)
+            
+            for match in re.finditer(pattern, input_content, flags):
+                start, end = match.span()
+                input_tab.text.tag_add("yellow_highlight", f"1.0 + {start}c", f"1.0 + {end}c")
+                match_count += 1
+
+            for match in re.finditer(pattern, output_tab.text.get("1.0", tk.END), flags):
+                start, end = match.span()
+                output_tab.text.tag_add("pink_highlight", f"1.0 + {start}c", f"1.0 + {end}c")
+                
+        except re.error as e:
+            self.logger.error(f"Regex error in preview: {e}")
+            match_count = "Regex Error"
+            # Show helpful error message
+            error_msg = self._get_regex_error_help(str(e))
+            self._show_warning("Regex Error", f"Invalid regular expression:\n\n{e}\n\n{error_msg}")
+
+        self.match_count_label.config(text=f"Found matches: {match_count}")
+    
+    def _get_regex_error_help(self, error_msg: str) -> str:
+        """Provide helpful suggestions for common regex errors."""
+        error_msg_lower = error_msg.lower()
+        
+        if "unbalanced parenthesis" in error_msg_lower or "missing )" in error_msg_lower:
+            return "Tip: Make sure all opening parentheses '(' have matching closing parentheses ')'."
+        elif "nothing to repeat" in error_msg_lower:
+            return "Tip: Quantifiers like *, +, ? must follow a character or group. Use \\* to match a literal asterisk."
+        elif "bad escape" in error_msg_lower:
+            return "Tip: Invalid escape sequence. Use \\\\ for a literal backslash."
+        elif "unterminated character set" in error_msg_lower or "missing ]" in error_msg_lower:
+            return "Tip: Character sets must be closed with ']'. Use \\[ to match a literal bracket."
+        elif "bad character range" in error_msg_lower:
+            return "Tip: In character sets like [a-z], the first character must come before the second."
+        else:
+            return "Tip: Check your regex syntax. Common issues: unescaped special characters (. * + ? [ ] ( ) { } ^ $ | \\)"
+
+    def highlight_processed_results(self):
+        """Highlights input (found) and output (replaced) text after processing."""
+        if not self.input_tabs or not self.output_tabs:
+            return
+            
+        active_input_tab, active_output_tab = self._get_active_tabs()
+
+        active_input_tab.text.tag_remove("yellow_highlight", "1.0", tk.END)
+        active_output_tab.text.config(state="normal")
+        active_output_tab.text.tag_remove("pink_highlight", "1.0", tk.END)
+
+        find_str = self.find_text_field.get()
+        replace_str = self.replace_text_field.get()
+        if not find_str:
+            active_output_tab.text.config(state="disabled")
+            self.match_count_label.config(text="Found matches: 0")
+            return
+
+        pattern = self._get_search_pattern()
+        flags = 0 if self.match_case_var.get() else re.IGNORECASE
+
+        match_count = 0
+        try:
+            for match in re.finditer(pattern, active_input_tab.text.get("1.0", tk.END), flags):
+                start, end = match.span()
+                active_input_tab.text.tag_add("yellow_highlight", f"1.0 + {start}c", f"1.0 + {end}c")
+                match_count += 1
+                
+            if replace_str:
+                 for match in re.finditer(re.escape(replace_str), active_output_tab.text.get("1.0", tk.END), flags):
+                    start, end = match.span()
+                    active_output_tab.text.tag_add("pink_highlight", f"1.0 + {start}c", f"1.0 + {end}c")
+        except re.error as e:
+            self.logger.error(f"Regex error in highlight: {e}")
+            match_count = "Regex Error"
+
+        self.match_count_label.config(text=f"Found matches: {match_count}")
+        active_output_tab.text.config(state="disabled")
+
+    def find_next(self):
+        """Moves to the next match in the input text area with automatic highlighting."""
+        if not self.input_tabs or not self.output_tabs:
+            return
+            
+        active_input_tab, active_output_tab = self._get_active_tabs()
+        find_str = self.find_text_field.get()
+        
+        if not find_str:
+            return
+        
+        # First, run preview to highlight all matches
+        self.preview_find_replace()
+        
+        # Focus on input text area
+        active_input_tab.text.focus_set()
+        
+        # Get current cursor position
+        try:
+            current_pos = active_input_tab.text.index(tk.INSERT)
+        except:
+            current_pos = "1.0"
+        
+        # Search for next occurrence
+        try:
+            # Get the search pattern (handles all matching options)
+            pattern = self._get_search_pattern()
+            content = active_input_tab.text.get("1.0", tk.END)
+            flags = 0 if self.match_case_var.get() else re.IGNORECASE
+            matches = list(re.finditer(pattern, content, flags))
+                
+            if matches:
+                # Store matches for navigation
+                self.input_matches = matches
+                
+                # Find current position in characters
+                current_char = len(active_input_tab.text.get("1.0", current_pos))
+                
+                # Find next match after current position
+                next_match = None
+                next_index = 0
+                for i, match in enumerate(matches):
+                    if match.start() > current_char:
+                        next_match = match
+                        next_index = i
+                        break
+                
+                # If no match found after current position, wrap to first match
+                if not next_match:
+                    next_match = matches[0]
+                    next_index = 0
+                
+                self.current_match_index = next_index
+                
+                # Convert character position back to line.column
+                start_pos = f"1.0 + {next_match.start()}c"
+                end_pos = f"1.0 + {next_match.end()}c"
+                
+                # Clear previous selection and highlight current match
+                active_input_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+                active_input_tab.text.tag_remove("current_match", "1.0", tk.END)
+                active_input_tab.text.tag_add("current_match", start_pos, end_pos)
+                active_input_tab.text.tag_config("current_match", background="red", foreground="white")
+                active_input_tab.text.mark_set(tk.INSERT, end_pos)
+                active_input_tab.text.see(start_pos)
+                
+                # Update match count label
+                self.match_count_label.config(text=f"Found matches: {len(matches)} (current: {next_index + 1})")
+                    
+        except Exception as e:
+            self.logger.warning(f"Find next error: {e}")
+
+    def find_previous(self):
+        """Moves to the previous match in the input text area with automatic highlighting."""
+        if not self.input_tabs or not self.output_tabs:
+            return
+            
+        active_input_tab, active_output_tab = self._get_active_tabs()
+        find_str = self.find_text_field.get()
+        
+        if not find_str:
+            return
+        
+        # First, run preview to highlight all matches
+        self.preview_find_replace()
+        
+        # Focus on input text area
+        active_input_tab.text.focus_set()
+        
+        # Get current cursor position
+        try:
+            current_pos = active_input_tab.text.index(tk.INSERT)
+        except:
+            current_pos = "1.0"
+        
+        # Search for previous occurrence
+        try:
+            # Get the search pattern (handles all matching options)
+            pattern = self._get_search_pattern()
+            content = active_input_tab.text.get("1.0", tk.END)
+            flags = 0 if self.match_case_var.get() else re.IGNORECASE
+            matches = list(re.finditer(pattern, content, flags))
+            
+            if matches:
+                # Store matches for navigation
+                self.input_matches = matches
+                
+                # Find current position in characters
+                current_char = len(active_input_tab.text.get("1.0", current_pos))
+                
+                # Find previous match before current position
+                prev_match = None
+                prev_index = 0
+                for i in reversed(range(len(matches))):
+                    match = matches[i]
+                    if match.start() < current_char:
+                        prev_match = match
+                        prev_index = i
+                        break
+                
+                # If no match found before current position, wrap to last match
+                if not prev_match:
+                    prev_match = matches[-1]
+                    prev_index = len(matches) - 1
+                
+                self.current_match_index = prev_index
+                
+                # Convert character position back to line.column
+                start_pos = f"1.0 + {prev_match.start()}c"
+                end_pos = f"1.0 + {prev_match.end()}c"
+                
+                # Clear previous selection and highlight current match
+                active_input_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+                active_input_tab.text.tag_remove("current_match", "1.0", tk.END)
+                active_input_tab.text.tag_add("current_match", start_pos, end_pos)
+                active_input_tab.text.tag_config("current_match", background="red", foreground="white")
+                active_input_tab.text.mark_set(tk.INSERT, start_pos)
+                active_input_tab.text.see(start_pos)
+                
+                # Update match count label
+                self.match_count_label.config(text=f"Found matches: {len(matches)} (current: {prev_index + 1})")
+                    
+        except Exception as e:
+            self.logger.warning(f"Find previous error: {e}")
+
+    def replace_all(self) -> str:
+        """
+        Performs find and replace on all matches.
+        
+        Returns:
+            Processed text with all replacements made
+        """
+        if not self.input_tabs:
+            return ""
+            
+        active_input_tab, _ = self._get_active_tabs()
+        find_str = self.find_text_field.get().strip()
+        replace_str = self.replace_text_field.get().strip()
+        
+        input_text = active_input_tab.text.get("1.0", tk.END)
+
+        if not find_str:
+            return input_text.strip()
+        
+        # Save state for undo
+        self._save_undo_state(input_text, find_str, replace_str)
+        
+        # Reset replacement count for Replace All
+        self.replaced_count = 0
+        
+        # Add to history
+        self._add_to_history("find_history", find_str)
+        if replace_str:  # Only add to replace history if not empty
+            self._add_to_history("replace_history", replace_str)
+        
+        # Use optimized find/replace processor if available
+        if PROGRESSIVE_SEARCH_AVAILABLE and self.find_replace_processor:
+            try:
+                result = self.find_replace_processor.process_find_replace(
+                    text=input_text,
+                    find_pattern=find_str,
+                    replace_text=replace_str,
+                    mode="Regex" if self.regex_mode_var.get() else "Text",
+                    options={
+                        'ignore_case': not self.match_case_var.get(),
+                        'whole_words': self.fr_option_var.get() == "whole_words",
+                        'match_prefix': self.fr_option_var.get() == "match_prefix",
+                        'match_suffix': self.fr_option_var.get() == "match_suffix"
+                    }
+                )
+                
+                return result.processed_text if result.success else f"Find/Replace Error: {result.error_message}"
+                
+            except Exception as e:
+                self.logger.warning(f"Optimized find/replace failed, falling back to basic: {e}")
+        
+        # Fallback to basic find/replace implementation
+        is_case_sensitive = self.match_case_var.get()
+        base_option = self.fr_option_var.get()
+
+        if self.regex_mode_var.get():
+            try:
+                flags = 0 if is_case_sensitive else re.IGNORECASE
+                # Count matches before replacement
+                matches = re.findall(find_str, input_text, flags)
+                self.replaced_count += len(matches)
+                result = re.sub(find_str, replace_str, input_text, flags=flags).strip()
+                self.replaced_count_label.config(text=f"Replaced matches: {self.replaced_count}")
+                return result
+            except re.error as e:
+                return f"Regex Error: {e}"
+
+        # Handle different text matching options
+        if base_option == "whole_words":
+            # Implement whole words matching
+            flags = 0 if is_case_sensitive else re.IGNORECASE
+            pattern = r'\b' + re.escape(find_str) + r'\b'
+            try:
+                # Count matches before replacement
+                matches = re.findall(pattern, input_text, flags)
+                self.replaced_count += len(matches)
+                result = re.sub(pattern, replace_str, input_text, flags=flags).strip()
+                self.replaced_count_label.config(text=f"Replaced matches: {self.replaced_count}")
+                return result
+            except re.error as e:
+                return f"Whole words error: {e}"
+        
+        elif base_option == "match_prefix":
+            # Implement prefix matching
+            flags = 0 if is_case_sensitive else re.IGNORECASE
+            pattern = r'\b' + re.escape(find_str)
+            try:
+                # Count matches before replacement
+                matches = re.findall(pattern, input_text, flags)
+                self.replaced_count += len(matches)
+                result = re.sub(pattern, replace_str, input_text, flags=flags).strip()
+                self.replaced_count_label.config(text=f"Replaced matches: {self.replaced_count}")
+                return result
+            except re.error as e:
+                return f"Prefix match error: {e}"
+        
+        elif base_option == "match_suffix":
+            # Implement suffix matching
+            flags = 0 if is_case_sensitive else re.IGNORECASE
+            pattern = re.escape(find_str) + r'\b'
+            try:
+                # Count matches before replacement
+                matches = re.findall(pattern, input_text, flags)
+                self.replaced_count += len(matches)
+                result = re.sub(pattern, replace_str, input_text, flags=flags).strip()
+                self.replaced_count_label.config(text=f"Replaced matches: {self.replaced_count}")
+                return result
+            except re.error as e:
+                return f"Suffix match error: {e}"
+        
+        else:
+            # Simple case-sensitive or case-insensitive replacement
+            if is_case_sensitive:
+                # Count occurrences before replacement
+                count = input_text.count(find_str)
+                self.replaced_count += count
+                result = input_text.replace(find_str, replace_str).strip()
+                self.replaced_count_label.config(text=f"Replaced matches: {self.replaced_count}")
+                return result
+            else:
+                # Case-insensitive replacement
+                pattern = re.escape(find_str)
+                # Count matches before replacement
+                matches = re.findall(pattern, input_text, re.IGNORECASE)
+                self.replaced_count += len(matches)
+                result = re.sub(pattern, replace_str, input_text, flags=re.IGNORECASE).strip()
+                self.replaced_count_label.config(text=f"Replaced matches: {self.replaced_count}")
+                return result
+
+    def replace_single(self):
+        """Replaces the current match and moves to next match in the output text area."""
+        if not self.output_tabs:
+            return
+            
+        active_output_tab = self.output_tabs[self.output_notebook.index(self.output_notebook.select())]
+        find_str = self.find_text_field.get()
+        replace_str = self.replace_text_field.get()
+        
+        if not find_str:
+            return
+        
+        # Focus on output text area
+        active_output_tab.text.focus_set()
+        
+        # Enable editing
+        active_output_tab.text.config(state="normal")
+        
+        try:
+            # Get current cursor position
+            try:
+                current_pos = active_output_tab.text.index(tk.INSERT)
+            except:
+                current_pos = "1.0"
+            
+            # Find the next match from current position
+            next_match_pos = self._find_next_match_in_output(current_pos)
+            
+            if next_match_pos:
+                start_pos, end_pos = next_match_pos
+                
+                # Replace the match (handle regex replacement)
+                matched_text = active_output_tab.text.get(start_pos, end_pos)
+                
+                if self.regex_mode_var.get():
+                    # Use regex replacement with backreferences
+                    pattern = self._get_search_pattern()
+                    flags = 0 if self.match_case_var.get() else re.IGNORECASE
+                    
+                    try:
+                        # Use re.sub to handle backreferences like \1, \2, \3
+                        replacement_text = re.sub(pattern, replace_str, matched_text, count=1, flags=flags)
+                        
+                        # If no replacement happened, use literal replacement
+                        if replacement_text == matched_text:
+                            replacement_text = replace_str
+                    except re.error:
+                        # Regex error, use literal replacement
+                        replacement_text = replace_str
+                else:
+                    replacement_text = replace_str
+                
+                active_output_tab.text.delete(start_pos, end_pos)
+                active_output_tab.text.insert(start_pos, replacement_text)
+                
+                # Update replacement count
+                self.replaced_count += 1
+                self.replaced_count_label.config(text=f"Replaced matches: {self.replaced_count}")
+                
+                # Update history
+                self._add_to_history("find_history", find_str)
+                if replace_str:  # Only add to replace history if not empty
+                    self._add_to_history("replace_history", replace_str)
+                
+                # Calculate new end position after replacement
+                new_end_pos = f"{start_pos} + {len(replace_str)}c"
+                
+                # Set cursor after the replacement
+                active_output_tab.text.mark_set(tk.INSERT, new_end_pos)
+                
+                # Find and highlight the next match
+                next_next_match = self._find_next_match_in_output(new_end_pos)
+                if next_next_match:
+                    next_start, next_end = next_next_match
+                    
+                    # Clear previous highlights
+                    active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+                    active_output_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+                    
+                    # Highlight the next match
+                    active_output_tab.text.tag_add("current_match", next_start, next_end)
+                    active_output_tab.text.tag_config("current_match", background="red", foreground="white")
+                    active_output_tab.text.see(next_start)
+                    
+                    # Set cursor to the highlighted match
+                    active_output_tab.text.mark_set(tk.INSERT, next_start)
+                else:
+                    # No more matches after current position, check for looping
+                    self._handle_end_of_matches_replace()
+            else:
+                # No matches found at current position, start from beginning
+                first_match = self._find_next_match_in_output("1.0")
+                if first_match:
+                    start_pos, end_pos = first_match
+                    
+                    # Replace the match
+                    active_output_tab.text.delete(start_pos, end_pos)
+                    active_output_tab.text.insert(start_pos, replace_str)
+                    
+                    # Update replacement count
+                    self.replaced_count += 1
+                    self.replaced_count_label.config(text=f"Replaced matches: {self.replaced_count}")
+                    
+                    # Update history
+                    self._add_to_history("find_history", find_str)
+                    if replace_str:
+                        self._add_to_history("replace_history", replace_str)
+                    
+                    # Set cursor after replacement
+                    new_end_pos = f"{start_pos} + {len(replace_str)}c"
+                    active_output_tab.text.mark_set(tk.INSERT, new_end_pos)
+                    active_output_tab.text.see(start_pos)
+                    
+                    # Find and highlight the next match
+                    next_next_match = self._find_next_match_in_output(new_end_pos)
+                    if next_next_match:
+                        next_start, next_end = next_next_match
+                        
+                        # Clear previous highlights
+                        active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+                        active_output_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+                        
+                        # Highlight the next match
+                        active_output_tab.text.tag_add("current_match", next_start, next_end)
+                        active_output_tab.text.tag_config("current_match", background="red", foreground="white")
+                        active_output_tab.text.see(next_start)
+                        
+                        # Set cursor to the highlighted match
+                        active_output_tab.text.mark_set(tk.INSERT, next_start)
+                else:
+                    # No matches found at all, clear highlights
+                    active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+                    active_output_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+            
+        except Exception as e:
+            self.logger.warning(f"Replace single error: {e}")
+        finally:
+            active_output_tab.text.config(state="disabled")
+
+    def skip_single(self):
+        """Skips the current match and moves to next match in the output text area."""
+        if not self.output_tabs:
+            return
+            
+        active_output_tab = self.output_tabs[self.output_notebook.index(self.output_notebook.select())]
+        find_str = self.find_text_field.get()
+        
+        if not find_str:
+            return
+        
+        # Focus on output text area
+        active_output_tab.text.focus_set()
+        
+        try:
+            # Get current cursor position
+            try:
+                current_pos = active_output_tab.text.index(tk.INSERT)
+            except:
+                current_pos = "1.0"
+            
+            # Find the current match at cursor position
+            current_match_pos = self._find_current_match_in_output(current_pos)
+            
+            if current_match_pos:
+                start_pos, end_pos = current_match_pos
+                
+                # Add this match position to skipped matches
+                self.skipped_matches.add((start_pos, end_pos))
+                
+                # Find the next match after current position
+                next_match_pos = self._find_next_match_in_output(end_pos)
+                
+                if next_match_pos:
+                    next_start, next_end = next_match_pos
+                    
+                    # Clear previous highlights
+                    active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+                    active_output_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+                    
+                    # Highlight the next match
+                    active_output_tab.text.tag_add("current_match", next_start, next_end)
+                    active_output_tab.text.tag_config("current_match", background="yellow", foreground="black")
+                    active_output_tab.text.see(next_start)
+                    
+                    # Set cursor to the highlighted match
+                    active_output_tab.text.mark_set(tk.INSERT, next_start)
+                else:
+                    # No more matches found, check if we should loop back to beginning
+                    self._handle_end_of_matches_skip()
+            else:
+                # No current match, find the first match from current position
+                next_match_pos = self._find_next_match_in_output(current_pos)
+                if next_match_pos:
+                    next_start, next_end = next_match_pos
+                    
+                    # Clear previous highlights
+                    active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+                    active_output_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+                    
+                    # Highlight the match
+                    active_output_tab.text.tag_add("current_match", next_start, next_end)
+                    active_output_tab.text.tag_config("current_match", background="yellow", foreground="black")
+                    active_output_tab.text.see(next_start)
+                    
+                    # Set cursor to the highlighted match
+                    active_output_tab.text.mark_set(tk.INSERT, next_start)
+                    
+        except Exception as e:
+            self.logger.warning(f"Skip single error: {e}")
+
+    def _find_current_match_in_output(self, cursor_pos) -> Optional[Tuple[str, str]]:
+        """Find the match at the current cursor position in output text area."""
+        if not self.output_tabs:
+            return None
+            
+        active_output_tab = self.output_tabs[self.output_notebook.index(self.output_notebook.select())]
+        find_str = self.find_text_field.get()
+        
+        if not find_str:
+            return None
+        
+        try:
+            # Get the search pattern (handles all matching options)
+            pattern = self._get_search_pattern()
+            content = active_output_tab.text.get("1.0", tk.END)
+            flags = 0 if self.match_case_var.get() else re.IGNORECASE
+            matches = list(re.finditer(pattern, content, flags))
+            
+            if matches:
+                # Find current position in characters
+                cursor_char = len(active_output_tab.text.get("1.0", cursor_pos))
+                
+                # Find match that contains or starts at current position
+                for match in matches:
+                    if match.start() <= cursor_char <= match.end():
+                        start_pos = f"1.0 + {match.start()}c"
+                        end_pos = f"1.0 + {match.end()}c"
+                        return (start_pos, end_pos)
+                        
+        except Exception as e:
+            self.logger.warning(f"Find current match in output error: {e}")
+        
+        return None
+
+    def _find_next_match_in_output(self, from_pos) -> Optional[Tuple[str, str]]:
+        """Find the next match in output text area from given position."""
+        if not self.output_tabs:
+            return None
+            
+        active_output_tab = self.output_tabs[self.output_notebook.index(self.output_notebook.select())]
+        find_str = self.find_text_field.get()
+        
+        if not find_str:
+            return None
+        
+        try:
+            # Get the search pattern (handles all matching options)
+            pattern = self._get_search_pattern()
+            content = active_output_tab.text.get("1.0", tk.END)
+            flags = 0 if self.match_case_var.get() else re.IGNORECASE
+            matches = list(re.finditer(pattern, content, flags))
+            
+            if matches:
+                # Find current position in characters
+                from_char = len(active_output_tab.text.get("1.0", from_pos))
+                
+                # Find next match after current position
+                for match in matches:
+                    if match.start() >= from_char:
+                        start_pos = f"1.0 + {match.start()}c"
+                        end_pos = f"1.0 + {match.end()}c"
+                        return (start_pos, end_pos)
+                
+                # If no match found after current position, wrap to first match
+                if matches:
+                    match = matches[0]
+                    start_pos = f"1.0 + {match.start()}c"
+                    end_pos = f"1.0 + {match.end()}c"
+                    return (start_pos, end_pos)
+                        
+        except Exception as e:
+            self.logger.warning(f"Find next match in output error: {e}")
+        
+        return None
+
+    def _handle_end_of_matches_skip(self):
+        """Handle looping when reaching end of matches during skip operation."""
+        if not self.output_tabs:
+            return
+            
+        active_output_tab = self.output_tabs[self.output_notebook.index(self.output_notebook.select())]
+        
+        # Check if there are any unprocessed matches from the beginning
+        first_match = self._find_next_match_in_output("1.0")
+        if first_match:
+            start_pos, end_pos = first_match
+            
+            # Check if this match was already skipped
+            if (start_pos, end_pos) not in self.skipped_matches:
+                # Clear previous highlights
+                active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+                active_output_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+                
+                # Highlight the first match
+                active_output_tab.text.tag_add("current_match", start_pos, end_pos)
+                active_output_tab.text.tag_config("current_match", background="yellow", foreground="black")
+                active_output_tab.text.see(start_pos)
+                
+                # Set cursor to the highlighted match
+                active_output_tab.text.mark_set(tk.INSERT, start_pos)
+                return
+        
+        # All matches have been processed, clear highlights
+        active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+        active_output_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+
+    def _handle_end_of_matches_replace(self):
+        """Handle looping when reaching end of matches during replace operation."""
+        if not self.output_tabs:
+            return
+            
+        active_output_tab = self.output_tabs[self.output_notebook.index(self.output_notebook.select())]
+        find_str = self.find_text_field.get()
+        replace_str = self.replace_text_field.get()
+        
+        # Check if there are any matches from the beginning that haven't been replaced
+        first_match = self._find_next_match_in_output("1.0")
+        if first_match:
+            start_pos, end_pos = first_match
+            
+            # Replace the match
+            active_output_tab.text.delete(start_pos, end_pos)
+            active_output_tab.text.insert(start_pos, replace_str)
+            
+            # Update replacement count
+            self.replaced_count += 1
+            self.replaced_count_label.config(text=f"Replaced matches: {self.replaced_count}")
+            
+            # Update history
+            self._add_to_history("find_history", find_str)
+            if replace_str:
+                self._add_to_history("replace_history", replace_str)
+            
+            # Set cursor after replacement
+            new_end_pos = f"{start_pos} + {len(replace_str)}c"
+            active_output_tab.text.mark_set(tk.INSERT, new_end_pos)
+            active_output_tab.text.see(start_pos)
+            
+            # Find and highlight the next match
+            next_match = self._find_next_match_in_output(new_end_pos)
+            if next_match:
+                next_start, next_end = next_match
+                
+                # Clear previous highlights
+                active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+                active_output_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+                
+                # Highlight the next match
+                active_output_tab.text.tag_add("current_match", next_start, next_end)
+                active_output_tab.text.tag_config("current_match", background="red", foreground="white")
+                active_output_tab.text.see(next_start)
+                
+                # Set cursor to the highlighted match
+                active_output_tab.text.mark_set(tk.INSERT, next_start)
+            else:
+                # No more matches, clear highlights
+                active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+                active_output_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+        else:
+            # No matches found at all, clear highlights
+            active_output_tab.text.tag_remove("current_match", "1.0", tk.END)
+            active_output_tab.text.tag_remove(tk.SEL, "1.0", tk.END)
+
+    def show_find_history(self):
+        """Shows find history in a popup window."""
+        self._show_history_popup("Find History", "find_history", self.find_text_field)
+
+    def show_replace_history(self):
+        """Shows replace history in a popup window."""
+        self._show_history_popup("Replace History", "replace_history", self.replace_text_field)
+
+    def _show_history_popup(self, title: str, history_key: str, target_field):
+        """Generic method to show history popup."""
+        settings = self.settings_manager.get_tool_settings("Find & Replace Text")
+        history = settings.get(history_key, [])
+        
+        popup = tk.Toplevel(self.parent)
+        popup.title(title)
+        popup.geometry("400x300")
+        popup.transient(self.parent)
+        popup.grab_set()
+        
+        # Center the popup
+        popup.update_idletasks()
+        x = (popup.winfo_screenwidth() // 2) - (popup.winfo_width() // 2)
+        y = (popup.winfo_screenheight() // 2) - (popup.winfo_height() // 2)
+        popup.geometry(f"+{x}+{y}")
+        
+        # History listbox
+        frame = ttk.Frame(popup)
+        frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
+        
+        ttk.Label(frame, text=f"Last 50 {title.lower()} terms:").pack(anchor="w")
+        
+        listbox_frame = ttk.Frame(frame)
+        listbox_frame.pack(fill=tk.BOTH, expand=True, pady=(5,0))
+        
+        scrollbar = ttk.Scrollbar(listbox_frame)
+        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        
+        listbox = tk.Listbox(listbox_frame, yscrollcommand=scrollbar.set)
+        listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        scrollbar.config(command=listbox.yview)
+        
+        # Populate listbox with history (most recent first)
+        for item in reversed(history[-50:]):
+            listbox.insert(tk.END, item)
+        
+        # Buttons
+        button_frame = ttk.Frame(frame)
+        button_frame.pack(fill=tk.X, pady=(10,0))
+        
+        def use_selected():
+            selection = listbox.curselection()
+            if selection:
+                selected_text = listbox.get(selection[0])
+                target_field.delete(0, tk.END)
+                target_field.insert(0, selected_text)
+                popup.destroy()
+                self.on_setting_change()
+        
+        def clear_history():
+            settings[history_key] = []
+            self.settings_manager.save_settings()
+            listbox.delete(0, tk.END)
+        
+        ttk.Button(button_frame, text="Use Selected", command=use_selected).pack(side=tk.LEFT, padx=(0,5))
+        ttk.Button(button_frame, text="Clear History", command=clear_history).pack(side=tk.LEFT, padx=5)
+        ttk.Button(button_frame, text="Close", command=popup.destroy).pack(side=tk.RIGHT)
+        
+        # Double-click to use selected
+        listbox.bind('<Double-Button-1>', lambda e: use_selected())
+
+    def _add_to_history(self, history_key: str, value: str):
+        """Add a value to the specified history list."""
+        if not value:
+            return
+            
+        settings = self.settings_manager.get_tool_settings("Find & Replace Text")
+        history = settings.get(history_key, [])
+        
+        # Remove if already exists to avoid duplicates
+        if value in history:
+            history.remove(value)
+        
+        # Add to end (most recent)
+        history.append(value)
+        
+        # Keep only last 50 items
+        if len(history) > 50:
+            history = history[-50:]
+        
+        settings[history_key] = history
+        self.settings_manager.save_settings()
+    
+    def _save_undo_state(self, text: str, find_str: str, replace_str: str):
+        """Save current state for undo functionality."""
+        undo_entry = {
+            'text': text,
+            'find': find_str,
+            'replace': replace_str,
+            'timestamp': time.time()
+        }
+        
+        self.undo_stack.append(undo_entry)
+        
+        # Limit undo stack size
+        if len(self.undo_stack) > self.max_undo_stack:
+            self.undo_stack.pop(0)
+        
+        # Enable undo button
+        if hasattr(self, 'undo_button'):
+            self.undo_button.config(state="normal")
+    
+    def undo_replace_all(self):
+        """Undo the last Replace All operation."""
+        if not self.undo_stack:
+            self._show_info("Undo", "No Replace All operations to undo.")
+            return
+        
+        if not self.output_tabs:
+            return
+        
+        try:
+            # Get last undo state
+            undo_entry = self.undo_stack.pop()
+            
+            # Restore the text
+            active_output_tab = self.output_tabs[self.output_notebook.index(self.output_notebook.select())]
+            active_output_tab.text.config(state="normal")
+            active_output_tab.text.delete("1.0", tk.END)
+            active_output_tab.text.insert("1.0", undo_entry['text'])
+            active_output_tab.text.config(state="disabled")
+            
+            # Reset replacement count
+            self.replaced_count = 0
+            self.replaced_count_label.config(text="Replaced matches: 0")
+            
+            # Disable undo button if no more undo states
+            if not self.undo_stack and hasattr(self, 'undo_button'):
+                self.undo_button.config(state="disabled")
+            
+            self._show_info("Undo", f"Undone: Replace '{undo_entry['find']}' with '{undo_entry['replace']}'")
+        except Exception as e:
+            self.logger.error(f"Error during undo: {e}")
+            self._show_warning("Undo Error", f"Failed to undo: {e}")
+
+    def on_regex_mode_change(self):
+        """Handle changes to regex mode checkbox."""
+        if not self.option_radiobuttons:
+            return
+            
+        is_regex = self.regex_mode_var.get()
+        
+        # Disable/enable text matching options when regex mode is on/off
+        for key, rb in self.option_radiobuttons.items():
+            if key in ["whole_words", "match_prefix", "match_suffix"]:
+                if is_regex:
+                    rb.config(state="disabled")
+                else:
+                    rb.config(state="normal")
+        
+        # If regex mode is enabled and a disabled option is selected, reset to "none"
+        if is_regex and self.fr_option_var.get() in ["whole_words", "match_prefix", "match_suffix"]:
+            self.fr_option_var.set("none")
+        
+        # Enable/disable Pattern Library button based on regex mode
+        if hasattr(self, 'pattern_library_button'):
+            if is_regex:
+                self.pattern_library_button.config(state="normal")
+            else:
+                self.pattern_library_button.config(state="disabled")
+        
+        # Clear regex cache when options change
+        self._regex_cache.clear()
+        
+        # Notify parent of setting change
+        self.on_setting_change()
+        
+        # Re-run search if there's a find string
+        if hasattr(self, 'find_text_field') and self.find_text_field.get().strip():
+            self.parent.after_idle(self.preview_find_replace)
+
+    def on_find_replace_option_change(self):
+        """Handle changes to Find & Replace radio button options."""
+        # Clear regex cache when options change
+        self._regex_cache.clear()
+        
+        # Notify parent of setting change
+        self.on_setting_change()
+        
+        # Re-run search if there's a find string
+        if hasattr(self, 'find_text_field') and self.find_text_field.get().strip():
+            # Use after_idle to avoid recursion and ensure UI is updated first
+            self.parent.after_idle(self.preview_find_replace)
+
+    def _on_find_text_change(self, event=None):
+        """Handle changes to find text field."""
+        self.on_setting_change()
+
+    def _on_replace_text_change(self, event=None):
+        """Handle changes to replace text field."""
+        self.on_setting_change()
+
+    def on_setting_change(self):
+        """Notify parent that settings have changed."""
+        # This should be overridden by the parent or connected to a callback
+        pass
+    
+    def trigger_replace_all(self):
+        """Trigger the parent application's apply_tool method for Replace All functionality."""
+        # This calls the parent application's apply_tool method, which will:
+        # 1. Call _process_text_with_tool
+        # 2. Which calls self.find_replace_widget.replace_all()
+        # 3. And then update the output UI automatically
+        if hasattr(self, 'apply_tool_callback') and self.apply_tool_callback:
+            self.apply_tool_callback()
+        else:
+            # Fallback to direct replace_all if no callback is set
+            result = self.replace_all()
+            # We need to update the output manually since we're not going through the normal pipeline
+            if hasattr(self, 'output_tabs') and self.output_tabs:
+                active_output_tab = self.output_tabs[self.output_notebook.index(self.output_notebook.select())]
+                active_output_tab.text.config(state="normal")
+                active_output_tab.text.delete("1.0", tk.END)
+                active_output_tab.text.insert("1.0", result)
+                active_output_tab.text.config(state="disabled")
+
+    def show_pattern_library(self):
+        """Shows the Pattern Library window with regex patterns."""
+        # Get pattern library from settings
+        pattern_library = self.settings_manager.get_pattern_library()
+        
+        popup = tk.Toplevel(self.parent)
+        popup.title("Pattern Library")
+        popup.geometry("800x500")
+        popup.transient(self.parent)
+        popup.grab_set()
+        
+        # Center the popup
+        popup.update_idletasks()
+        x = (popup.winfo_screenwidth() // 2) - (popup.winfo_width() // 2)
+        y = (popup.winfo_screenheight() // 2) - (popup.winfo_height() // 2)
+        popup.geometry(f"+{x}+{y}")
+        
+        # Main frame
+        main_frame = ttk.Frame(popup)
+        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
+        
+        # Title
+        ttk.Label(main_frame, text="Regex Pattern Library", font=("Arial", 12, "bold")).pack(anchor="w", pady=(0,10))
+        
+        # Treeview for the table
+        tree_frame = ttk.Frame(main_frame)
+        tree_frame.pack(fill=tk.BOTH, expand=True)
+        
+        # Create Treeview with scrollbars
+        tree_scroll_y = ttk.Scrollbar(tree_frame)
+        tree_scroll_y.pack(side=tk.RIGHT, fill=tk.Y)
+        
+        tree_scroll_x = ttk.Scrollbar(tree_frame, orient=tk.HORIZONTAL)
+        tree_scroll_x.pack(side=tk.BOTTOM, fill=tk.X)
+        
+        tree = ttk.Treeview(tree_frame, 
+                           columns=("Find", "Replace", "Purpose"), 
+                           show="headings",
+                           yscrollcommand=tree_scroll_y.set,
+                           xscrollcommand=tree_scroll_x.set)
+        tree.pack(fill=tk.BOTH, expand=True)
+        
+        tree_scroll_y.config(command=tree.yview)
+        tree_scroll_x.config(command=tree.xview)
+        
+        # Configure columns
+        tree.heading("Find", text="Find")
+        tree.heading("Replace", text="Replace")
+        tree.heading("Purpose", text="Purpose")
+        
+        tree.column("Find", width=200, minwidth=150)
+        tree.column("Replace", width=150, minwidth=100)
+        tree.column("Purpose", width=300, minwidth=200)
+        
+        # Populate tree with patterns
+        def refresh_tree():
+            tree.delete(*tree.get_children())
+            for i, pattern in enumerate(pattern_library):
+                tree.insert("", tk.END, iid=i, values=(pattern["find"], pattern["replace"], pattern["purpose"]))
+        
+        refresh_tree()
+        
+        # Management buttons frame
+        button_frame = ttk.Frame(main_frame)
+        button_frame.pack(fill=tk.X, pady=(10,0))
+        
+        # Left side buttons (management)
+        left_buttons = ttk.Frame(button_frame)
+        left_buttons.pack(side=tk.LEFT)
+        
+        def add_pattern():
+            pattern_library.append({"find": "", "replace": "", "purpose": ""})
+            refresh_tree()
+            # Select the new item for editing
+            new_item_id = len(pattern_library) - 1
+            tree.selection_set(str(new_item_id))
+            tree.focus(str(new_item_id))
+            self.settings_manager.save_settings()
+        
+        def delete_pattern():
+            selection = tree.selection()
+            if selection:
+                item_id = int(selection[0])
+                del pattern_library[item_id]
+                refresh_tree()
+                self.settings_manager.save_settings()
+        
+        def move_up():
+            selection = tree.selection()
+            if selection:
+                item_id = int(selection[0])
+                if item_id > 0:
+                    # Swap with previous item
+                    pattern_library[item_id], pattern_library[item_id-1] = \
+                        pattern_library[item_id-1], pattern_library[item_id]
+                    refresh_tree()
+                    tree.selection_set(str(item_id-1))
+                    tree.focus(str(item_id-1))
+                    self.settings_manager.save_settings()
+        
+        def move_down():
+            selection = tree.selection()
+            if selection:
+                item_id = int(selection[0])
+                if item_id < len(pattern_library) - 1:
+                    # Swap with next item
+                    pattern_library[item_id], pattern_library[item_id+1] = \
+                        pattern_library[item_id+1], pattern_library[item_id]
+                    refresh_tree()
+                    tree.selection_set(str(item_id+1))
+                    tree.focus(str(item_id+1))
+                    self.settings_manager.save_settings()
+        
+        ttk.Button(left_buttons, text="Add", command=add_pattern).pack(side=tk.LEFT, padx=(0,5))
+        ttk.Button(left_buttons, text="Delete", command=delete_pattern).pack(side=tk.LEFT, padx=5)
+        ttk.Button(left_buttons, text="Move Up", command=move_up).pack(side=tk.LEFT, padx=5)
+        ttk.Button(left_buttons, text="Move Down", command=move_down).pack(side=tk.LEFT, padx=5)
+        
+        # Right side buttons (use/close)
+        right_buttons = ttk.Frame(button_frame)
+        right_buttons.pack(side=tk.RIGHT)
+        
+        def use_pattern():
+            selection = tree.selection()
+            if selection:
+                item_id = int(selection[0])
+                pattern = pattern_library[item_id]
+                self.find_text_field.delete(0, tk.END)
+                self.find_text_field.insert(0, pattern["find"])
+                self.replace_text_field.delete(0, tk.END)
+                self.replace_text_field.insert(0, pattern["replace"])
+                popup.destroy()
+                self.on_setting_change()
+        
+        def ai_help():
+            """Copy selected pattern to next empty input tab and switch to AI Tools."""
+            # Check if AI Tools is available
+            if not AI_TOOLS_AVAILABLE:
+                self._show_warning("AI Tools Not Available", 
+                                 "AI Tools module is not available. Please ensure the ai_tools.py module is properly installed.")
+                return
+            
+            selection = tree.selection()
+            if not selection:
+                self._show_info("No Selection", "Please select a pattern from the list first.")
+                return
+                
+            item_id = int(selection[0])
+            pattern = pattern_library[item_id]
+            
+            # Create the AI help text
+            ai_help_text = f"""## Please help me understand this regex:
+
+Purpose: {pattern.get('purpose', 'No purpose specified')}
+Find: {pattern['find']}
+Replace: {pattern['replace']}"""
+            
+            # This would need to be implemented by the parent application
+            # For now, just show a message
+            self._show_info("AI Help", "AI Help integration would be implemented by the parent application.")
+            popup.destroy()
+        
+        ai_help_button = ttk.Button(right_buttons, text="AI Help", command=ai_help)
+        ai_help_button.pack(side=tk.LEFT, padx=5)
+        use_pattern_button = ttk.Button(right_buttons, text="Use Pattern", command=use_pattern)
+        use_pattern_button.pack(side=tk.LEFT, padx=5)
+        ttk.Button(right_buttons, text="Close", command=popup.destroy).pack(side=tk.LEFT, padx=(5,0))
+        
+        # Function to update button states based on selection
+        def update_button_states():
+            selection = tree.selection()
+            state = "normal" if selection else "disabled"
+            use_pattern_button.config(state=state)
+            if AI_TOOLS_AVAILABLE:
+                ai_help_button.config(state=state)
+            else:
+                ai_help_button.config(state="disabled")
+        
+        # Bind selection change to update button states
+        tree.bind('<<TreeviewSelect>>', lambda e: update_button_states())
+        
+        # Initial button state update
+        update_button_states()
+        
+        # Double-click to use pattern
+        tree.bind('<Double-Button-1>', lambda e: use_pattern())
+        
+        # Cell editing functionality
+        def on_cell_click(event):
+            item = tree.selection()[0] if tree.selection() else None
+            if item:
+                column = tree.identify_column(event.x)
+                if column in ['#1', '#2', '#3']:  # Find, Replace, Purpose columns
+                    self._edit_cell(tree, item, column, popup, pattern_library)
+        
+        tree.bind('<Button-1>', on_cell_click)
+
+    def _edit_cell(self, tree, item, column, parent_window, pattern_library):
+        """Edit a cell in the pattern library tree."""
+        # Get current value
+        item_id = int(item)
+        pattern = pattern_library[item_id]
+        
+        column_map = {'#1': 'find', '#2': 'replace', '#3': 'purpose'}
+        field_name = column_map[column]
+        current_value = pattern[field_name]
+        
+        # Get cell position
+        bbox = tree.bbox(item, column)
+        if not bbox:
+            return
+        
+        # Create entry widget for editing
+        entry = tk.Entry(tree)
+        entry.place(x=bbox[0], y=bbox[1], width=bbox[2], height=bbox[3])
+        entry.insert(0, current_value)
+        entry.select_range(0, tk.END)
+        entry.focus()
+        
+        def save_edit():
+            new_value = entry.get()
+            pattern[field_name] = new_value
+            tree.set(item, column, new_value)
+            entry.destroy()
+            self.settings_manager.save_settings()
+        
+        def cancel_edit():
+            entry.destroy()
+        
+        entry.bind('<Return>', lambda e: save_edit())
+        entry.bind('<Escape>', lambda e: cancel_edit())
+        entry.bind('<FocusOut>', lambda e: save_edit())
+
+
+class SettingsManager:
+    """
+    Interface for settings management that the FindReplaceWidget expects.
+    This should be implemented by the parent application.
+    """
+    
+    def get_tool_settings(self, tool_name: str) -> Dict[str, Any]:
+        """Get settings for a specific tool."""
+        raise NotImplementedError("Must be implemented by parent application")
+    
+    def save_settings(self):
+        """Save current settings to persistent storage."""
+        raise NotImplementedError("Must be implemented by parent application")
+    
+    def get_pattern_library(self) -> List[Dict[str, str]]:
+        """Get the regex pattern library."""
+        raise NotImplementedError("Must be implemented by parent application")
+
+
+# Example usage and integration helper
+def create_find_replace_widget(parent, settings_manager, logger=None):
+    """
+    Factory function to create a Find & Replace widget.
+    
+    Args:
+        parent: Parent widget/window
+        settings_manager: Object implementing SettingsManager interface
+        logger: Optional logger instance
+    
+    Returns:
+        FindReplaceWidget instance
+    """
+    return FindReplaceWidget(parent, settings_manager, logger)