pomera-ai-commander 1.2.7 → 1.2.9

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/case_tool.py

@@ -188,7 +188,8 @@ class CaseTool:
         """Get default settings for the Case Tool.
         
         Uses the centralized Settings Defaults Registry if available,
-        otherwise falls back to hardcoded defaults.
+        otherwise falls back to minimal defaults. Full exclusions list
+        is maintained only in the registry.
         """
         try:
             from core.settings_defaults_registry import get_registry
@@ -199,11 +200,10 @@ class CaseTool:
         except Exception:
             pass
         
-        # Fallback to hardcoded defaults with updated exclusions
-        # Exclusions: a, an, the, and, but, or, for, nor, on, at, to, from, by, with, in, of
+        # Minimal fallback - registry has the full exclusions list
         return {
             "mode": "Sentence",
-            "exclusions": "a\nan\nthe\nand\nbut\nor\nfor\nnor\non\nat\nto\nfrom\nby\nwith\nin\nof"
+            "exclusions": ""
         }
 
 

package/tools/curl_settings.py

@@ -91,7 +91,18 @@ class CurlSettingsManager:
             # Version and metadata
             "settings_version": "1.0",
             "last_updated": None,
-            "created_date": None
+            "created_date": None,
+            
+            # UI State Persistence (NEW - persist between restarts)
+            "last_url": "",
+            "last_method": "GET",
+            "last_headers": "",
+            "last_body": "",
+            "last_body_type": "None",
+            "last_auth_type": "None",
+            "last_auth_data": {},  # Encrypted auth tokens stored here
+            "last_complex_options": "",
+            "persist_ui_state": True  # User preference to persist UI state
         }
         
         # Current settings (loaded from file or defaults)

package/tools/curl_tool.py

@@ -284,6 +284,9 @@ class CurlToolWidget:
         # Create the UI
         self.create_widgets()
         
+        # Restore saved UI state (URL, method, headers, body, auth)
+        self._restore_ui_state()
+        
         # Save settings when the window is closed
         if hasattr(self.parent, 'protocol'):
             self.parent.protocol("WM_DELETE_WINDOW", self._on_closing)
@@ -4232,17 +4235,8 @@ curl -X POST https://api.example.com/users \\
             if self.logger:
                 self.logger.error(f"Error saving settings: {e}")
     
-    def _on_closing(self):
-        """Handle application closing - save settings before exit."""
-        try:
-            self._save_current_settings()
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"Error saving settings on close: {e}")
-        
-        # Continue with normal closing
-        if hasattr(self.parent, 'destroy'):
-            self.parent.destroy()
+    # NOTE: _on_closing method has been moved to end of class (line ~5490)
+    # to consolidate with UI state persistence logic
     
     def _export_curl(self):
         """Export current request as cURL command."""
