pomera-ai-commander 1.2.1 → 1.2.3

package/tools/diff_viewer.py

@@ -16,7 +16,8 @@ Author: Promera AI Commander
 """
 
 import tkinter as tk
-from tkinter import ttk
+from tkinter import ttk, filedialog, messagebox
+import difflib
 import re
 import platform
 import logging
@@ -45,7 +46,7 @@ class TextWithLineNumbers(tk.Frame):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.text = tk.Text(self, wrap=tk.WORD, height=15, width=50, undo=True)
-        self.linenumbers = tk.Canvas(self, width=40, bg='#f0f0f0', highlightthickness=0)
+        self.linenumbers = tk.Canvas(self, width=50, bg='#f0f0f0', highlightthickness=0)
         
         self.linenumbers.pack(side=tk.LEFT, fill=tk.Y)
         self.text.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
@@ -100,7 +101,10 @@ class DiffViewerWidget:
         
         # Settings for diff comparison
         self.settings = {
-            "option": "ignore_case"  # Default comparison mode
+            "option": "ignore_case",  # Default comparison mode
+            "char_level_diff": False,  # Character-level diff mode (vs word-level)
+            "detect_moved": False,  # Detect moved lines
+            "syntax_highlight": False  # Syntax highlighting for code
         }
         
         # Create the main frame
@@ -113,6 +117,22 @@ class DiffViewerWidget:
         self.input_stats_bar = None
         self.output_stats_bar = None
         
+        # Diff tracking for navigation and summary
+        self.diff_positions = []  # List of (line_number, diff_type) tuples
+        self.current_diff_index = -1
+        self.diff_counts = {"additions": 0, "deletions": 0, "modifications": 0}
+        self.similarity_score = 0.0
+        self.diff_summary_bar = None
+        
+        # Regex filter mode flags
+        self.input_regex_mode = tk.BooleanVar(value=False)
+        self.output_regex_mode = tk.BooleanVar(value=False)
+        
+        # Store original source text for comparison (to avoid accumulating blank lines)
+        self.comparison_source_input = {}  # {tab_idx: original_text}
+        self.comparison_source_output = {}  # {tab_idx: original_text}
+        self.has_run_comparison = {}  # {tab_idx: bool}
+        
         # Initialize UI components
         self._create_ui()
         self._setup_event_bindings()
@@ -126,7 +146,7 @@ class DiffViewerWidget:
                 from tkinter import messagebox
                 messagebox.showerror(title, message, parent=self.parent)
                 return True
-            except:
+            except Exception:
                 return False
     
     def _show_warning(self, title, message, category="warning"):
@@ -138,7 +158,7 @@ class DiffViewerWidget:
                 import tkinter.messagebox as messagebox
                 messagebox.showwarning(title, message, parent=self.parent)
                 return True
-            except:
+            except Exception:
                 return False
         
     def _create_ui(self):
@@ -147,6 +167,7 @@ class DiffViewerWidget:
         self._create_notebooks()
         self._create_tabs()
         self._create_statistics_bars()
+        self._create_diff_summary_bar()
         self._configure_text_tags()
         
     def _create_title_rows(self):
@@ -173,8 +194,10 @@ class DiffViewerWidget:
         ttk.Label(input_filter_frame, text="Filter:").pack(side=tk.LEFT)
         self.input_filter_var = tk.StringVar()
         self.input_filter_entry = ttk.Entry(input_filter_frame, textvariable=self.input_filter_var, width=25)
-        self.input_filter_entry.pack(side=tk.LEFT, padx=(5, 5), fill=tk.X, expand=True)
+        self.input_filter_entry.pack(side=tk.LEFT, padx=(5, 2), fill=tk.X, expand=True)
         self.input_filter_var.trace_add("write", self._on_input_filter_changed)
+        ttk.Checkbutton(input_filter_frame, text="Rx", variable=self.input_regex_mode, 
+                        command=self._on_input_filter_changed, width=3).pack(side=tk.LEFT, padx=(0, 2))
         ttk.Button(input_filter_frame, text="✕", command=self._clear_input_filter, width=3).pack(side=tk.LEFT)
         
         # Output title row
@@ -209,8 +232,10 @@ class DiffViewerWidget:
         ttk.Label(output_filter_frame, text="Filter:").pack(side=tk.LEFT)
         self.output_filter_var = tk.StringVar()
         self.output_filter_entry = ttk.Entry(output_filter_frame, textvariable=self.output_filter_var, width=25)
-        self.output_filter_entry.pack(side=tk.LEFT, padx=(5, 5), fill=tk.X, expand=True)
+        self.output_filter_entry.pack(side=tk.LEFT, padx=(5, 2), fill=tk.X, expand=True)
         self.output_filter_var.trace_add("write", self._on_output_filter_changed)
+        ttk.Checkbutton(output_filter_frame, text="Rx", variable=self.output_regex_mode,
+                        command=self._on_output_filter_changed, width=3).pack(side=tk.LEFT, padx=(0, 2))
         ttk.Button(output_filter_frame, text="✕", command=self._clear_output_filter, width=3).pack(side=tk.LEFT)
         
         # Store original content for filtering
@@ -246,6 +271,37 @@ class DiffViewerWidget:
             padding=(5, 2)
         )
         self.output_stats_bar.grid(row=2, column=1, sticky="ew", padx=(5, 0), pady=(5, 0))
+    
+    def _create_diff_summary_bar(self):
+        """Create diff summary bar with navigation buttons and similarity score."""
+        # Container frame spanning both columns
+        summary_frame = ttk.Frame(self.diff_frame)
+        summary_frame.grid(row=3, column=0, columnspan=2, sticky="ew", pady=(5, 0))
+        
+        # Navigation buttons on the left
+        nav_frame = ttk.Frame(summary_frame)
+        nav_frame.pack(side=tk.LEFT)
+        
+        self.prev_diff_btn = ttk.Button(nav_frame, text="⬆ Prev", command=self._goto_prev_diff, width=8)
+        self.prev_diff_btn.pack(side=tk.LEFT, padx=(0, 5))
+        self.prev_diff_btn.state(['disabled'])
+        
+        self.next_diff_btn = ttk.Button(nav_frame, text="⬇ Next", command=self._goto_next_diff, width=8)
+        self.next_diff_btn.pack(side=tk.LEFT, padx=(0, 10))
+        self.next_diff_btn.state(['disabled'])
+        
+        # Diff summary label in the center
+        self.diff_summary_bar = ttk.Label(
+            summary_frame,
+            text="Run comparison to see diff summary",
+            anchor=tk.CENTER,
+            padding=(5, 2)
+        )
+        self.diff_summary_bar.pack(side=tk.LEFT, fill=tk.X, expand=True)
+        
+        # Export button on the right
+        self.export_html_btn = ttk.Button(summary_frame, text="Export HTML", command=self._export_to_html, width=13)
+        self.export_html_btn.pack(side=tk.RIGHT, padx=(10, 0))
 
     def _create_tabs(self):
         """Create the text tabs for input and output."""
@@ -282,16 +338,27 @@ class DiffViewerWidget:
             self.output_notebook.add(output_tab, text=f"{i+1}:")
 
     def _configure_text_tags(self):
-        """Configure text tags for highlighting differences."""
+        """Configure text tags for highlighting differences and syntax."""
         for tab_list in [self.input_tabs, self.output_tabs]:
             for tab in tab_list:
                 widget = tab.text
                 widget.config(state="normal")
+                # Diff highlighting tags
                 widget.tag_configure("addition", background="#e6ffed")
                 widget.tag_configure("deletion", background="#ffebe9")
                 widget.tag_configure("modification", background="#e6f7ff")
                 widget.tag_configure("inline_add", background="#a7f0ba")
                 widget.tag_configure("inline_del", background="#ffc9c9")
+                widget.tag_configure("moved", background="#f3e8ff")  # Lavender for moved lines
+                
+                # Syntax highlighting tags (lower priority than diff tags)
+                widget.tag_configure("syntax_keyword", foreground="#0000ff")  # Blue
+                widget.tag_configure("syntax_string", foreground="#008000")   # Green
+                widget.tag_configure("syntax_comment", foreground="#808080", font=("", 0, "italic"))  # Gray italic
+                widget.tag_configure("syntax_number", foreground="#ff8c00")   # Dark orange
+                widget.tag_configure("syntax_function", foreground="#800080") # Purple
+                widget.tag_configure("syntax_decorator", foreground="#b8860b") # Dark goldenrod
+                widget.tag_configure("syntax_class", foreground="#2e8b57")    # Sea green
 
     def _setup_event_bindings(self):
         """Set up event bindings for synchronized scrolling."""
@@ -415,6 +482,11 @@ class DiffViewerWidget:
             self.output_tabs[i].text.delete("1.0", tk.END)
             self.output_tabs[i].text.insert("1.0", output_tabs_content[i])
         
+        # Clear stored comparison source text (so new content is compared fresh)
+        self.comparison_source_input.clear()
+        self.comparison_source_output.clear()
+        self.has_run_comparison.clear()
+        
         # Update tab labels after loading content
         self.update_tab_labels()
 
@@ -456,11 +528,15 @@ class DiffViewerWidget:
         
         Args:
             text: Input text to preprocess
-            option: Comparison option ('ignore_case', 'match_case', 'ignore_whitespace')
+            option: Comparison option ('ignore_case', 'match_case', 'ignore_whitespace', 'sentence_level')
             
         Returns:
             List of dicts with 'raw' and 'cmp' keys
         """
