pomera-ai-commander 1.2.5 → 1.2.8

package/tools/base64_tools.py

@@ -53,9 +53,10 @@ class Base64Tools:
 class Base64ToolsWidget:
     """Widget for the Base64 Tools interface."""
     
-    def __init__(self, base64_tools):
+    def __init__(self, base64_tools=None):
         """Initialize the Base64ToolsWidget."""
-        self.base64_tools = base64_tools
+        # Create Base64Tools instance if not provided
+        self.base64_tools = base64_tools if base64_tools else Base64Tools()
         self.main_app = None
         
         # Variables for Base64 mode
@@ -102,8 +103,7 @@ class Base64ToolsWidget:
     def on_mode_change(self):
         """Handle mode change and save settings."""
         self.save_settings()
-        # Auto-process if there's input text
-        self.process_base64()
+        # Don't auto-process - wait for Process button click
     
     def process_base64(self):
         """Process the input text with Base64 encoding/decoding."""

package/tools/curl_history.py

@@ -46,33 +46,39 @@ class CurlHistoryManager:
     Manages request history persistence and organization for the cURL Tool.
     
     Handles:
-    - History file storage and loading
+    - History file storage and loading (JSON or database backend)
     - History item management (add, remove, search)
     - History cleanup and organization
     - Collections support
     """
     
     def __init__(self, history_file: str = "settings.json", 
-                 max_items: int = 100, logger=None):
+                 max_items: int = 100, logger=None, db_settings_manager=None):
         """
         Initialize the history manager.
         
         Args:
-            history_file: Path to the main settings file
+            history_file: Path to the main settings file (used if no db_settings_manager)
             max_items: Maximum number of history items to keep
             logger: Logger instance for debugging
+            db_settings_manager: DatabaseSettingsManager instance for database backend (optional)
         """
         self.history_file = history_file
         self.max_items = max_items
         self.logger = logger or logging.getLogger(__name__)
         self.tool_key = "cURL Tool"  # Key in tool_settings section
         
+        # Database backend support
+        self.db_settings_manager = db_settings_manager
+        self.use_database = db_settings_manager is not None
+        
         # History storage
         self.history: List[RequestHistoryItem] = []
         self.collections: Dict[str, List[str]] = {}  # Collection name -> list of history item IDs
         
         # Load history on initialization
         self.load_history()
+
     
     def add_request(self, method: str, url: str, headers: Dict[str, str] = None,
                    body: str = None, auth_type: str = "None", 
@@ -505,12 +511,34 @@ class CurlHistoryManager:
     
     def load_history(self) -> bool:
         """
-        Load history from centralized settings.json file.
+        Load history from database or settings.json file.
         
         Returns:
             True if successful
         """
         try:
+            if self.use_database and self.db_settings_manager:
+                # Load from database backend
+                curl_settings = self.db_settings_manager.get_tool_settings(self.tool_key)
+                if curl_settings:
+                    # Load history items
+                    self.history = []
+                    for item_data in curl_settings.get("history", []):
+                        try:
+                            item = RequestHistoryItem.from_dict(item_data)
+                            self.history.append(item)
+                        except Exception as e:
+                            self.logger.warning(f"Error loading history item: {e}")
+                    
+                    # Load collections
+                    self.collections = curl_settings.get("collections", {})
+                    
+                    self.logger.info(f"Loaded {len(self.history)} history items from database")
+                else:
+                    self.logger.info("No history found in database, starting with empty history")
+                return True
+            
+            # Fallback to JSON file
             if os.path.exists(self.history_file):
                 with open(self.history_file, 'r', encoding='utf-8') as f:
                     all_settings = json.load(f)
@@ -543,12 +571,24 @@ class CurlHistoryManager:
     
     def save_history(self) -> bool:
         """