@@ -5483,6 +5477,177 @@ Timestamp: {timestamp}{additional_details}"""
         if item:
             self.history_tree.selection_set(item)
             self.history_context_menu.post(event.x_root, event.y_root)
+    
+    def _on_closing(self):
+        """Handle widget/window closing - save all settings and UI state."""
+        # Save original settings (from the original method at line 4238)
+        try:
+            self._save_current_settings()
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Error saving settings on close: {e}")
+        
+        # Also save UI state for full persistence (new functionality)
+        try:
+            self._save_ui_state()
+            self.logger.info("cURL Tool UI state saved on close")
+        except Exception as e:
+            self.logger.error(f"Error saving UI state on close: {e}")
+        
+        # If parent has destroy, call it
+        if hasattr(self.parent, 'destroy'):
+            self.parent.destroy()
+    
+    def _save_ui_state(self):
+        """Save current UI state to settings for persistence."""
+        if not self.settings_manager:
+            return
+        
+        # Check if UI state persistence is enabled
+        if not self.settings.get("persist_ui_state", True):
+            return
+        
+        try:
+            # Get current URL from text widget
+            url = ""
+            if self.url_text and self.url_text.winfo_exists():
+                url = self.url_text.get("1.0", tk.END).strip()
+            
+            # Get current method
+            method = self.method_var.get() if self.method_var else "GET"
+            
+            # Get headers from text widget
+            headers = ""
+            if hasattr(self, 'headers_text') and self.headers_text and self.headers_text.winfo_exists():
+                headers = self.headers_text.get("1.0", tk.END).strip()
+            
+            # Get body from text widget
+            body = ""
+            if hasattr(self, 'body_text') and self.body_text and self.body_text.winfo_exists():
+                body = self.body_text.get("1.0", tk.END).strip()
+            
+            # Get body type
+            body_type = self.body_type_var.get() if self.body_type_var else "None"
+            
+            # Get auth type
+            auth_type = self.auth_type_var.get() if self.auth_type_var else "None"
+            
+            # Get auth data (encrypted)
+            auth_data = {}
+            if auth_type == "Bearer":
+                token = self.bearer_token_var.get() if hasattr(self, 'bearer_token_var') else ""
+                if token:
+                    auth_data["bearer_token"] = encrypt_auth_value(token)
+            elif auth_type == "Basic":
+                username = self.basic_username_var.get() if hasattr(self, 'basic_username_var') else ""
+                password = self.basic_password_var.get() if hasattr(self, 'basic_password_var') else ""
+                if username or password:
+                    auth_data["basic_username"] = username
+                    auth_data["basic_password"] = encrypt_auth_value(password)
+            elif auth_type == "API Key":
+                key_name = self.api_key_name_var.get() if hasattr(self, 'api_key_name_var') else ""
+                key_value = self.api_key_value_var.get() if hasattr(self, 'api_key_value_var') else ""
+                key_location = self.api_key_location_var.get() if hasattr(self, 'api_key_location_var') else "header"
+                if key_value:
+                    auth_data["api_key_name"] = key_name
+                    auth_data["api_key_value"] = encrypt_auth_value(key_value)
+                    auth_data["api_key_location"] = key_location
+            
+            # Get complex options
+            complex_options = self.complex_options_var.get() if hasattr(self, 'complex_options_var') else ""
+            
+            # Update settings
+            self.settings_manager.set_setting("last_url", url)
+            self.settings_manager.set_setting("last_method", method)
+            self.settings_manager.set_setting("last_headers", headers)
+            self.settings_manager.set_setting("last_body", body)
+            self.settings_manager.set_setting("last_body_type", body_type)
+            self.settings_manager.set_setting("last_auth_type", auth_type)
+            self.settings_manager.set_setting("last_auth_data", auth_data)
+            self.settings_manager.set_setting("last_complex_options", complex_options)
+            
+            # Save to persistent storage
+            self.settings_manager.save_settings()
+            self.logger.debug("UI state saved successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Error saving UI state: {e}")
+    
+    def _restore_ui_state(self):
+        """Restore UI state from saved settings."""
+        if not self.settings_manager:
+            return
+        
+        # Check if UI state persistence is enabled
+        if not self.settings.get("persist_ui_state", True):
+            return
+        
+        try:
+            # Restore URL
+            last_url = self.settings.get("last_url", "")
+            if last_url and self.url_text and self.url_text.winfo_exists():
+                self.url_text.delete("1.0", tk.END)
+                self.url_text.insert("1.0", last_url)
+            
+            # Restore method
+            last_method = self.settings.get("last_method", "GET")
+            if self.method_var:
+                self.method_var.set(last_method)
+            
+            # Restore headers
+            last_headers = self.settings.get("last_headers", "")
+            if last_headers and hasattr(self, 'headers_text') and self.headers_text:
+                if self.headers_text.winfo_exists():
+                    self.headers_text.delete("1.0", tk.END)
+                    self.headers_text.insert("1.0", last_headers)
+            
+            # Restore body
+            last_body = self.settings.get("last_body", "")
+            if last_body and hasattr(self, 'body_text') and self.body_text:
+                if self.body_text.winfo_exists():
+                    self.body_text.delete("1.0", tk.END)
+                    self.body_text.insert("1.0", last_body)
+            
+            # Restore body type
+            last_body_type = self.settings.get("last_body_type", "None")
+            if self.body_type_var:
+                self.body_type_var.set(last_body_type)
+            
+            # Restore auth type
+            last_auth_type = self.settings.get("last_auth_type", "None")
+            if self.auth_type_var:
+                self.auth_type_var.set(last_auth_type)
+            
+            # Restore auth data (decrypted)
+            last_auth_data = self.settings.get("last_auth_data", {})
+            if last_auth_data:
+                if last_auth_type == "Bearer" and hasattr(self, 'bearer_token_var'):
+                    token = last_auth_data.get("bearer_token", "")
+                    self.bearer_token_var.set(decrypt_auth_value(token))
+                elif last_auth_type == "Basic":
+                    if hasattr(self, 'basic_username_var'):
+                        self.basic_username_var.set(last_auth_data.get("basic_username", ""))
+                    if hasattr(self, 'basic_password_var'):
+                        password = last_auth_data.get("basic_password", "")
+                        self.basic_password_var.set(decrypt_auth_value(password))
+                elif last_auth_type == "API Key":
+                    if hasattr(self, 'api_key_name_var'):
+                        self.api_key_name_var.set(last_auth_data.get("api_key_name", ""))
+                    if hasattr(self, 'api_key_value_var'):
+                        key_value = last_auth_data.get("api_key_value", "")
+                        self.api_key_value_var.set(decrypt_auth_value(key_value))
+                    if hasattr(self, 'api_key_location_var'):
+                        self.api_key_location_var.set(last_auth_data.get("api_key_location", "header"))
+            
+            # Restore complex options
+            last_complex_options = self.settings.get("last_complex_options", "")
+            if last_complex_options and hasattr(self, 'complex_options_var'):
+                self.complex_options_var.set(last_complex_options)
+            
+            self.logger.debug("UI state restored successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Error restoring UI state: {e}")
 
 
 # For standalone testing

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

@@ -301,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(
@@ -373,6 +366,24 @@ TOOL_SPECS: Dict[str, ToolSpec] = {
         description="Model Context Protocol server management",
         available_flag="MCP_WIDGET_MODULE_AVAILABLE"
     ),
+    
+    # Web Tools - handled inline in pomera.py (tabbed interface like AI Tools)
+    "Web Search": ToolSpec(
+        name="Web Search",
+        module_path="tools.web_search",  # Core module, UI created inline
+        class_name="search",  # Function, not class
+        category=ToolCategory.UTILITY,
+        description="Search the web using DuckDuckGo, Tavily, Google, Brave, SerpApi, Serper",
+        available_flag=""  # Always available
+    ),
+    "URL Reader": ToolSpec(
+        name="URL Reader",
+        module_path="tools.url_content_reader",
+        class_name="URLContentReader",
+        category=ToolCategory.UTILITY,
+        description="Fetch URL content and convert to HTML, JSON, or Markdown",
+        available_flag=""  # Always available
+    ),
 }
 
 # These sub-tools appear as tabs within their parent tool