+        # For sentence-level comparison, split by sentences instead of lines
+        if option == "sentence_level":
+            return self._preprocess_sentences(text)
+        
         lines = text.splitlines()
         processed = []
         for line in lines:
@@ -469,8 +545,116 @@ class DiffViewerWidget:
                 cmp_line = cmp_line.lower()
             elif option == "ignore_whitespace": 
                 cmp_line = re.sub(r"\s+", " ", cmp_line).strip()
+            elif option == "ignore_punctuation":
+                # Remove all punctuation for comparison (useful for prose)
+                cmp_line = re.sub(r'[^\w\s]', '', cmp_line.lower()).strip()
+                cmp_line = re.sub(r"\s+", " ", cmp_line)  # Normalize whitespace too
             processed.append({"raw": line, "cmp": cmp_line})
         return processed
+    
+    def _preprocess_sentences(self, text):
+        """
+        Split text into sentences for sentence-level comparison.
+        
+        Args:
+            text: Input text to split into sentences
+            
+        Returns:
+            List of dicts with 'raw' (original sentence) and 'cmp' (normalized) keys
+        """
+        # Replace line breaks with spaces for continuous text
+        continuous_text = re.sub(r'\s+', ' ', text).strip()
+        
+        if not continuous_text:
+            return []
+        
+        # Split into sentences using pattern that handles common cases
+        # Matches: . ! ? followed by space or end of string
+        # But not: abbreviations like Mr. Mrs. Dr. etc.
+        sentence_pattern = r'(?<![A-Z][a-z])(?<![A-Z])(?<=\.|\!|\?)\s+'
+        sentences = re.split(sentence_pattern, continuous_text)
+        
+        processed = []
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if sentence:
+                # Normalize for comparison: lowercase, normalize whitespace
+                cmp_sentence = re.sub(r'\s+', ' ', sentence.lower()).strip()
+                processed.append({"raw": sentence, "cmp": cmp_sentence})
+        
+        return processed
+    
+    def _clean_alignment_blanks(self, text):
+        """
+        Remove consecutive empty lines (alignment artifacts) while preserving single empty lines.
+        
+        This prevents blank lines from accumulating across comparison sessions.
+        
+        Args:
+            text: Input text that may contain alignment blank lines
+            
+        Returns:
+            Cleaned text with consecutive empty lines collapsed
+        """
+        if not text:
+            return text
+        
+        lines = text.splitlines()
+        cleaned_lines = []
+        prev_was_empty = False
+        
+        for line in lines:
+            is_empty = line.strip() == ""
+            
+            if is_empty and prev_was_empty:
+                # Skip consecutive empty lines
+                continue
+            
+            cleaned_lines.append(line)
+            prev_was_empty = is_empty
+        
+        return '\n'.join(cleaned_lines)
+    
+    def reset_comparison_source(self):
+        """
+        Reset comparison source cache and clean widget content of accumulated blanks.
+        
+        Called when user clicks 'Compare Active Tabs' to ensure fresh content is used.
+        """
+        # Clear the source cache
+        self.comparison_source_input.clear()
+        self.comparison_source_output.clear()
+        self.has_run_comparison.clear()
+        
+        # Clean the active tab widgets of accumulated blank lines
+        try:
+            active_input_idx = self.input_notebook.index("current")
+            active_output_idx = self.output_notebook.index("current")
+            
+            input_widget = self.input_tabs[active_input_idx].text
+            output_widget = self.output_tabs[active_output_idx].text
+            
+            # Get and clean input content
+            input_text = input_widget.get("1.0", tk.END)
+            if input_text.endswith('\n'):
+                input_text = input_text[:-1]
+            cleaned_input = self._clean_alignment_blanks(input_text)
+            
+            # Get and clean output content
+            output_text = output_widget.get("1.0", tk.END)
+            if output_text.endswith('\n'):
+                output_text = output_text[:-1]
+            cleaned_output = self._clean_alignment_blanks(output_text)
+            
+            # Replace widget content with cleaned version
+            input_widget.delete("1.0", tk.END)
+            input_widget.insert("1.0", cleaned_input)
+            
+            output_widget.delete("1.0", tk.END)
+            output_widget.insert("1.0", cleaned_output)
+            
+        except (tk.TclError, IndexError) as e:
+            self.logger.warning(f"Could not clean widget content: {e}")
 
     def run_comparison(self, option=None):
         """
@@ -494,14 +678,28 @@ class DiffViewerWidget:
             input_widget = self.input_tabs[active_input_idx].text
             output_widget = self.output_tabs[active_output_idx].text
             
-            # Get text content (remove trailing newline that tkinter adds)
-            input_text = input_widget.get("1.0", tk.END)
-            if input_text.endswith('\n'):
-                input_text = input_text[:-1]
+            # Check if we have stored original text from a previous comparison
+            # This prevents accumulating blank lines when switching comparison modes
+            tab_key = (active_input_idx, active_output_idx)
             
-            output_text = output_widget.get("1.0", tk.END)
-            if output_text.endswith('\n'):
-                output_text = output_text[:-1]
+            if tab_key in self.has_run_comparison and self.has_run_comparison[tab_key]:
+                # Use stored original text (without alignment blanks)
+                input_text = self.comparison_source_input.get(active_input_idx, "")
+                output_text = self.comparison_source_output.get(active_output_idx, "")
+            else:
+                # First comparison - read current widget content and store it
+                input_text = input_widget.get("1.0", tk.END)
+                if input_text.endswith('\n'):
+                    input_text = input_text[:-1]
+                
+                output_text = output_widget.get("1.0", tk.END)
+                if output_text.endswith('\n'):
+                    output_text = output_text[:-1]
+                
+                # Store the original source text (no blank line cleaning - preserves structure)
+                self.comparison_source_input[active_input_idx] = input_text
+                self.comparison_source_output[active_output_idx] = output_text
+                self.has_run_comparison[tab_key] = True
                 
         except (tk.TclError, IndexError):
             self.logger.error("Could not get active tabs for comparison")
@@ -522,19 +720,32 @@ class DiffViewerWidget:
         # Clear existing content
         input_widget.delete("1.0", tk.END)
         output_widget.delete("1.0", tk.END)
+        
+        # Reset diff tracking
+        self.diff_positions = []
+        self.current_diff_index = -1
+        self.diff_counts = {"additions": 0, "deletions": 0, "modifications": 0}
+        self.similarity_score = 0.0
 
         # Handle empty texts
-        if not input_text.strip() and not output_text.strip(): 
+        if not input_text.strip() and not output_text.strip():
+            self._update_diff_summary()
             return
         elif not input_text.strip():
-            for line in output_text.splitlines():
+            for i, line in enumerate(output_text.splitlines()):
                 input_widget.insert(tk.END, '\n')
                 output_widget.insert(tk.END, line + '\n', 'addition')
+                self.diff_positions.append((i + 1, 'addition'))
+                self.diff_counts["additions"] += 1
+            self._update_diff_summary()
             return
         elif not output_text.strip():
-            for line in input_text.splitlines():
+            for i, line in enumerate(input_text.splitlines()):
                 input_widget.insert(tk.END, line + '\n', 'deletion')
                 output_widget.insert(tk.END, '\n')
+                self.diff_positions.append((i + 1, 'deletion'))
+                self.diff_counts["deletions"] += 1
+            self._update_diff_summary()
             return
 
         # Preprocess texts for comparison
@@ -544,9 +755,11 @@ class DiffViewerWidget:
         right_cmp = [r["cmp"] for r in right_lines]
         
         try:
-            import difflib
             matcher = difflib.SequenceMatcher(None, left_cmp, right_cmp, autojunk=False)
             
+            # Compute similarity score
+            self.similarity_score = matcher.ratio() * 100
+            
             for tag, i1, i2, j1, j2 in matcher.get_opcodes():
                 if tag == 'equal':
                     for i in range(i1, i2):
@@ -557,11 +770,23 @@ class DiffViewerWidget:
                     for i in range(i1, i2):
                         input_widget.insert(tk.END, left_lines[i]["raw"] + '\n', 'deletion')
                         output_widget.insert(tk.END, '\n')
+                        # Get line number AFTER inserting (current line minus 1 since cursor is on next line)
+                        actual_line = int(input_widget.index(tk.INSERT).split('.')[0]) - 1
+                        if actual_line < 1:
+                            actual_line = 1
+                        self.diff_positions.append((actual_line, 'deletion'))
+                        self.diff_counts["deletions"] += 1
                         
                 elif tag == 'insert':
                     for j in range(j1, j2):
                         input_widget.insert(tk.END, '\n')
                         output_widget.insert(tk.END, right_lines[j]["raw"] + '\n', 'addition')
+                        # Get line number AFTER inserting
+                        actual_line = int(input_widget.index(tk.INSERT).split('.')[0]) - 1
+                        if actual_line < 1:
+                            actual_line = 1
+                        self.diff_positions.append((actual_line, 'addition'))
+                        self.diff_counts["additions"] += 1
                         
                 elif tag == 'replace':
                     input_block = [l["raw"] for l in left_lines[i1:i2]]
@@ -576,12 +801,28 @@ class DiffViewerWidget:
                     for line1, line2 in zip(input_block, output_block):
                         if line1 and line2: 
                             self._highlight_word_diffs(input_widget, [line1], output_widget, [line2])
+                            # Get line number AFTER inserting
+                            actual_line = int(input_widget.index(tk.INSERT).split('.')[0]) - 1
+                            if actual_line < 1:
+                                actual_line = 1
+                            self.diff_positions.append((actual_line, 'modification'))
+                            self.diff_counts["modifications"] += 1
                         elif line1:
                             input_widget.insert(tk.END, line1 + '\n', 'deletion')
                             output_widget.insert(tk.END, '\n')
+                            actual_line = int(input_widget.index(tk.INSERT).split('.')[0]) - 1
+                            if actual_line < 1:
+                                actual_line = 1
+                            self.diff_positions.append((actual_line, 'deletion'))
+                            self.diff_counts["deletions"] += 1
                         elif line2:
                             input_widget.insert(tk.END, '\n')
                             output_widget.insert(tk.END, line2 + '\n', 'addition')
+                            actual_line = int(input_widget.index(tk.INSERT).split('.')[0]) - 1
+                            if actual_line < 1:
+                                actual_line = 1
+                            self.diff_positions.append((actual_line, 'addition'))
+                            self.diff_counts["additions"] += 1
                             
         except Exception as e:
             self.logger.error(f"Error in diff computation: {e}")
@@ -593,8 +834,130 @@ class DiffViewerWidget:
         output_widget.yview_moveto(0)
         self._setup_sync()
         
+        # Detect moved lines if enabled
+        if self.settings.get("detect_moved", False):
+            self._detect_moved_lines(input_widget, output_widget)
+        
+        # Apply syntax highlighting if enabled
+        if self.settings.get("syntax_highlight", False):
+            self._apply_syntax_highlighting(input_widget)
+            self._apply_syntax_highlighting(output_widget)
+        
         # Update tab labels after comparison
         self.update_tab_labels()
+        
+        # Update diff summary bar
+        self._update_diff_summary()
+    
+    def _detect_moved_lines(self, input_widget, output_widget):
+        """
+        Detect lines that were moved (appear in both delete and insert sections).
+        Re-tags them as 'moved' instead of deletion/addition.
+        """
+        try:
+            # Get all lines with deletion tag from input
+            deleted_lines = {}
+            for tag_range in input_widget.tag_ranges("deletion"):
+                if isinstance(tag_range, str):
+                    continue
+                # Get line number from index
+                line_num = int(str(tag_range).split('.')[0])
+                line_content = input_widget.get(f"{line_num}.0", f"{line_num}.end").strip()
+                if line_content:
+                    deleted_lines[line_content.lower()] = line_num
+            
+            # Get all lines with addition tag from output
+            added_lines = {}
+            for tag_range in output_widget.tag_ranges("addition"):
+                if isinstance(tag_range, str):
+                    continue
+                line_num = int(str(tag_range).split('.')[0])
+                line_content = output_widget.get(f"{line_num}.0", f"{line_num}.end").strip()
+                if line_content:
+                    added_lines[line_content.lower()] = line_num
+            
+            # Find lines that appear in both (moved lines)
+            moved_count = 0
+            for content, input_line in deleted_lines.items():
+                if content in added_lines:
+                    output_line = added_lines[content]
+                    # Re-tag as moved in both widgets
+                    input_widget.tag_remove("deletion", f"{input_line}.0", f"{input_line}.end+1c")
+                    input_widget.tag_add("moved", f"{input_line}.0", f"{input_line}.end+1c")
+                    
+                    output_widget.tag_remove("addition", f"{output_line}.0", f"{output_line}.end+1c")
+                    output_widget.tag_add("moved", f"{output_line}.0", f"{output_line}.end+1c")
+                    
+                    moved_count += 1
+            
+            # Update counts
+            if moved_count > 0:
+                self.diff_counts["moved"] = moved_count
+                # Reduce deletion/addition counts
+                self.diff_counts["deletions"] = max(0, self.diff_counts.get("deletions", 0) - moved_count)
+                self.diff_counts["additions"] = max(0, self.diff_counts.get("additions", 0) - moved_count)
+                
+        except Exception as e:
+            self.logger.error(f"Error detecting moved lines: {e}")
+    
+    def _apply_syntax_highlighting(self, widget):
+        """
+        Apply syntax highlighting to code content in a text widget.
+        Uses regex patterns for common programming constructs.
+        """
+        try:
+            content = widget.get("1.0", tk.END)
+            
+            # Define patterns for syntax highlighting
+            patterns = [
+                # Python/JS keywords
+                (r'\b(def|class|import|from|return|if|elif|else|for|while|try|except|finally|with|as|'
+                 r'raise|yield|lambda|and|or|not|in|is|True|False|None|async|await|'
+                 r'function|const|let|var|new|this|typeof|instanceof|export|default)\b', 
+                 'syntax_keyword'),
+                
+                # Triple-quoted strings (must come before single/double quotes)
+                (r'"""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\'', 'syntax_string'),
+                
+                # Single and double quoted strings
+                (r'"(?:[^"\\]|\\.)*"|\'(?:[^\'\\]|\\.)*\'', 'syntax_string'),
+                
+                # Comments (Python # and JS //)
+                (r'#[^\n]*|//[^\n]*', 'syntax_comment'),
+                
+                # Numbers (integers, floats, hex)
+                (r'\b(?:0x[0-9a-fA-F]+|0b[01]+|0o[0-7]+|\d+\.?\d*(?:e[+-]?\d+)?)\b', 'syntax_number'),
+                
+                # Function definitions
+                (r'\b(?:def|function)\s+([a-zA-Z_][a-zA-Z0-9_]*)', 'syntax_function'),
+                
+                # Decorators
+                (r'@[a-zA-Z_][a-zA-Z0-9_.]*', 'syntax_decorator'),
+                
+                # Class definitions
+                (r'\bclass\s+([a-zA-Z_][a-zA-Z0-9_]*)', 'syntax_class'),
+            ]
+            
+            for pattern, tag in patterns:
+                for match in re.finditer(pattern, content):
+                    start_idx = f"1.0+{match.start()}c"
+                    end_idx = f"1.0+{match.end()}c"
+                    
+                    # For function/class definitions, highlight just the name (group 1)
+                    if tag in ('syntax_function', 'syntax_class') and match.lastindex:
+                        name_start = match.start(1)
+                        name_end = match.end(1)
+                        start_idx = f"1.0+{name_start}c"
+                        end_idx = f"1.0+{name_end}c"
+                    
+                    widget.tag_add(tag, start_idx, end_idx)
+            
+            # Ensure diff tags have higher priority (raise them above syntax tags)
+            for diff_tag in ['addition', 'deletion', 'modification', 'inline_add', 'inline_del', 'moved']:
+                widget.tag_raise(diff_tag)
+                
+        except Exception as e:
+            self.logger.error(f"Error applying syntax highlighting: {e}")
 
     def _highlight_word_diffs(self, w1, lines1, w2, lines2):
         """
@@ -606,6 +969,9 @@ class DiffViewerWidget:
             w2: Second text widget  
             lines2: Lines for second widget
         """