-        Save history to centralized settings.json file.
+        Save history to database or settings.json file.
         
         Returns:
             True if successful
         """
         try:
+            if self.use_database and self.db_settings_manager:
+                # Save to database backend
+                history_data = [item.to_dict() for item in self.history]
+                self.db_settings_manager.set_tool_setting(self.tool_key, "history", history_data)
+                self.db_settings_manager.set_tool_setting(self.tool_key, "collections", self.collections)
+                self.db_settings_manager.set_tool_setting(self.tool_key, "history_last_updated", datetime.now().isoformat())
+                self.db_settings_manager.set_tool_setting(self.tool_key, "history_version", "1.0")
+                
+                self.logger.debug("History saved to database")
+                return True
+            
+            # Fallback to JSON file
             # Load existing settings file
             all_settings = {}
             if os.path.exists(self.history_file):

package/tools/curl_tool.py

@@ -60,6 +60,17 @@ except ImportError:
         CURL_HISTORY_AVAILABLE = False
         print("cURL modules not available")
 
+# Import database-compatible settings manager
+try:
+    from core.database_curl_settings_manager import DatabaseCurlSettingsManager
+    DATABASE_CURL_SETTINGS_AVAILABLE = True
+except ImportError:
+    try:
+        from ..core.database_curl_settings_manager import DatabaseCurlSettingsManager
+        DATABASE_CURL_SETTINGS_AVAILABLE = True
+    except ImportError:
+        DATABASE_CURL_SETTINGS_AVAILABLE = False
+
 
 def get_system_encryption_key():
     """Generate encryption key based on system characteristics (same as AI Tools)"""
@@ -138,7 +149,7 @@ class CurlToolWidget:
     with the application's tool ecosystem.
     """
     
-    def __init__(self, parent, logger=None, send_to_input_callback=None, dialog_manager=None):
+    def __init__(self, parent, logger=None, send_to_input_callback=None, dialog_manager=None, db_settings_manager=None):
         """
         Initialize the cURL Tool widget.
         
@@ -147,21 +158,30 @@ class CurlToolWidget:
             logger: Logger instance for debugging
             send_to_input_callback: Callback function to send content to input tabs
             dialog_manager: DialogManager instance for configurable dialogs
+            db_settings_manager: DatabaseSettingsManager instance for database backend (optional)
         """
         self.parent = parent
         self.logger = logger or logging.getLogger(__name__)
         self.send_to_input_callback = send_to_input_callback
         self.dialog_manager = dialog_manager
+        self.db_settings_manager = db_settings_manager  # Store for database backend
         
-        # Initialize processor and settings manager
+        # Initialize processor
         if CURL_PROCESSOR_AVAILABLE:
             self.processor = CurlProcessor()
         else:
             self.processor = None
             self.logger.error("cURL Processor not available")
         
-        if CURL_SETTINGS_AVAILABLE:
+        # Initialize settings manager - prefer database backend if available
+        if db_settings_manager and DATABASE_CURL_SETTINGS_AVAILABLE:
+            # Use database-backed settings manager
+            self.settings_manager = DatabaseCurlSettingsManager(db_settings_manager, logger=self.logger)
+            self.logger.info("cURL Tool using database backend for settings")
+        elif CURL_SETTINGS_AVAILABLE:
+            # Fallback to JSON-based settings manager
             self.settings_manager = CurlSettingsManager(logger=self.logger)
+            self.logger.info("cURL Tool using JSON backend for settings (database not available)")
         else:
             self.settings_manager = None
             self.logger.error("cURL Settings Manager not available")
@@ -174,7 +194,7 @@ class CurlToolWidget:
         
         # Settings - load from settings manager or use defaults (must be loaded before history manager)
         if self.settings_manager:
-            self.settings = self.settings_manager.get_all_settings()
+            self.settings = self.settings_manager.load_settings()
         else:
             self.settings = {
                 "timeout": 30,
@@ -190,16 +210,26 @@ class CurlToolWidget:
                 "history_retention_days": 30
             }
         
+        # Initialize history manager - use database backend if available
         if CURL_HISTORY_AVAILABLE:
             max_history = self.settings.get("max_history_items", 100)
