pomera-ai-commander 0.1.0

package/tools/whitespace_tools.py

@@ -0,0 +1,356 @@
+"""
+Whitespace Tools Module - Whitespace manipulation utilities
+
+This module provides comprehensive whitespace manipulation functionality with a tabbed UI interface
+for the Pomera AI Commander application.
+
+Features:
+- Trim Lines: Remove leading/trailing whitespace per line
+- Remove Extra Spaces: Collapse multiple spaces to single
+- Tabs to Spaces: Convert tabs to spaces
+- Spaces to Tabs: Convert spaces to tabs
+- Normalize Line Endings: Convert to LF/CRLF/CR
+"""
+
+import tkinter as tk
+from tkinter import ttk
+import re
+
+
+class WhitespaceToolsProcessor:
+    """Whitespace tools processor with various whitespace manipulation capabilities."""
+    
+    @staticmethod
+    def trim_lines(text, mode="both"):
+        """Trim whitespace from lines."""
+        lines = text.splitlines()
+        result = []
+        
+        for line in lines:
+            if mode == "leading":
+                result.append(line.lstrip())
+            elif mode == "trailing":
+                result.append(line.rstrip())
+            else:  # both
+                result.append(line.strip())
+        
+        return '\n'.join(result)
+    
+    @staticmethod
+    def remove_extra_spaces(text, preserve_indent=False):
+        """Collapse multiple spaces to single space."""
+        lines = text.splitlines()
+        result = []
+        
+        for line in lines:
+            if preserve_indent:
+                stripped = line.lstrip()
+                indent = line[:len(line) - len(stripped)]
+                collapsed = re.sub(r' {2,}', ' ', stripped)
+                result.append(indent + collapsed)
+            else:
+                result.append(re.sub(r' {2,}', ' ', line))
+        
+        return '\n'.join(result)
+    
+    @staticmethod
+    def tabs_to_spaces(text, tab_size=4):
+        """Convert tabs to spaces."""
+        return text.replace('\t', ' ' * tab_size)
+    
+    @staticmethod
+    def spaces_to_tabs(text, tab_size=4):
+        """Convert leading spaces to tabs."""
+        lines = text.splitlines()
+        result = []
+        
+        for line in lines:
+            if not line.strip():
+                result.append(line)
+                continue
+            
+            stripped = line.lstrip(' ')
+            leading_spaces = len(line) - len(stripped)
+            tabs = leading_spaces // tab_size
+            remaining_spaces = leading_spaces % tab_size
+            result.append('\t' * tabs + ' ' * remaining_spaces + stripped)
+        
+        return '\n'.join(result)
+    
+    @staticmethod
+    def normalize_line_endings(text, ending="lf"):
+        """Normalize line endings."""
+        text = text.replace('\r\n', '\n').replace('\r', '\n')
+        
+        if ending == "crlf":
+            return text.replace('\n', '\r\n')
+        elif ending == "cr":
+            return text.replace('\n', '\r')
+        else:  # lf
+            return text
+    
+    @staticmethod
+    def process_text(input_text, tool_type, settings):
+        """Process text using the specified whitespace tool and settings."""
+        if tool_type == "Trim Lines":
+            return WhitespaceToolsProcessor.trim_lines(
+                input_text,
+                settings.get("trim_mode", "both")
+            )
+        elif tool_type == "Remove Extra Spaces":
+            return WhitespaceToolsProcessor.remove_extra_spaces(
+                input_text,
+                settings.get("preserve_indent", False)
+            )
+        elif tool_type == "Tabs to Spaces":
+            return WhitespaceToolsProcessor.tabs_to_spaces(
+                input_text,
+                settings.get("tab_size", 4)
+            )
+        elif tool_type == "Spaces to Tabs":
+            return WhitespaceToolsProcessor.spaces_to_tabs(
+                input_text,
+                settings.get("tab_size", 4)
+            )
+        elif tool_type == "Normalize Line Endings":
+            return WhitespaceToolsProcessor.normalize_line_endings(
+                input_text,
+                settings.get("line_ending", "lf")
+            )
+        else:
+            return f"Unknown whitespace tool: {tool_type}"
+
+
+class WhitespaceToolsWidget(ttk.Frame):
+    """Tabbed interface widget for whitespace tools."""
+    
+    def __init__(self, parent, app):
+        super().__init__(parent)
+        self.app = app
+        self.processor = WhitespaceToolsProcessor()
+        
+        self.trim_mode = tk.StringVar(value="both")
+        self.preserve_indent = tk.BooleanVar(value=False)
+        self.tab_size = tk.IntVar(value=4)
+        self.line_ending = tk.StringVar(value="lf")
+        
+        self.create_widgets()
+        self.load_settings()
+    
+    def create_widgets(self):
+        """Creates the tabbed interface for whitespace tools."""
+        self.notebook = ttk.Notebook(self)
+        self.notebook.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
+        
+        self.create_trim_tab()
+        self.create_extra_spaces_tab()
+        self.create_tabs_spaces_tab()
+        self.create_line_endings_tab()
+    
+    def create_trim_tab(self):
+        """Creates the Trim Lines tab."""
+        frame = ttk.Frame(self.notebook)
+        self.notebook.add(frame, text="Trim Lines")
+        
+        mode_frame = ttk.LabelFrame(frame, text="Trim Mode", padding=10)
+        mode_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        ttk.Radiobutton(mode_frame, text="Both (leading and trailing)", 
+                       variable=self.trim_mode, value="both",
+                       command=self.on_setting_change).pack(anchor=tk.W)
+        ttk.Radiobutton(mode_frame, text="Leading only", 
+                       variable=self.trim_mode, value="leading",
+                       command=self.on_setting_change).pack(anchor=tk.W)
+        ttk.Radiobutton(mode_frame, text="Trailing only", 
+                       variable=self.trim_mode, value="trailing",
+                       command=self.on_setting_change).pack(anchor=tk.W)
+        
+        ttk.Button(frame, text="Trim Lines", 
+                  command=lambda: self.process("Trim Lines")).pack(pady=10)
+    
+    def create_extra_spaces_tab(self):
+        """Creates the Remove Extra Spaces tab."""
+        frame = ttk.Frame(self.notebook)
+        self.notebook.add(frame, text="Extra Spaces")
+        
+        options_frame = ttk.LabelFrame(frame, text="Options", padding=10)
+        options_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        ttk.Checkbutton(options_frame, text="Preserve Indentation", 
+                       variable=self.preserve_indent,
+                       command=self.on_setting_change).pack(anchor=tk.W)
+        
+        info = ttk.Label(frame, text="Collapses multiple consecutive spaces into a single space.",
+                        justify=tk.CENTER)
+        info.pack(pady=10)
+        
+        ttk.Button(frame, text="Remove Extra Spaces", 
+                  command=lambda: self.process("Remove Extra Spaces")).pack(pady=10)
+    
+    def create_tabs_spaces_tab(self):
+        """Creates the Tabs/Spaces conversion tab."""
+        frame = ttk.Frame(self.notebook)
+        self.notebook.add(frame, text="Tabs/Spaces")
+        
+        size_frame = ttk.LabelFrame(frame, text="Tab Size", padding=10)
+        size_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        ttk.Label(size_frame, text="Spaces per tab:").pack(side=tk.LEFT)
+        ttk.Spinbox(size_frame, from_=1, to=8, width=4,
+                   textvariable=self.tab_size,
+                   command=self.on_setting_change).pack(side=tk.LEFT, padx=5)
+        
+        buttons_frame = ttk.Frame(frame)
+        buttons_frame.pack(pady=10)
+        
+        ttk.Button(buttons_frame, text="Tabs -> Spaces", 
+                  command=lambda: self.process("Tabs to Spaces")).pack(side=tk.LEFT, padx=5)
+        ttk.Button(buttons_frame, text="Spaces -> Tabs", 
+                  command=lambda: self.process("Spaces to Tabs")).pack(side=tk.LEFT, padx=5)
+    
+    def create_line_endings_tab(self):
+        """Creates the Line Endings tab."""
+        frame = ttk.Frame(self.notebook)
+        self.notebook.add(frame, text="Line Endings")
+        
+        ending_frame = ttk.LabelFrame(frame, text="Target Line Ending", padding=10)
+        ending_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        ttk.Radiobutton(ending_frame, text="LF (Unix/Linux/macOS)", 
+                       variable=self.line_ending, value="lf",
+                       command=self.on_setting_change).pack(anchor=tk.W)
+        ttk.Radiobutton(ending_frame, text="CRLF (Windows)", 
+                       variable=self.line_ending, value="crlf",
+                       command=self.on_setting_change).pack(anchor=tk.W)
+        ttk.Radiobutton(ending_frame, text="CR (Classic Mac)", 
+                       variable=self.line_ending, value="cr",
+                       command=self.on_setting_change).pack(anchor=tk.W)
+        
+        ttk.Button(frame, text="Normalize Line Endings", 
+                  command=lambda: self.process("Normalize Line Endings")).pack(pady=10)
+    
+    def load_settings(self):
+        """Load settings from the application."""
+        settings = self.app.settings.get("tool_settings", {}).get("Whitespace Tools", {})
+        
+        self.trim_mode.set(settings.get("trim_mode", "both"))
+        self.preserve_indent.set(settings.get("preserve_indent", False))
+        self.tab_size.set(settings.get("tab_size", 4))
+        self.line_ending.set(settings.get("line_ending", "lf"))
+    
+    def save_settings(self):
+        """Save current settings to the application."""
+        if "Whitespace Tools" not in self.app.settings["tool_settings"]:
+            self.app.settings["tool_settings"]["Whitespace Tools"] = {}
+        
+        self.app.settings["tool_settings"]["Whitespace Tools"].update({
+            "trim_mode": self.trim_mode.get(),
+            "preserve_indent": self.preserve_indent.get(),
+            "tab_size": self.tab_size.get(),
+            "line_ending": self.line_ending.get()
+        })
+        
+        self.app.save_settings()
+    
+    def on_setting_change(self, *args):
+        """Handle setting changes."""
+        self.save_settings()
+    
+    def process(self, tool_type):
+        """Process the input text with the selected tool."""
+        active_input_tab = self.app.input_tabs[self.app.input_notebook.index(self.app.input_notebook.select())]
+        input_text = active_input_tab.text.get("1.0", tk.END).rstrip('\n')
+        
+        if not input_text.strip():
+            return
+        
+        settings = {
+            "trim_mode": self.trim_mode.get(),
+            "preserve_indent": self.preserve_indent.get(),
+            "tab_size": self.tab_size.get(),
+            "line_ending": self.line_ending.get()
+        }
+        
+        result = WhitespaceToolsProcessor.process_text(input_text, tool_type, settings)
+        
+        active_output_tab = self.app.output_tabs[self.app.output_notebook.index(self.app.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")
+        
+        self.app.update_all_stats()
+
+
+class WhitespaceTools:
+    """Main class for Whitespace Tools integration."""
+    
+    def __init__(self):
+        self.processor = WhitespaceToolsProcessor()
+    
+    def create_widget(self, parent, app):
+        """Create and return the Whitespace Tools widget."""
+        return WhitespaceToolsWidget(parent, app)
+    
+    def get_default_settings(self):
+        """Return default settings for Whitespace Tools."""
+        return {
+            "trim_mode": "both",
+            "preserve_indent": False,
+            "tab_size": 4,
+            "line_ending": "lf"
+        }
+    
+    def process_text(self, input_text, tool_type, settings):
+        """Process text using the specified tool and settings."""
+        return WhitespaceToolsProcessor.process_text(input_text, tool_type, settings)
+
+
+# BaseTool-compatible wrapper
+try:
+    from tools.base_tool import ToolWithOptions
+    from typing import Dict, Any
+    
+    class WhitespaceToolsV2(ToolWithOptions):
+        """
+        BaseTool-compatible version of WhitespaceTools.
+        """
+        
+        TOOL_NAME = "Whitespace Tools"
+        TOOL_DESCRIPTION = "Trim lines, remove extra spaces, convert tabs/spaces, normalize line endings"
+        TOOL_VERSION = "2.0.0"
+        
+        OPTIONS = [
+            ("Trim Lines", "trim"),
+            ("Remove Extra Spaces", "remove_extra"),
+            ("Tabs to Spaces", "tabs_to_spaces"),
+            ("Spaces to Tabs", "spaces_to_tabs"),
+            ("Normalize Line Endings", "normalize"),
+        ]
+        OPTIONS_LABEL = "Operation"
+        USE_DROPDOWN = True
+        DEFAULT_OPTION = "trim"
+        
+        def __init__(self):
+            super().__init__()
+            self._processor = WhitespaceToolsProcessor()
+        
+        def process_text(self, input_text: str, settings: Dict[str, Any]) -> str:
+            """Process text using the specified whitespace operation."""
+            mode = settings.get("mode", "trim")
+            
+            if mode == "trim":
+                return WhitespaceToolsProcessor.trim_lines(input_text)
+            elif mode == "remove_extra":
+                return WhitespaceToolsProcessor.remove_extra_spaces(input_text)
+            elif mode == "tabs_to_spaces":
+                return WhitespaceToolsProcessor.tabs_to_spaces(input_text, settings.get("tab_size", 4))
+            elif mode == "spaces_to_tabs":
+                return WhitespaceToolsProcessor.spaces_to_tabs(input_text, settings.get("tab_size", 4))
+            elif mode == "normalize":
+                return WhitespaceToolsProcessor.normalize_line_endings(input_text, settings.get("line_ending", "lf"))
+            else:
+                return input_text
+
+except ImportError:
+    pass

package/tools/word_frequency_counter.py

@@ -0,0 +1,147 @@
+"""
+Word Frequency Counter Module - Text word frequency analysis utility
+
+This module provides comprehensive word frequency analysis functionality with UI components
+for the Promera AI Commander application.
+"""
+
+import tkinter as tk
+from tkinter import ttk
+import re
+from collections import Counter
+
+
+class WordFrequencyCounterProcessor:
+    """Word frequency counter processor with detailed word analysis capabilities."""
+    
+    @staticmethod
+    def word_frequency(text):
+        """Counts the frequency of each word in the text."""
+        words = re.findall(r'\b\w+\b', text.lower())
+        if not words:
+            return "No words found."
+        
+        word_counts = Counter(words)
+        total_words = len(words)
+        
+        report = []
+        for word, count in word_counts.most_common():
+            percentage = (count / total_words) * 100
+            report.append(f"{word} ({count} / {percentage:.2f}%)")
+        return '\n'.join(report)
+
+    @staticmethod
+    def process_text(input_text, settings=None):
+        """Process text using the current settings."""
+        # Word Frequency Counter doesn't need settings currently, but keeping for consistency
+        return WordFrequencyCounterProcessor.word_frequency(input_text)
+
+
+class WordFrequencyCounterUI:
+    """UI components for the Word Frequency Counter."""
+    
+    def __init__(self, parent, settings, on_setting_change_callback=None, apply_tool_callback=None):
+        """
+        Initialize the Word Frequency Counter UI.
+        
+        Args:
+            parent: Parent widget
+            settings: Dictionary containing tool settings (currently unused)
+            on_setting_change_callback: Callback function for setting changes
+            apply_tool_callback: Callback function for applying the tool
+        """
+        self.parent = parent
+        self.settings = settings
+        self.on_setting_change_callback = on_setting_change_callback
+        self.apply_tool_callback = apply_tool_callback
+        
+        self.create_widgets()
+
+    def create_widgets(self):
+        """Creates the UI widgets for the Word Frequency Counter."""
+        # Count button
+        if self.apply_tool_callback:
+            ttk.Button(
+                self.parent, 
+                text="Count", 
+                command=self.apply_tool_callback
+            ).pack(side=tk.LEFT, padx=10)
+
+    def get_current_settings(self):
+        """Get the current settings from the UI."""
+        # Word Frequency Counter doesn't have settings currently
+        return {}
+
+    def update_settings(self, settings):
+        """Update the UI with new settings."""
+        # Word Frequency Counter doesn't have settings currently
+        pass
+
+
+class WordFrequencyCounter:
+    """Main Word Frequency Counter class that combines processor and UI functionality."""
+    
+    def __init__(self):
+        self.processor = WordFrequencyCounterProcessor()
+        self.ui = None
+        
+    def create_ui(self, parent, settings, on_setting_change_callback=None, apply_tool_callback=None):
+        """Create and return the UI component."""
+        self.ui = WordFrequencyCounterUI(parent, settings, on_setting_change_callback, apply_tool_callback)
+        return self.ui
+        
+    def process_text(self, input_text, settings=None):
+        """Process text using the current settings."""
+        return self.processor.process_text(input_text, settings)
+        
+    def get_default_settings(self):
+        """Get default settings for the Word Frequency Counter."""
+        # Word Frequency Counter doesn't have settings currently
+        return {}
+
+
+# Convenience functions for backward compatibility
+def word_frequency(text):
+    """Count word frequency in text."""
+    return WordFrequencyCounterProcessor.word_frequency(text)
+
+
+def process_word_frequency(input_text, settings=None):
+    """Process word frequency analysis with the specified settings."""
+    return WordFrequencyCounterProcessor.process_text(input_text, settings)
+
+
+# BaseTool-compatible wrapper
+try:
+    from tools.base_tool import BaseTool
+    from typing import Dict, Any
+    import tkinter as tk
+    from tkinter import ttk
+    
+    class WordFrequencyCounterV2(BaseTool):
+        """
+        BaseTool-compatible version of WordFrequencyCounter.
+        """
+        
+        TOOL_NAME = "Word Frequency Counter"
+        TOOL_DESCRIPTION = "Count frequency of each word in text"
+        TOOL_VERSION = "2.0.0"
+        
+        def process_text(self, input_text: str, settings: Dict[str, Any]) -> str:
+            """Process text and return word frequencies."""
+            return WordFrequencyCounterProcessor.word_frequency(input_text)
+        
+        def get_default_settings(self) -> Dict[str, Any]:
+            return {}
+        
+        def create_ui(self, parent: tk.Widget, settings: Dict[str, Any], 
+                     on_change=None, on_apply=None) -> tk.Widget:
+            """Create a simple UI for Word Frequency Counter."""
+            frame = ttk.Frame(parent)
+            ttk.Label(frame, text="Count word frequencies").pack(side=tk.LEFT, padx=5)
+            if on_apply:
+                ttk.Button(frame, text="Count", command=on_apply).pack(side=tk.LEFT, padx=5)
+            return frame
+
+except ImportError:
+    pass