+        # Check if character-level diff is enabled
+        use_char_diff = self.settings.get("char_level_diff", False)
+        
         for line1, line2 in zip(lines1, lines2):
             w1.insert(tk.END, line1 + '\n', 'modification')
             w2.insert(tk.END, line2 + '\n', 'modification')
@@ -613,24 +979,49 @@ class DiffViewerWidget:
             line_start1 = w1.index(f"{w1.index(tk.INSERT)} -1 lines linestart")
             line_start2 = w2.index(f"{w2.index(tk.INSERT)} -1 lines linestart")
 
+            if use_char_diff:
+                # Character-level diff
+                self._apply_char_diff(w1, line1, line_start1, w2, line2, line_start2)
+            else:
+                # Word-level diff
+                self._apply_word_diff(w1, line1, line_start1, w2, line2, line_start2)
+    
+    def _apply_word_diff(self, w1, line1, line_start1, w2, line2, line_start2):
+        """Apply word-level diff highlighting."""
+        try:
             words1 = re.split(r'(\s+)', line1)
             words2 = re.split(r'(\s+)', line2)
             
-            try:
-                import difflib
-                matcher = difflib.SequenceMatcher(None, words1, words2)
+            matcher = difflib.SequenceMatcher(None, words1, words2)
+
+            for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+                if tag == 'delete' or tag == 'replace':
+                    start_char1 = len("".join(words1[:i1]))
+                    end_char1 = len("".join(words1[:i2]))
+                    w1.tag_add('inline_del', f"{line_start1}+{start_char1}c", f"{line_start1}+{end_char1}c")
+                if tag == 'insert' or tag == 'replace':
+                    start_char2 = len("".join(words2[:j1]))
+                    end_char2 = len("".join(words2[:j2]))
+                    w2.tag_add('inline_add', f"{line_start2}+{start_char2}c", f"{line_start2}+{end_char2}c")
+        except Exception as e:
+            self.logger.error(f"Error in word-level diff highlighting: {e}")
+    
+    def _apply_char_diff(self, w1, line1, line_start1, w2, line2, line_start2):
+        """Apply character-level diff highlighting."""
+        try:
+            # Split into individual characters
+            chars1 = list(line1)
+            chars2 = list(line2)
+            
+            matcher = difflib.SequenceMatcher(None, chars1, chars2)
 