-            # Use centralized settings.json file
-            history_file = os.path.abspath("settings.json")
-            self.history_manager = CurlHistoryManager(
-                history_file=history_file, 
-                max_items=max_history, 
-                logger=self.logger
-            )
-            self.logger.debug(f"History manager initialized with file: {history_file}")
+            if db_settings_manager and DATABASE_CURL_SETTINGS_AVAILABLE:
+                # Use database backend for history (through DatabaseCurlSettingsManager)
+                self.history_manager = CurlHistoryManager(
+                    max_items=max_history, 
+                    logger=self.logger,
+                    db_settings_manager=db_settings_manager
+                )
+                self.logger.debug("History manager initialized with database backend")
+            else:
+                # Fallback to JSON file
+                history_file = os.path.abspath("settings.json")
+                self.history_manager = CurlHistoryManager(
+                    history_file=history_file, 
+                    max_items=max_history, 
+                    logger=self.logger
+                )
+                self.logger.debug(f"History manager initialized with file: {history_file}")
         else:
             self.history_manager = None
             self.logger.error("cURL History Manager not available")

package/tools/diff_viewer.py

@@ -458,7 +458,8 @@ class DiffViewerWidget:
 
     def show(self):
         """Show the diff viewer."""
-        self.diff_frame.grid(row=0, column=0, sticky="nsew", pady=5)
+        # Use row=1 (same as central_frame) to not cover search bar in row=0
+        self.diff_frame.grid(row=1, column=0, sticky="nsew", pady=5)
 
     def hide(self):
         """Hide the diff viewer."""
@@ -1658,14 +1659,6 @@ class DiffViewerSettingsWidget:
             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(
-            row2, 
-            text="List Comparator", 
-            command=self._launch_list_comparator
-        ).pack(side=tk.LEFT, padx=5)
     
     def _on_option_change(self):
         """Handle option change."""

package/tools/notes_widget.py

