pomera-ai-commander 1.2.5 → 1.2.7

package/core/migration_manager.py

@@ -324,8 +324,9 @@ class MigrationManager:
         """
         try:
             with self.connection_manager.transaction() as conn:
-                # Clear existing data
-                self._clear_all_tables(conn)
+                # NOTE: Do NOT clear tables - use INSERT OR REPLACE for upsert semantics
+                # The _clear_all_tables() call was removed because it caused data loss
+                # when save_settings() was called with incomplete/empty data
                 
                 # Migrate core settings
                 self._migrate_core_settings(conn, json_data)
@@ -432,7 +433,7 @@ class MigrationManager:
                 serialized_value = self.converter.serialize_value(value)
                 
                 conn.execute(
-                    "INSERT INTO core_settings (key, value, data_type) VALUES (?, ?, ?)",
+                    "INSERT OR REPLACE INTO core_settings (key, value, data_type) VALUES (?, ?, ?)",
                     (key, serialized_value, data_type)
                 )
     
@@ -454,7 +455,7 @@ class MigrationManager:
                     serialized_value = self.converter.serialize_value(value)
                     
                     conn.execute(
-                        "INSERT INTO tool_settings (tool_name, setting_path, setting_value, data_type) VALUES (?, ?, ?, ?)",
+                        "INSERT OR REPLACE INTO tool_settings (tool_name, setting_path, setting_value, data_type) VALUES (?, ?, ?, ?)",
                         (tool_name, setting_path, serialized_value, data_type)
                     )
             else:
@@ -463,7 +464,7 @@ class MigrationManager:
                 serialized_value = self.converter.serialize_value(tool_config)
                 
                 conn.execute(
-                    "INSERT INTO tool_settings (tool_name, setting_path, setting_value, data_type) VALUES (?, ?, ?, ?)",
+                    "INSERT OR REPLACE INTO tool_settings (tool_name, setting_path, setting_value, data_type) VALUES (?, ?, ?, ?)",
                     (tool_name, 'value', serialized_value, data_type)
                 )
     
@@ -480,7 +481,7 @@ class MigrationManager:
             input_tabs = json_data['input_tabs']
             for i, content in enumerate(input_tabs):
                 conn.execute(
-                    "INSERT INTO tab_content (tab_type, tab_index, content) VALUES (?, ?, ?)",
+                    "INSERT OR REPLACE INTO tab_content (tab_type, tab_index, content) VALUES (?, ?, ?)",
                     ('input', i, content or '')
                 )
         
@@ -489,7 +490,7 @@ class MigrationManager:
             output_tabs = json_data['output_tabs']
             for i, content in enumerate(output_tabs):
                 conn.execute(
-                    "INSERT INTO tab_content (tab_type, tab_index, content) VALUES (?, ?, ?)",
+                    "INSERT OR REPLACE INTO tab_content (tab_type, tab_index, content) VALUES (?, ?, ?)",
                     ('output', i, content or '')
                 )
     
@@ -511,7 +512,7 @@ class MigrationManager:
                     serialized_value = self.converter.serialize_value(value)
                     
                     conn.execute(
-                        "INSERT INTO performance_settings (category, setting_key, setting_value, data_type) VALUES (?, ?, ?, ?)",
+                        "INSERT OR REPLACE INTO performance_settings (category, setting_key, setting_value, data_type) VALUES (?, ?, ?, ?)",
                         (category, setting_key, serialized_value, data_type)
                     )
             else:
@@ -520,7 +521,7 @@ class MigrationManager:
                 serialized_value = self.converter.serialize_value(settings)
                 
                 conn.execute(
-                    "INSERT INTO performance_settings (category, setting_key, setting_value, data_type) VALUES (?, ?, ?, ?)",
+                    "INSERT OR REPLACE INTO performance_settings (category, setting_key, setting_value, data_type) VALUES (?, ?, ?, ?)",
                     (category, 'value', serialized_value, data_type)
                 )
     
@@ -539,7 +540,7 @@ class MigrationManager:
                     serialized_value = self.converter.serialize_value(value)
                     
                     conn.execute(
-                        "INSERT INTO font_settings (font_type, property, value, data_type) VALUES (?, ?, ?, ?)",
+                        "INSERT OR REPLACE INTO font_settings (font_type, property, value, data_type) VALUES (?, ?, ?, ?)",
                         (font_type, property_name, serialized_value, data_type)
                     )
     
@@ -560,7 +561,7 @@ class MigrationManager:
                     self.logger.debug(f"Inserting dialog setting: {category}.{property_name} = {value} (type: {data_type})")
                     
                     conn.execute(
-                        "INSERT INTO dialog_settings (category, property, value, data_type) VALUES (?, ?, ?, ?)",
+                        "INSERT OR REPLACE INTO dialog_settings (category, property, value, data_type) VALUES (?, ?, ?, ?)",
                         (category, property_name, serialized_value, data_type)
                     )
     

package/core/settings_defaults_registry.py

@@ -833,6 +833,14 @@ class SettingsDefaultsRegistry:
                     "description": "Error messages for critical issues (cannot be disabled)",
                     "examples": ["File not found", "Network error", "Invalid configuration"]
                 }
+            },
+            # UI Layout Settings for tool search and collapsible panels
+            "ui_layout": {
+                "options_panel_collapsed": False,
+                "search_bar_collapsed": False,
+                "favorite_tools": [],
+                "recent_tools": [],
+                "recent_tools_max": 10
             }
         }
     

package/core/tool_search_widget.py

@@ -0,0 +1,417 @@
+"""
+Tool Search Widget - Compact tool selector with popup dropdown.
+
+This module provides a compact search bar that shows the current tool name
+and opens a popup dropdown with search results when focused.
+
+Author: Pomera AI Commander Team
+"""
+
+import tkinter as tk
+from tkinter import ttk
+from typing import Optional, Callable, List, Dict, Any
+import logging
+
+# Try to import rapidfuzz for fuzzy matching
+try:
+    from rapidfuzz import fuzz, process
+    RAPIDFUZZ_AVAILABLE = True
+except ImportError:
+    RAPIDFUZZ_AVAILABLE = False
+
+
+logger = logging.getLogger(__name__)
+
+
+class ToolSearchPalette(ttk.Frame):
+    """
+    Compact tool selector with popup dropdown.
+    
+    Features:
+    - Compact bar showing current tool name
+    - Popup dropdown appears on click/focus
+    - Fuzzy search with keyboard navigation
+    - Dropdown hides on selection or click outside
+    
+    Layout:
+        [🔍 Current Tool Name          (Ctrl+K)]
+                      ↓ (on focus)
+        ┌────────────────────────────────────┐
+        │ Search: [_____________]            │
+        ├────────────────────────────────────┤
+        │ ⭐ Case Tool                       │
+        │    Email Extraction - Extract...   │
+        │    Hash Generator - Generate...    │
+        └────────────────────────────────────┘
+    """
+    
+    def __init__(
+        self,
+        parent: tk.Widget,
+        tool_loader: Any,
+        on_tool_selected: Callable[[str], None],
+        settings: Optional[Dict[str, Any]] = None,
+        on_settings_change: Optional[Callable[[Dict[str, Any]], None]] = None,
+        **kwargs
+    ):
+        super().__init__(parent, **kwargs)
+        
+        self._tool_loader = tool_loader
+        self._on_tool_selected = on_tool_selected
+        self._settings = settings or {}
+        self._on_settings_change = on_settings_change
+        
+        # Get UI layout settings
+        ui_layout = self._settings.get("ui_layout", {})
+        self._favorites: List[str] = list(ui_layout.get("favorite_tools", []))
+        self._recent: List[str] = list(ui_layout.get("recent_tools", []))
+        self._recent_max = ui_layout.get("recent_tools_max", 10)
+        
+        # Current state
+        self._current_tool: str = self._settings.get("selected_tool", "Case Tool")
+        self._filtered_tools: List[str] = []
+        self._selected_index: int = 0
+        self._popup: Optional[tk.Toplevel] = None
+        self._popup_listbox: Optional[tk.Listbox] = None
+        
+        self._create_widgets()
+    
+    def _create_widgets(self) -> None:
+        """Create the compact search bar (centered, half-width like VS Code)."""
+        # Centering frame
+        self.center_frame = ttk.Frame(self)
+        self.center_frame.pack(expand=True)  # Centers horizontally
+        
+        # Main bar frame (fixed width, centered)
+        self.bar_frame = ttk.Frame(self.center_frame)
+        self.bar_frame.pack()
+        
+        # "Search Tools" label instead of icon
+        self.icon_label = ttk.Label(self.bar_frame, text="Search Tools", cursor="hand2")
+        self.icon_label.pack(side=tk.LEFT, padx=(5, 0))
+        self.icon_label.bind("<Button-1>", self._on_bar_click)
+        
+        # StringVar for reliable text change detection
+        self._search_var = tk.StringVar(value=self._current_tool)
+        self._search_var.trace_add("write", self._on_search_change)
+        
+        # Current tool name (wider entry for dropdown width + Ctrl+K hint space)
+        self.tool_entry = ttk.Entry(self.bar_frame, textvariable=self._search_var, width=65)
+        self.tool_entry.pack(side=tk.LEFT, padx=5)
+        
+        # Make entry clickable to show dropdown
+        self.tool_entry.bind("<FocusIn>", self._on_entry_focus)
+        self.tool_entry.bind("<Return>", self._on_enter)
+        self.tool_entry.bind("<Escape>", self._hide_popup)
+        self.tool_entry.bind("<Down>", self._on_key_down)
+        self.tool_entry.bind("<Up>", self._on_key_up)
+        
+        # Shortcut button (clickable, focuses search)
+        self.hint_button = ttk.Button(self.bar_frame, text="(Ctrl+K)", width=8,
+                                       command=self.focus_search)
+        self.hint_button.pack(side=tk.RIGHT, padx=(0, 5))
+        
+        # Bind to MAIN WINDOW Configure event for resize/move handling
+        self.winfo_toplevel().bind("<Configure>", self._on_main_window_configure, add="+")
+    
+    def _on_search_change(self, *args) -> None:
+        """Handle text changes in search entry (via StringVar trace)."""
+        # Show popup if not visible
+        if not (self._popup and self._popup.winfo_exists()):
+            self._show_popup()
+        else:
+            self._update_popup_list()
+    
+    def _on_main_window_configure(self, event=None) -> None:
+        """Handle main window resize/move - hide popup to prevent floating."""
+        if self._popup and self._popup.winfo_exists():
+            self._hide_popup()
+    
+    def _on_bar_click(self, event=None) -> None:
+        """Handle click on the bar - show dropdown."""
+        self.tool_entry.focus_set()
+        self._show_popup()
+    
+    def _on_configure(self, event=None) -> None:
+        """Handle window resize/move - hide popup to prevent floating."""
+        if self._popup and self._popup.winfo_exists():
+            self._hide_popup()
+    
+    def _on_entry_focus(self, event=None) -> None:
+        """Handle focus on entry - clear text and show dropdown."""
+        # Clear search field to allow fresh search
+        self._search_var.set("")
+        self._show_popup()
+    
+    def _show_popup(self) -> None:
+        """Show the dropdown popup below the search bar."""
+        if self._popup and self._popup.winfo_exists():
+            self._update_popup_list()
+            return
+        
+        # Create popup window
+        self._popup = tk.Toplevel(self)
+        self._popup.wm_overrideredirect(True)  # No window decorations
+        self._popup.wm_attributes("-topmost", True)
+        
+        # Position below the entry
+        x = self.tool_entry.winfo_rootx()
+        y = self.tool_entry.winfo_rooty() + self.tool_entry.winfo_height()
+        width = max(400, self.tool_entry.winfo_width() + 50)
+        self._popup.geometry(f"{width}x250+{x}+{y}")
+        
+        # Popup content frame
+        popup_frame = ttk.Frame(self._popup, relief="solid", borderwidth=1)
+        popup_frame.pack(fill=tk.BOTH, expand=True)
+        
+        # Results listbox
+        self._popup_listbox = tk.Listbox(
+            popup_frame,
+            selectmode=tk.SINGLE,
+            font=("TkDefaultFont", 10),
+            activestyle="dotbox"
+        )
+        self._popup_listbox.pack(fill=tk.BOTH, expand=True, padx=2, pady=2)
+        
+        # Scrollbar
+        scrollbar = ttk.Scrollbar(popup_frame, command=self._popup_listbox.yview)
+        scrollbar.place(relx=1.0, rely=0, relheight=1.0, anchor="ne")
+        self._popup_listbox.configure(yscrollcommand=scrollbar.set)
+        
+        # Bind events
+        self._popup_listbox.bind("<Double-Button-1>", self._on_listbox_select)
+        self._popup_listbox.bind("<Return>", self._on_listbox_select)
+        
+        # Close popup when clicking outside
+        self._popup.bind("<FocusOut>", self._on_popup_focus_out)
+        self.tool_entry.bind("<FocusOut>", self._on_entry_focus_out)
+        
+        # Populate list
+        self._update_popup_list()
+    
+    # Sub-tools that are nested within parent categories (for indentation)
+    SUB_TOOLS = {
+        "Slug Generator", "Hash Generator", "ASCII Art Generator",
+        "URL Link Extractor", "Regex Extractor", "Email Extraction",
+        "Word Frequency Counter", "HTML Tool",
+    }
+    
+    def _update_popup_list(self) -> None:
+        """Update the popup listbox with filtered tools."""
+        if not self._popup_listbox:
+            return
+        
+        # Get search query
+        query = self._search_var.get().strip()
+        
+        # Get grouped tools (processing tools only, with parent-child hierarchy)
+        if self._tool_loader:
+            grouped_tools = self._tool_loader.get_grouped_tools()
+            all_tools = [t[0] for t in grouped_tools]
+        else:
+            grouped_tools = []
+            all_tools = []
+        
+        # Filter by search query or show all grouped
+        if query and query != self._current_tool:
+            # Search mode - fuzzy search all tools
+            matched = self._fuzzy_search(all_tools, query)
+            self._filtered_tools = matched
+            # Build display with is_sub_tool info
+            tool_info = {t[0]: t[1] for t in grouped_tools}
+            display_tools = [(t, tool_info.get(t, False)) for t in matched]
+        else:
+            # Default mode - show grouped tools in order
+            display_tools = grouped_tools
+            self._filtered_tools = [t[0] for t in grouped_tools]
+        
+        # Update listbox
+        self._popup_listbox.delete(0, tk.END)
+        for tool, is_sub_tool in display_tools:
+            # Format sub-tools with arrow prefix
+            if is_sub_tool:
+                indent = "    ↳ "  # Arrow prefix for sub-tools
+            else:
+                indent = ""
+            
+            prefix = "⭐ " if tool in self._favorites else ""
+            
+            # Get description  
+            desc = ""
+            if self._tool_loader:
+                spec = self._tool_loader.get_tool_spec(tool)
+                if spec and spec.description:
+                    desc = f" - {spec.description[:35]}..."
+            
+            self._popup_listbox.insert(tk.END, f"{indent}{prefix}{tool}{desc}")
+        
+        # Select first item
+        if self._filtered_tools:
+            self._selected_index = 0
+            self._popup_listbox.selection_set(0)
+    
+    def _fuzzy_search(self, tools: List[str], query: str) -> List[str]:
+        """Perform fuzzy search on tool names."""
+        if not query:
+            return tools
+        
+        if RAPIDFUZZ_AVAILABLE:
+            search_data = {}
+            for tool in tools:
+                search_text = tool
+                if self._tool_loader:
+                    spec = self._tool_loader.get_tool_spec(tool)
+                    if spec and spec.description:
+                        search_text = f"{tool} {spec.description}"
+                # Use lowercase for case-insensitive matching
+                search_data[tool] = search_text.lower()
+            
+            # Convert query to lowercase for case-insensitive search
+            results = process.extract(query.lower(), search_data, scorer=fuzz.WRatio, limit=15)
+            return [match[2] for match in results if match[1] >= 40]
+        else:
+            # Fallback substring matching
+            query_lower = query.lower()
+            matches = [(t, t.lower().find(query_lower)) for t in tools if query_lower in t.lower()]
+            matches.sort(key=lambda x: x[1])
+            return [m[0] for m in matches]
+    
+    def _on_search_key(self, event=None) -> None:
+        """Handle key press in search entry."""
+        if event and event.keysym in ("Up", "Down", "Return", "Escape"):
+            return  # Handled separately
+        self._update_popup_list()
+    
+    def _on_key_down(self, event=None) -> str:
+        """Handle down arrow."""
+        if self._popup_listbox and self._filtered_tools:
+            if self._selected_index < len(self._filtered_tools) - 1:
+                self._selected_index += 1
+                self._popup_listbox.selection_clear(0, tk.END)
+                self._popup_listbox.selection_set(self._selected_index)
+                self._popup_listbox.see(self._selected_index)
+        return "break"
+    
+    def _on_key_up(self, event=None) -> str:
+        """Handle up arrow."""
+        if self._popup_listbox and self._filtered_tools:
+            if self._selected_index > 0:
+                self._selected_index -= 1
+                self._popup_listbox.selection_clear(0, tk.END)
+                self._popup_listbox.selection_set(self._selected_index)
+                self._popup_listbox.see(self._selected_index)
+        return "break"
+    
+    def _on_enter(self, event=None) -> str:
+        """Handle Enter key - select current tool."""
+        if self._filtered_tools and 0 <= self._selected_index < len(self._filtered_tools):
+            tool = self._filtered_tools[self._selected_index]
+            self._select_tool(tool)
+        return "break"
+    
+    def _on_listbox_select(self, event=None) -> None:
+        """Handle listbox selection."""
+        if not self._popup_listbox:
+            return
+        selection = self._popup_listbox.curselection()
+        if selection and selection[0] < len(self._filtered_tools):
+            tool = self._filtered_tools[selection[0]]
+            self._select_tool(tool)
+    
+    def _select_tool(self, tool_name: str) -> None:
+        """Select a tool and hide popup."""
+        self._current_tool = tool_name
+        
+        # Update entry to show selected tool (use StringVar)
+        self._search_var.set(tool_name)
+        
+        # Update recent tools
+        if tool_name in self._recent:
+            self._recent.remove(tool_name)
+        self._recent.insert(0, tool_name)
+        self._recent = self._recent[:self._recent_max]
+        
+        # Hide popup
+        self._hide_popup()
+        
+        # Remove focus from search entry so clicking again shows dropdown
+        self.winfo_toplevel().focus_set()
+        
+        # Save settings
+        self._save_settings()
+        
+        # Notify callback
+        if self._on_tool_selected:
+            try:
+                self._on_tool_selected(tool_name)
+            except Exception as e:
+                logger.error(f"Error in on_tool_selected callback: {e}")
+    
+    def _hide_popup(self, event=None) -> str:
+        """Hide the popup dropdown and restore tool name."""
+        if self._popup and self._popup.winfo_exists():
+            self._popup.destroy()
+        self._popup = None
+        self._popup_listbox = None
+        
+        # Restore current tool name if search field is empty or contains partial text
+        if not self._search_var.get().strip() or self._search_var.get() != self._current_tool:
+            self._search_var.set(self._current_tool)
+        
+        return "break"
+    
+    def _on_popup_focus_out(self, event=None) -> None:
+        """Handle focus leaving popup."""
+        # Delay to check if focus went to entry
+        self.after(100, self._check_focus)
+    
+    def _on_entry_focus_out(self, event=None) -> None:
+        """Handle focus leaving entry."""
+        # Delay to check if focus went to popup
+        self.after(100, self._check_focus)
+    
+    def _check_focus(self) -> None:
+        """Check if focus is on entry or popup, hide if not."""
+        try:
+            focused = self.focus_get()
+            if focused not in (self.tool_entry, self._popup_listbox):
+                if self._popup and self._popup.winfo_exists():
+                    # Check if focus is inside popup
+                    try:
+                        if not str(focused).startswith(str(self._popup)):
+                            self._hide_popup()
+                    except:
+                        pass
+        except:
+            pass
+    
+    def _save_settings(self) -> None:
+        """Save favorites and recent to settings."""
+        if self._on_settings_change:
+            try:
+                self._on_settings_change({
+                    "ui_layout": {
+                        "favorite_tools": self._favorites.copy(),
+                        "recent_tools": self._recent.copy(),
+                    }
+                })
+            except Exception as e:
+                logger.error(f"Error saving settings: {e}")
+    
+    def focus_search(self) -> None:
+        """Focus the search entry (Ctrl+K shortcut)."""
+        self.tool_entry.focus_set()
+        self.tool_entry.selection_range(0, tk.END)
+        self._show_popup()
+    
+    def get_selected_tool(self) -> Optional[str]:
+        """Get the currently selected tool name."""
+        return self._current_tool
+    
+    def set_tool_loader(self, loader: Any) -> None:
+        """Update the tool loader."""
+        self._tool_loader = loader
+
+
+# Module availability flag
+TOOL_SEARCH_WIDGET_AVAILABLE = True

package/mcp.json

@@ -1,6 +1,6 @@
 {
   "name": "pomera-ai-commander",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "Text processing toolkit with 22 MCP tools including case transformation, encoding, hashing, text analysis, and notes management for AI assistants.",
   "homepage": "https://github.com/matbanik/Pomera-AI-Commander",
   "repository": "https://github.com/matbanik/Pomera-AI-Commander",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pomera-ai-commander",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "Text processing toolkit with 22 MCP tools for AI assistants - case transformation, encoding, hashing, text analysis, and notes management",
   "main": "pomera_mcp_server.py",
   "bin": {