-                for tag, i1, i2, j1, j2 in matcher.get_opcodes():
-                    if tag == 'delete' or tag == 'replace':
-                        start_char1 = len("".join(words1[:i1]))
-                        end_char1 = len("".join(words1[:i2]))
-                        w1.tag_add('inline_del', f"{line_start1}+{start_char1}c", f"{line_start1}+{end_char1}c")
-                    if tag == 'insert' or tag == 'replace':
-                        start_char2 = len("".join(words2[:j1]))
-                        end_char2 = len("".join(words2[:j2]))
-                        w2.tag_add('inline_add', f"{line_start2}+{start_char2}c", f"{line_start2}+{end_char2}c")
-            except Exception as e:
-                self.logger.error(f"Error in word-level diff highlighting: {e}")
+            for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+                if tag == 'delete' or tag == 'replace':
+                    w1.tag_add('inline_del', f"{line_start1}+{i1}c", f"{line_start1}+{i2}c")
+                if tag == 'insert' or tag == 'replace':
+                    w2.tag_add('inline_add', f"{line_start2}+{j1}c", f"{line_start2}+{j2}c")
+        except Exception as e:
+            self.logger.error(f"Error in character-level diff highlighting: {e}")
 
     def clear_all_input_tabs(self):
         """Clear all input tabs."""