@@ -716,9 +716,16 @@ class NotesWidget:
 • Search specific columns: Title:refactor OR Input:code.
 • Leave empty to show all records."""
         if self.dialog_manager:
-            self.dialog_manager.show_info("Search Help", help_text)
+            self.dialog_manager.show_info("Search Help", help_text, parent=self.parent)
         else:
             messagebox.showinfo("Search Help", help_text, parent=self.parent)
+        
+        # Return focus to Notes window after dialog closes
+        try:
+            self.parent.focus_force()
+            self.search_entry.focus_set()
+        except Exception:
+            pass  # Widget may not exist
     
     def new_note(self) -> None:
         """Create a new note."""

package/tools/tool_loader.py

@@ -9,10 +9,20 @@ Author: Pomera AI Commander Team
 
 import importlib
 import logging
+import threading
 from typing import Dict, Any, Optional, Callable, Type, List, Tuple
 from dataclasses import dataclass, field
 from enum import Enum
 
+# Optional rapidfuzz for fuzzy search
+try:
+    from rapidfuzz import fuzz, process
+    RAPIDFUZZ_AVAILABLE = True
+except ImportError:
+    fuzz = None
+    process = None
+    RAPIDFUZZ_AVAILABLE = False
+
 
 logger = logging.getLogger(__name__)
 
@@ -68,12 +78,11 @@ TOOL_SPECS: Dict[str, ToolSpec] = {
         description="Transform text case (uppercase, lowercase, title case, etc.)",
         available_flag="CASE_TOOL_MODULE_AVAILABLE"
     ),
-    "Find & Replace": ToolSpec(
-        name="Find & Replace",
+    "Find & Replace Text": ToolSpec(
+        name="Find & Replace Text",
         module_path="tools.find_replace",
         class_name="FindReplaceWidget",
         category=ToolCategory.CORE,
-        is_widget=True,
         description="Find and replace text with regex support",
         available_flag="FIND_REPLACE_MODULE_AVAILABLE"
     ),
@@ -83,7 +92,6 @@ TOOL_SPECS: Dict[str, ToolSpec] = {
         class_name="DiffViewerWidget",
         widget_class="DiffViewerSettingsWidget",
         category=ToolCategory.CORE,
-        is_widget=True,
         description="Compare and view differences between texts",
         available_flag="DIFF_VIEWER_MODULE_AVAILABLE"
     ),
@@ -94,7 +102,6 @@ TOOL_SPECS: Dict[str, ToolSpec] = {
         module_path="tools.ai_tools",
         class_name="AIToolsWidget",
         category=ToolCategory.AI,
-        is_widget=True,
         description="AI-powered text processing with multiple providers",
         available_flag="AI_TOOLS_AVAILABLE"
     ),
@@ -158,8 +165,8 @@ TOOL_SPECS: Dict[str, ToolSpec] = {
     ),
     
     # Conversion Tools
-    "Base64 Tools": ToolSpec(
-        name="Base64 Tools",
+    "Base64 Encoder/Decoder": ToolSpec(
+        name="Base64 Encoder/Decoder",
         module_path="tools.base64_tools",
         class_name="Base64Tools",
         widget_class="Base64ToolsWidget",
@@ -294,20 +301,13 @@ TOOL_SPECS: Dict[str, ToolSpec] = {
     ),
     
     # Analysis Tools
-    "Word Frequency Counter": ToolSpec(
-        name="Word Frequency Counter",
-        module_path="tools.word_frequency_counter",
-        class_name="WordFrequencyCounter",
-        category=ToolCategory.ANALYSIS,
-        description="Count word frequencies in text",
-        available_flag="WORD_FREQUENCY_COUNTER_MODULE_AVAILABLE"
-    ),
+    # NOTE: Word Frequency Counter merged into Text Statistics (has "Word Frequency Counter" button)
     "Text Statistics": ToolSpec(
         name="Text Statistics",
         module_path="tools.text_statistics_tool",
         class_name="TextStatistics",
         category=ToolCategory.ANALYSIS,
-        description="Calculate text statistics (chars, words, lines)",
+        description="Text stats, character/word/line counts, word frequency",
         available_flag="TEXT_STATISTICS_MODULE_AVAILABLE"
     ),
     "Cron Tool": ToolSpec(
@@ -334,6 +334,7 @@ TOOL_SPECS: Dict[str, ToolSpec] = {
         module_path="tools.list_comparator",
         class_name="DiffApp",
         category=ToolCategory.UTILITY,
+        is_widget=True,  # Exclude from search - standalone widget
         description="Compare two lists and find differences",
         available_flag="LIST_COMPARATOR_MODULE_AVAILABLE"
     ),
@@ -367,6 +368,89 @@ TOOL_SPECS: Dict[str, ToolSpec] = {
     ),
 }
 
+# These sub-tools appear as tabs within their parent tool
+PARENT_TOOLS = {
+    "AI Tools": [
+        # Tab order from UI screenshot
+        "Google AI",
+        "Vertex AI",
+        "Azure AI",
+        "Anthropic AI",
+        "OpenAI",
+        "Cohere AI",
+        "HuggingFace AI",
+        "Groq AI",
+        "OpenRouterAI",
+        "LM Studio",
+        "AWS Bedrock",
+    ],
+    "Extraction Tools": [
+        "Email Extraction",
+        "HTML Tool", 
+        "Regex Extractor",
+        "URL Link Extractor",
+    ],
+    "Generator Tools": [
+        # Tab order: Strong Password | Repeating Text | Lorem Ipsum | UUID/GUID | Random Email | ASCII Art | Hash | Slug
+        "Strong Password Generator",
+        "Repeating Text Generator",
+        "Lorem Ipsum Generator",
+        "UUID/GUID Generator",
+        "Random Email Generator",
+        "ASCII Art Generator",
+        "Hash Generator",
+        "Slug Generator",
+    ],
+    "Line Tools": [
+        # Tab order from line_tools.py
+        "Remove Duplicates",
+        "Remove Empty Lines",
+        "Add Line Numbers",
+        "Remove Line Numbers",
+        "Reverse Lines",
+        "Shuffle Lines",
+    ],
+    "Markdown Tools": [
+        # Tab order from markdown_tools.py
+        "Strip Markdown",
+        "Extract Links",
+        "Extract Headers",
+        "Table to CSV",
+        "Format Table",
+    ],
+    "Sorter Tools": [
+        # Tab order from sorter_tools.py
+        "Number Sorter",
+        "Alphabetical Sorter",
+    ],
+    "Text Wrapper": [
+        # Tab order from text_wrapper.py
+        "Word Wrap",
+        "Justify Text",
+        "Prefix/Suffix",
+        "Indent Text",
+        "Quote Text",
+    ],
+    "Translator Tools": [
+        # Tab order from translator_tools.py
+        "Morse Code Translator",
+        "Binary Code Translator",
+    ],
+    "Whitespace Tools": [
+        # Tab order from whitespace_tools.py
+        "Trim Lines",
+        "Remove Extra Spaces",
+        "Tabs/Spaces Converter",
+        "Normalize Line Endings",
+    ],
+}
+
+# Reverse lookup: sub-tool -> parent
+SUB_TOOL_PARENTS = {
+    sub: parent
+    for parent, subs in PARENT_TOOLS.items()
+    for sub in subs
+}
 
 class ToolLoader:
     """
@@ -588,6 +672,75 @@ class ToolLoader:
             if spec.category == category and self.is_available(name)
         ]
     
+    def get_processing_tools(self) -> List[str]:
+        """
+        Get list of available text processing tools (excludes standalone widgets).
+        
+        This filters out tools like Notes Widget, MCP Manager that are 
+        standalone windows rather than text processing tools.
+        
+        Returns:
+            List of processing tool names
+        """
+        return [
+            name for name, spec in self._specs.items()
+            if self.is_available(name) and not spec.is_widget
+        ]
+    
+    def get_processing_tools_by_category(self, category: ToolCategory) -> List[str]:
+        """
+        Get processing tools in a specific category (excludes standalone widgets).
+        
+        Args:
+            category: Tool category
+            
+        Returns:
+            List of processing tool names in that category
+        """
+        return [
+            name for name, spec in self._specs.items()
+            if spec.category == category and self.is_available(name) and not spec.is_widget
+        ]
+    
+    def get_grouped_tools(self) -> List[Tuple[str, bool]]:
+        """
+        Get processing tools grouped with parent-child relationships.
+        
+        Returns tools sorted alphabetically, with sub-tools appearing
+        immediately after their parent tool.
+        
+        Returns:
+            List of tuples: (tool_name, is_sub_tool)
+            is_sub_tool is True for tools that belong under a parent
+        """
+        # Get all processing tools (excludes widgets)
+        all_tools = set(self.get_processing_tools())
+        
+        # Build result with grouping
+        result: List[Tuple[str, bool]] = []
+        processed = set()
+        
+        # Sort main tools alphabetically
+        main_tools = sorted([t for t in all_tools if t not in SUB_TOOL_PARENTS])
+        
+        for tool in main_tools:
+            if tool in processed:
+                continue
+            
+            # Add the main tool
+            result.append((tool, False))
+            processed.add(tool)
+            
+            # If this is a parent, add all its children (they're virtual sub-tools for tabs)
+            if tool in PARENT_TOOLS:
+                children = PARENT_TOOLS[tool]
+                for child in children:
+                    if child not in processed:
+                        result.append((child, True))
+                        processed.add(child)
+        
+        return result
+    
     def get_tool_spec(self, tool_name: str) -> Optional[ToolSpec]:
         """
         Get the specification for a tool.
@@ -657,6 +810,86 @@ class ToolLoader:
         self._widget_classes.clear()
         logger.debug("Tool loader cache cleared")
     
+    def search_tools(
+        self,
+        query: str,
+        limit: int = 10,
+        include_unavailable: bool = False
+    ) -> List[Tuple[str, int, 'ToolCategory']]:
+        """
+        Fuzzy search tools by name and description.
+        
+        Uses rapidfuzz for fuzzy matching if available, otherwise falls back
+        to simple substring matching.
+        
+        Args:
+            query: Search query string
+            limit: Maximum number of results to return
+            include_unavailable: Whether to include unavailable tools
+            
+        Returns:
+            List of tuples: (tool_name, match_score, category)
+            Score is 0-100, higher is better match
+        """
+        if not query:
+            # Return all tools sorted alphabetically
+            tools = self.get_available_tools() if not include_unavailable else list(self._specs.keys())
+            return [(name, 100, self._specs[name].category) for name in sorted(tools)[:limit]]
+        
+        # Build search data: name -> searchable text
+        search_data = {}
+        for name, spec in self._specs.items():
+            if not include_unavailable and not self.is_available(name):
+                continue
+            # Combine name and description for searching
+            search_text = f"{name} {spec.description}"
+            search_data[name] = search_text
+        
+        if not search_data:
+            return []
+        
+        results: List[Tuple[str, int, ToolCategory]] = []
+        
+        if RAPIDFUZZ_AVAILABLE and process is not None:
+            # Use rapidfuzz for proper fuzzy matching
+            matches = process.extract(
+                query,
+                search_data,
+                scorer=fuzz.WRatio,
+                limit=limit
+            )
+            
+            for match in matches:
+                tool_name = match[2]  # Key from dict
+                score = int(match[1])  # Score 0-100
+                if score >= 30:  # Minimum relevance threshold
+                    category = self._specs[tool_name].category
+                    results.append((tool_name, score, category))
+        else:
+            # Fallback to simple substring matching
+            query_lower = query.lower()
+            for name, search_text in search_data.items():
+                text_lower = search_text.lower()
+                if query_lower in text_lower:
+                    # Score based on position and exact match
+                    if name.lower() == query_lower:
+                        score = 100
+                    elif name.lower().startswith(query_lower):
+                        score = 90
+                    elif query_lower in name.lower():
+                        score = 80
+                    else:
+                        score = 60  # Match in description only
+                    
+                    category = self._specs[name].category
+                    results.append((name, score, category))
+            
+            # Sort by score descending, then name ascending
+            results.sort(key=lambda x: (-x[1], x[0]))
+            results = results[:limit]
+        
+        return results
+
     def get_legacy_flags(self) -> Dict[str, bool]:
         """
         Get legacy availability flags for backwards compatibility.