@@ -676,7 +1067,6 @@ class DiffViewerWidget:
     def load_file_to_input(self):
         """Load file content to the active input tab."""
         try:
-            from tkinter import filedialog
             file_path = filedialog.askopenfilename(
                 title="Select file to load",
                 filetypes=[
@@ -735,6 +1125,196 @@ class DiffViewerWidget:
                     
         except Exception as e:
             self.logger.error(f"Error updating tab labels: {e}")
+    
+    def _update_diff_summary(self):
+        """Update the diff summary bar with current comparison results."""
+        if not self.diff_summary_bar:
+            return
+        
+        total_diffs = len(self.diff_positions)
+        adds = self.diff_counts.get("additions", 0)
+        dels = self.diff_counts.get("deletions", 0)
+        mods = self.diff_counts.get("modifications", 0)
+        moved = self.diff_counts.get("moved", 0)
+        
+        if total_diffs == 0 and moved == 0:
+            summary_text = "No differences found | 100% similar"
+            self.prev_diff_btn.state(['disabled'])
+            self.next_diff_btn.state(['disabled'])
+        else:
+            parts = [f"+{adds} additions", f"-{dels} deletions", f"~{mods} modifications"]
+            if moved > 0:
+                parts.append(f"↔{moved} moved")
+            parts.append(f"{self.similarity_score:.1f}% similar")
+            summary_text = " | ".join(parts)
+            self.prev_diff_btn.state(['!disabled'])
+            self.next_diff_btn.state(['!disabled'])
+        
+        self.diff_summary_bar.config(text=summary_text)
+    
+    def _goto_prev_diff(self):
+        """Navigate to the previous difference."""
+        if not self.diff_positions:
+            return
+        
+        if self.current_diff_index <= 0:
+            self.current_diff_index = len(self.diff_positions) - 1
+        else:
+            self.current_diff_index -= 1
+        
+        self._scroll_to_diff(self.current_diff_index)
+    
+    def _goto_next_diff(self):
+        """Navigate to the next difference."""
+        if not self.diff_positions:
+            return
+        
+        if self.current_diff_index >= len(self.diff_positions) - 1:
+            self.current_diff_index = 0
+        else:
+            self.current_diff_index += 1
+        
+        self._scroll_to_diff(self.current_diff_index)
+    
+    def _scroll_to_diff(self, diff_index):
+        """Scroll both text widgets to show the specified difference."""
+        try:
+            if diff_index < 0 or diff_index >= len(self.diff_positions):
+                return
+            
+            line_num, diff_type = self.diff_positions[diff_index]
+            
+            active_input_tab = self.input_tabs[self.input_notebook.index("current")]
+            active_output_tab = self.output_tabs[self.output_notebook.index("current")]
+            
+            input_widget = active_input_tab.text
+            output_widget = active_output_tab.text
+            
+            # Line index for the diff
+            line_index = f"{line_num}.0"
+            line_end = f"{line_num}.end"
+            
+            # Remove any previous navigation highlight
+            input_widget.tag_remove("nav_highlight", "1.0", tk.END)
+            output_widget.tag_remove("nav_highlight", "1.0", tk.END)
+            
+            # Configure navigation highlight tag (bright yellow background with high priority)
+            input_widget.tag_configure("nav_highlight", background="#ffff00", foreground="#000000")
+            output_widget.tag_configure("nav_highlight", background="#ffff00", foreground="#000000")
+            
+            # Add highlight to current diff line
+            input_widget.tag_add("nav_highlight", line_index, line_end)
+            output_widget.tag_add("nav_highlight", line_index, line_end)
+            
+            # Raise nav_highlight above all other tags so it's visible
+            input_widget.tag_raise("nav_highlight")
+            output_widget.tag_raise("nav_highlight")
+            
+            # Move cursor to the beginning of the line
+            input_widget.mark_set(tk.INSERT, line_index)
+            output_widget.mark_set(tk.INSERT, line_index)
+            
+            # Focus the input widget
+            input_widget.focus_set()
+            
+            # Scroll to make the line visible (centered if possible)
+            input_widget.see(line_index)
+            output_widget.see(line_index)
+            
+            # Force update of line numbers if available
+            if hasattr(active_input_tab, '_on_text_modified'):
+                active_input_tab._on_text_modified()
+            if hasattr(active_output_tab, '_on_text_modified'):
+                active_output_tab._on_text_modified()
+            
+            # Update summary to show current position
+            total = len(self.diff_positions)
+            current = diff_index + 1
+            base_summary = self.diff_summary_bar.cget("text").split(" | Diff ")[0]
+            self.diff_summary_bar.config(text=f"{base_summary} | Diff {current}/{total}")
+            
+        except (tk.TclError, IndexError) as e:
+            self.logger.error(f"Error scrolling to diff: {e}")
+    
+    def _export_to_html(self):
+        """Export the current diff comparison to an HTML file."""
+        try:
+            active_input_idx = self.input_notebook.index("current")
+            active_output_idx = self.output_notebook.index("current")
+            
+            input_text = self.input_tabs[active_input_idx].text.get("1.0", tk.END)
+            output_text = self.output_tabs[active_output_idx].text.get("1.0", tk.END)
+            
+            # Remove trailing newlines
+            if input_text.endswith('\n'):
+                input_text = input_text[:-1]
+            if output_text.endswith('\n'):
+                output_text = output_text[:-1]
+            
+            if not input_text.strip() and not output_text.strip():
+                messagebox.showinfo("Export", "No content to export.", parent=self.parent)
+                return
+            
+            # Ask for save location
+            file_path = filedialog.asksaveasfilename(
+                title="Export Diff as HTML",
+                defaultextension=".html",
+                filetypes=[("HTML files", "*.html"), ("All files", "*.*")],
+                parent=self.parent
+            )
+            
+            if not file_path:
+                return
+            
+            # Generate HTML diff
+            html_diff = difflib.HtmlDiff(wrapcolumn=80)
+            html_content = html_diff.make_file(
+                input_text.splitlines(),
+                output_text.splitlines(),
+                fromdesc="Input",
+                todesc="Output",
+                context=False
+            )
+            
+            # Add custom styling for better appearance
+            custom_css = """
+            <style>
+                body { font-family: 'Segoe UI', Tahoma, sans-serif; margin: 20px; }
+                table.diff { border-collapse: collapse; width: 100%; }
+                .diff_header { background-color: #f0f0f0; }
+                .diff_next { background-color: #e0e0e0; }
+                td { padding: 2px 8px; font-family: 'Consolas', 'Monaco', monospace; font-size: 12px; }
+                .diff_add { background-color: #e6ffed; }
+                .diff_chg { background-color: #e6f7ff; }
+                .diff_sub { background-color: #ffebe9; }
+                .summary { margin-bottom: 15px; padding: 10px; background: #f5f5f5; border-radius: 5px; }
+            </style>
+            """
+            
+            # Insert summary and custom CSS
+            summary_html = f"""
+            <div class="summary">
+                <strong>Diff Summary:</strong> 
+                +{self.diff_counts.get('additions', 0)} additions | 
+                -{self.diff_counts.get('deletions', 0)} deletions | 
+                ~{self.diff_counts.get('modifications', 0)} modifications | 
+                {self.similarity_score:.1f}% similar
+            </div>
+            """
+            
+            html_content = html_content.replace("</head>", f"{custom_css}</head>")
+            html_content = html_content.replace("<body>", f"<body>{summary_html}")
+            
+            # Write to file
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(html_content)
+            
+            self.logger.info(f"Exported diff to: {file_path}")
+            messagebox.showinfo("Export Complete", f"Diff exported to:\n{file_path}", parent=self.parent)
+            
+        except Exception as e:
+            self.logger.error(f"Error exporting to HTML: {e}")
+            self._show_error("Export Error", f"Could not export diff: {str(e)}")
 
     def _on_input_filter_changed(self, *args):
         """Handle input filter text changes."""
@@ -768,7 +1348,20 @@ class DiffViewerWidget:
             if filter_text:
                 # Apply filter
                 lines = original_content.split('\n')
-                filtered_lines = [line for line in lines if filter_text.lower() in line.lower()]
+                
+                if self.input_regex_mode.get():
+                    # Regex mode
+                    try:
+                        pattern = re.compile(filter_text, re.IGNORECASE)
+                        filtered_lines = [line for line in lines if pattern.search(line)]
+                    except re.error as e:
+                        self.logger.warning(f"Invalid regex pattern: {e}")
+                        # Fallback to literal search on regex error
+                        filtered_lines = [line for line in lines if filter_text.lower() in line.lower()]
+                else:
+                    # Simple substring match
+                    filtered_lines = [line for line in lines if filter_text.lower() in line.lower()]
+                
                 filtered_content = '\n'.join(filtered_lines)
                 
                 current_tab.text.delete("1.0", tk.END)
@@ -803,7 +1396,20 @@ class DiffViewerWidget:
             if filter_text:
                 # Apply filter
                 lines = original_content.split('\n')
-                filtered_lines = [line for line in lines if filter_text.lower() in line.lower()]
+                
+                if self.output_regex_mode.get():
+                    # Regex mode
+                    try:
+                        pattern = re.compile(filter_text, re.IGNORECASE)
+                        filtered_lines = [line for line in lines if pattern.search(line)]
+                    except re.error as e:
+                        self.logger.warning(f"Invalid regex pattern: {e}")
+                        # Fallback to literal search on regex error
+                        filtered_lines = [line for line in lines if filter_text.lower() in line.lower()]
+                else:
+                    # Simple substring match
+                    filtered_lines = [line for line in lines if filter_text.lower() in line.lower()]
+                
                 filtered_content = '\n'.join(filtered_lines)
                 
                 current_tab.text.delete("1.0", tk.END)
@@ -909,8 +1515,11 @@ class DiffViewerWidget:
                 words = [word for word in stripped_text.split() if word]
                 word_count = len(words)
             
-            # Count sentences (rough approximation)
-            sentence_count = text.count('.') + text.count('!') + text.count('?')
+            # Count sentences using regex pattern that handles abbreviations better
+            # Looks for sentence-ending punctuation followed by space or end of string
+            sentence_pattern = r'[.!?]+(?:\s|$)'
+            sentence_matches = re.findall(sentence_pattern, text)
+            sentence_count = len(sentence_matches)
             if sentence_count == 0 and char_count > 0:
                 sentence_count = 1
             
@@ -951,17 +1560,29 @@ class DiffViewerSettingsWidget:
         # Get current settings
         settings = diff_viewer.get_settings()
         default_option = settings.get("option", "ignore_case")
+        default_char_level = settings.get("char_level_diff", False)
+        default_detect_moved = settings.get("detect_moved", False)
+        default_syntax = settings.get("syntax_highlight", False)
         
-        # Create option variable
+        # Create option variables
         self.option_var = tk.StringVar(value=default_option)
+        self.char_level_var = tk.BooleanVar(value=default_char_level)
+        self.detect_moved_var = tk.BooleanVar(value=default_detect_moved)
+        self.syntax_var = tk.BooleanVar(value=default_syntax)
         
         # Create UI
         self._create_ui()
         
     def _create_ui(self):
-        """Create the settings UI."""
+        """Create the settings UI in two rows for better layout."""
+        # Row 1: Comparison mode radio buttons
+        row1 = ttk.Frame(self.parent)
+        row1.pack(fill=tk.X, pady=(0, 3))
+        
+        ttk.Label(row1, text="Mode:").pack(side=tk.LEFT, padx=(0, 5))
+        
         ttk.Radiobutton(
-            self.parent, 
+            row1, 
             text="Ignore case", 
             variable=self.option_var, 
             value="ignore_case", 
@@ -969,7 +1590,7 @@ class DiffViewerSettingsWidget:
         ).pack(side=tk.LEFT, padx=(0, 8))
         
         ttk.Radiobutton(
-            self.parent, 
+            row1, 
             text="Match case", 
             variable=self.option_var, 
             value="match_case", 
@@ -977,24 +1598,71 @@ class DiffViewerSettingsWidget:
         ).pack(side=tk.LEFT, padx=(0, 8))
         
         ttk.Radiobutton(
-            self.parent, 
+            row1, 
             text="Ignore whitespace", 
             variable=self.option_var, 
             value="ignore_whitespace", 
             command=self._on_option_change
-        ).pack(side=tk.LEFT, padx=(0, 16))
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        ttk.Radiobutton(
+            row1, 
+            text="Ignore punctuation", 
+            variable=self.option_var, 
+            value="ignore_punctuation", 
+            command=self._on_option_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        ttk.Radiobutton(
+            row1, 
+            text="Sentences", 
+            variable=self.option_var, 
+            value="sentence_level", 
+            command=self._on_option_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        # Row 2: Action buttons and options
+        row2 = ttk.Frame(self.parent)
+        row2.pack(fill=tk.X)
         
         ttk.Button(
-            self.parent, 
+            row2, 
             text="Compare Active Tabs", 
             command=self._run_comparison
-        ).pack(side=tk.LEFT, padx=5)
+        ).pack(side=tk.LEFT, padx=(0, 10))
+        
+        ttk.Label(row2, text="|").pack(side=tk.LEFT, padx=5)
         
-        # Add separator
-        ttk.Label(self.parent, text="|").pack(side=tk.LEFT, padx=5)
+        ttk.Label(row2, text="Options:").pack(side=tk.LEFT, padx=(0, 5))
+        
+        # Character-level diff checkbox
+        ttk.Checkbutton(
+            row2,
+            text="Char diff",
+            variable=self.char_level_var,
+            command=self._on_char_level_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        # Detect moved lines checkbox
+        ttk.Checkbutton(
+            row2,
+            text="Detect moved",
+            variable=self.detect_moved_var,
+            command=self._on_detect_moved_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        # Syntax highlighting checkbox
+        ttk.Checkbutton(
+            row2,
+            text="Syntax",
+            variable=self.syntax_var,
+            command=self._on_syntax_change
+        ).pack(side=tk.LEFT, padx=(0, 8))
+        
+        ttk.Label(row2, text="|").pack(side=tk.LEFT, padx=5)
         
         ttk.Button(
-            self.parent, 
+            row2, 
             text="List Comparator", 
             command=self._launch_list_comparator
         ).pack(side=tk.LEFT, padx=5)
@@ -1002,14 +1670,75 @@ class DiffViewerSettingsWidget:
     def _on_option_change(self):
         """Handle option change."""
         option = self.option_var.get()
+        
+        # Show confirmation dialog for sentence mode
+        if option == "sentence_level":
+            if not self._confirm_sentence_mode():
+                # User cancelled - revert to previous option
+                previous_option = self.diff_viewer.settings.get("option", "ignore_case")
+                self.option_var.set(previous_option)
+                return
+        
         self.diff_viewer.update_settings({"option": option})
         
         if self.on_setting_change:
             self.on_setting_change("Diff Viewer", {"option": option})
     
+    def _confirm_sentence_mode(self):
+        """Show confirmation dialog for sentence mode."""
+        message = (
+            "Sentence Mode restructures text for comparison.\n\n"
+            "• Text will be split into sentences (not lines)\n"
+            "• Each sentence appears on its own line\n"
+            "• Original line breaks will not be preserved\n\n"
+            "This is useful for comparing prose where sentences\n"
+            "may span multiple lines or be wrapped differently.\n\n"
+            "Continue with Sentence Mode?"
+        )
+        return messagebox.askyesno(
+            "Sentence Mode", 
+            message,
+            icon=messagebox.WARNING
+        )
+    
+    def _on_char_level_change(self):
+        """Handle character-level diff toggle."""
+        char_level = self.char_level_var.get()
+        self.diff_viewer.update_settings({"char_level_diff": char_level})
+        
+        # Re-run comparison with new setting
+        self._run_comparison()
+        
+        if self.on_setting_change:
+            self.on_setting_change("Diff Viewer", {"char_level_diff": char_level})
+    
+    def _on_detect_moved_change(self):
+        """Handle detect moved lines toggle."""
+        detect_moved = self.detect_moved_var.get()
+        self.diff_viewer.update_settings({"detect_moved": detect_moved})
+        
+        # Re-run comparison with new setting
+        self._run_comparison()
+        
+        if self.on_setting_change:
+            self.on_setting_change("Diff Viewer", {"detect_moved": detect_moved})
+    
+    def _on_syntax_change(self):
+        """Handle syntax highlighting toggle."""
+        syntax = self.syntax_var.get()
+        self.diff_viewer.update_settings({"syntax_highlight": syntax})
+        
+        # Re-run comparison with new setting
+        self._run_comparison()
+        
+        if self.on_setting_change:
+            self.on_setting_change("Diff Viewer", {"syntax_highlight": syntax})
+    
     def _run_comparison(self):
         """Run the diff comparison."""
         option = self.option_var.get()
+        # Reset comparison source and clean widget content of accumulated blanks
+        self.diff_viewer.reset_comparison_source()
         self.diff_viewer.run_comparison(option)
     
     def _launch_list_comparator(self):
@@ -1048,7 +1777,7 @@ class DiffViewerSettingsWidget:
                                 startupinfo.wShowWindow = subprocess.SW_HIDE
                                 subprocess.Popen([sys.executable, list_comparator_path], 
                                                startupinfo=startupinfo)
-                        except:
+                        except Exception:
                             # Final fallback
                             subprocess.Popen([sys.executable, list_comparator_path])
                     else:
@@ -1069,4 +1798,20 @@ class DiffViewerSettingsWidget:
     
     def get_settings(self):
         """Get current settings."""
-        return {"option": self.option_var.get()}
+        return {"option": self.option_var.get()}
+    
+    def _show_warning(self, title, message):
+        """Show warning dialog using DialogManager if available, otherwise use messagebox."""
+        if hasattr(self.diff_viewer, '_show_warning'):
+            return self.diff_viewer._show_warning(title, message)
+        else:
+            messagebox.showwarning(title, message, parent=self.parent)
+            return True
+    
+    def _show_error(self, title, message):
+        """Show error dialog using DialogManager if available, otherwise use messagebox."""
+        if hasattr(self.diff_viewer, '_show_error'):
+            return self.diff_viewer._show_error(title, message)
+        else:
+            messagebox.showerror(title, message, parent=self.parent)
+            return True