@@ -671,26 +904,33 @@ class ToolLoader:
         return flags
 
 
-# Global instance
+# Global instance with thread-safe initialization
 _tool_loader: Optional[ToolLoader] = None
+_tool_loader_lock = threading.Lock()
 
 
 def get_tool_loader() -> ToolLoader:
     """
-    Get the global tool loader instance.
+    Get the global tool loader instance (thread-safe).
+    
+    Uses double-checked locking pattern to ensure thread safety
+    while minimizing lock contention after initialization.
     
     Returns:
         Global ToolLoader instance
     """
     global _tool_loader
     if _tool_loader is None:
-        _tool_loader = ToolLoader()
+        with _tool_loader_lock:
+            # Double-check after acquiring lock
+            if _tool_loader is None:
+                _tool_loader = ToolLoader()
     return _tool_loader
 
 
 def init_tool_loader(tool_specs: Optional[Dict[str, ToolSpec]] = None) -> ToolLoader:
     """
-    Initialize the global tool loader.
+    Initialize the global tool loader (thread-safe).
     
     Args:
         tool_specs: Optional custom tool specifications
@@ -699,12 +939,13 @@ def init_tool_loader(tool_specs: Optional[Dict[str, ToolSpec]] = None) -> ToolLo
         Initialized ToolLoader
     """
     global _tool_loader
-    _tool_loader = ToolLoader(tool_specs)
+    with _tool_loader_lock:
+        _tool_loader = ToolLoader(tool_specs)
     return _tool_loader
 
 
 def reset_tool_loader() -> None:
-    """Reset the global tool loader."""
+    """Reset the global tool loader (thread-safe)."""
     global _tool_loader
-    _tool_loader = None
-
+    with _tool_loader_lock:
+        _tool_loader = None