pomera-ai-commander 1.2.7 → 1.2.8

package/bin/pomera-create-shortcut.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+/**
+ * Pomera AI Commander - Desktop Shortcut Creator
+ * 
+ * This script creates a desktop shortcut for the Pomera GUI.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+// Get the path to create_shortcut.py
+const shortcutScript = path.join(__dirname, '..', 'create_shortcut.py');
+
+// Find Python executable
+function findPython() {
+    const { execSync } = require('child_process');
+
+    try {
+        execSync('python3 --version', { stdio: 'ignore' });
+        return 'python3';
+    } catch (e) {
+        try {
+            execSync('python --version', { stdio: 'ignore' });
+            return 'python';
+        } catch (e) {
+            console.error('Error: Python is not installed or not in PATH');
+            process.exit(1);
+        }
+    }
+}
+
+const pythonCmd = findPython();
+
+// Get command line arguments
+const args = process.argv.slice(2);
+
+// Spawn the Python script
+const proc = spawn(pythonCmd, [shortcutScript, ...args], {
+    stdio: 'inherit',
+    cwd: path.join(__dirname, '..')
+});
+
+proc.on('close', (code) => {
+    process.exit(code || 0);
+});
+
+proc.on('error', (err) => {
+    console.error('Failed to create shortcut:', err.message);
+    process.exit(1);
+});

package/bin/pomera.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+/**
+ * Pomera AI Commander - GUI launcher
+ * 
+ * This script launches the Pomera GUI application.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+// Get the path to pomera.py
+const pomeraPath = path.join(__dirname, '..', 'pomera.py');
+
+// Find Python executable
+function findPython() {
+    const { execSync } = require('child_process');
+
+    // Try pythonw first (Windows - no console)
+    if (process.platform === 'win32') {
+        try {
+            execSync('pythonw --version', { stdio: 'ignore' });
+            return 'pythonw';
+        } catch (e) {
+            // Fall through
+        }
+    }
+
+    // Try python3 (Linux/macOS)
+    try {
+        execSync('python3 --version', { stdio: 'ignore' });
+        return 'python3';
+    } catch (e) {
+        // Fall back to python
+        try {
+            execSync('python --version', { stdio: 'ignore' });
+            return 'python';
+        } catch (e) {
+            console.error('Error: Python is not installed or not in PATH');
+            console.error('Please install Python 3.8 or higher');
+            process.exit(1);
+        }
+    }
+}
+
+const pythonCmd = findPython();
+
+// Spawn the Python GUI
+const app = spawn(pythonCmd, [pomeraPath], {
+    stdio: 'inherit',
+    cwd: path.join(__dirname, '..'),
+    detached: process.platform !== 'win32' // Detach on non-Windows
+});
+
+// Handle process exit
+app.on('close', (code) => {
+    process.exit(code || 0);
+});
+
+// Handle errors
+app.on('error', (err) => {
+    console.error('Failed to start Pomera:', err.message);
+    process.exit(1);
+});
+
+// Forward signals
+process.on('SIGINT', () => app.kill('SIGINT'));
+process.on('SIGTERM', () => app.kill('SIGTERM'));

package/core/tool_search_widget.py

@@ -73,6 +73,7 @@ class ToolSearchPalette(ttk.Frame):
         self._selected_index: int = 0
         self._popup: Optional[tk.Toplevel] = None
         self._popup_listbox: Optional[tk.Listbox] = None
+        self._closing: bool = False  # Flag to prevent re-opening during close
         
         self._create_widgets()
     
@@ -116,6 +117,9 @@ class ToolSearchPalette(ttk.Frame):
     
     def _on_search_change(self, *args) -> None:
         """Handle text changes in search entry (via StringVar trace)."""
+        # Don't show popup during close operation
+        if self._closing:
+            return
         # Show popup if not visible
         if not (self._popup and self._popup.winfo_exists()):
             self._show_popup()
@@ -164,6 +168,16 @@ class ToolSearchPalette(ttk.Frame):
         popup_frame = ttk.Frame(self._popup, relief="solid", borderwidth=1)
         popup_frame.pack(fill=tk.BOTH, expand=True)
         
+        # Header frame with title only
+        header_frame = ttk.Frame(popup_frame)
+        header_frame.pack(fill=tk.X, padx=2, pady=(2, 0))
+        
+        # Header label
+        ttk.Label(header_frame, text="Select Tool", font=("TkDefaultFont", 9, "bold")).pack(side=tk.LEFT, padx=5)
+        
+        # Separator under header
+        ttk.Separator(popup_frame, orient="horizontal").pack(fill=tk.X, padx=2, pady=2)
+        
         # Results listbox
         self._popup_listbox = tk.Listbox(
             popup_frame,
@@ -175,9 +189,17 @@ class ToolSearchPalette(ttk.Frame):
         
         # Scrollbar
         scrollbar = ttk.Scrollbar(popup_frame, command=self._popup_listbox.yview)
-        scrollbar.place(relx=1.0, rely=0, relheight=1.0, anchor="ne")
+        scrollbar.place(relx=1.0, rely=0, relheight=0.85, anchor="ne")
         self._popup_listbox.configure(yscrollcommand=scrollbar.set)
         
+        # Footer frame with close button at bottom right
+        footer_frame = ttk.Frame(popup_frame)
+        footer_frame.pack(fill=tk.X, padx=2, pady=(0, 2))
+        
+        # Close button (X) - positioned at bottom right
+        close_btn = ttk.Button(footer_frame, text="Close", width=8, command=self._close_and_select_default)
+        close_btn.pack(side=tk.RIGHT, padx=2)
+        
         # Bind events
         self._popup_listbox.bind("<Double-Button-1>", self._on_listbox_select)
         self._popup_listbox.bind("<Return>", self._on_listbox_select)
@@ -193,7 +215,7 @@ class ToolSearchPalette(ttk.Frame):
     SUB_TOOLS = {
         "Slug Generator", "Hash Generator", "ASCII Art Generator",
         "URL Link Extractor", "Regex Extractor", "Email Extraction",
-        "Word Frequency Counter", "HTML Tool",
+        "HTML Tool",
     }
     
     def _update_popup_list(self) -> None:
@@ -255,6 +277,16 @@ class ToolSearchPalette(ttk.Frame):
         if not query:
             return tools
         
+        query_lower = query.lower()
+        
+        # For very short queries (1-2 chars), use prefix matching only to avoid noise
+        if len(query) <= 2:
+            matches = [t for t in tools if t.lower().startswith(query_lower)]
+            if matches:
+                return matches
+            # Fallback to contains if no prefix matches
+            return [t for t in tools if query_lower in t.lower()]
+        
         if RAPIDFUZZ_AVAILABLE:
             search_data = {}
             for tool in tools:
@@ -267,11 +299,23 @@ class ToolSearchPalette(ttk.Frame):
                 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]
+            # Threshold set to 50 to allow substring matches
+            results = process.extract(query_lower, search_data, scorer=fuzz.WRatio, limit=15)
+            fuzzy_matches = [match[2] for match in results if match[1] >= 50]
+            
+            # Also include any tools that contain the query as substring (ensures "URL" finds "URL Parser")
+            substring_matches = [t for t in tools if query_lower in t.lower()]
+            for tool in substring_matches:
+                if tool not in fuzzy_matches:
+                    fuzzy_matches.append(tool)
+            
+            # Prioritize exact prefix matches at the top
+            prefix_matches = [t for t in fuzzy_matches if t.lower().startswith(query_lower)]
+            other_matches = [t for t in fuzzy_matches if not t.lower().startswith(query_lower)]
+            
+            return prefix_matches + other_matches
         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]
@@ -360,6 +404,39 @@ class ToolSearchPalette(ttk.Frame):
         
         return "break"
     
+    def _close_and_select_default(self) -> None:
+        """Close popup and select default tool if no tool selected."""
+        # Set closing flag to prevent focus events from re-opening
+        self._closing = True
+        
+        # Destroy popup FIRST to prevent any refresh loops
+        if self._popup and self._popup.winfo_exists():
+            self._popup.destroy()
+        self._popup = None
+        self._popup_listbox = None
+        
+        # If no current tool, default to AI Tools
+        if not self._current_tool or self._current_tool == "":
+            self._current_tool = "AI Tools"
+            if self._on_tool_selected:
+                try:
+                    self._on_tool_selected(self._current_tool)
+                except Exception as e:
+                    logger.error(f"Error in on_tool_selected callback: {e}")
+        
+        # Set the search var to current tool (popup already destroyed, won't trigger refresh)
+        self._search_var.set(self._current_tool)
+        
+        # Remove focus from entry
+        self.winfo_toplevel().focus_set()
+        
+        # Reset closing flag after a delay
+        self.after(200, self._reset_closing_flag)
+    
+    def _reset_closing_flag(self) -> None:
+        """Reset the closing flag."""
+        self._closing = False
+    
     def _on_popup_focus_out(self, event=None) -> None:
         """Handle focus leaving popup."""
         # Delay to check if focus went to entry
@@ -372,6 +449,9 @@ class ToolSearchPalette(ttk.Frame):
     
     def _check_focus(self) -> None:
         """Check if focus is on entry or popup, hide if not."""
+        # Don't interfere during close operation
+        if self._closing:
+            return
         try:
             focused = self.focus_get()
             if focused not in (self.tool_entry, self._popup_listbox):

package/create_shortcut.py

@@ -19,12 +19,15 @@ from pathlib import Path
 
 def get_package_dir() -> Path:
     """Get the pomera-ai-commander package directory."""
-    # First check if we're running from the package itself
+    # Get the directory where this script is located
     script_dir = Path(__file__).parent.resolve()
-    if (script_dir / "pomera.py").exists():
+    
+    # Check if we're already running from an npm installation
+    # (script_dir will be inside node_modules/pomera-ai-commander)
+    if "node_modules" in str(script_dir) and (script_dir / "pomera.py").exists():
         return script_dir
     
-    # Check npm global installation
+    # Check npm global installation paths
     npm_global = os.environ.get("APPDATA", "") or os.path.expanduser("~")
     if platform.system() == "Windows":
         npm_path = Path(npm_global) / "npm" / "node_modules" / "pomera-ai-commander"
@@ -35,9 +38,14 @@ def get_package_dir() -> Path:
         if not npm_path.exists():
             npm_path = Path.home() / ".npm-packages" / "lib" / "node_modules" / "pomera-ai-commander"
     
-    if npm_path.exists():
+    # Prefer npm installation if it exists
+    if npm_path.exists() and (npm_path / "pomera.py").exists():
         return npm_path
     
+    # Fallback to script's directory (for pip install or direct run)
+    if (script_dir / "pomera.py").exists():
+        return script_dir
+    
     return script_dir
 
 

package/mcp.json

@@ -1,6 +1,6 @@
 {
   "name": "pomera-ai-commander",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "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,11 +1,13 @@
 {
   "name": "pomera-ai-commander",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "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": {
     "pomera-ai-commander": "./bin/pomera-ai-commander.js",
-    "pomera-mcp": "./bin/pomera-ai-commander.js"
+    "pomera-mcp": "./bin/pomera-ai-commander.js",
+    "pomera": "./bin/pomera.js",
+    "pomera-create-shortcut": "./bin/pomera-create-shortcut.js"
   },
   "scripts": {
     "start": "python pomera_mcp_server.py",

package/pomera.py

@@ -626,14 +626,16 @@ class PromeraAISettingsManager:
     
     def get_pattern_library(self) -> List[Dict[str, str]]:
         """Get the regex pattern library."""
-        # Initialize pattern library if it doesn't exist
-        if "pattern_library" not in self.app.settings:
+        # Initialize pattern library if it doesn't exist OR is empty
+        existing = self.app.settings.get("pattern_library", None)
+        if not existing or len(existing) == 0:
             # Try to import and use the comprehensive pattern library
             try:
                 from core.regex_pattern_library import RegexPatternLibrary
                 library = RegexPatternLibrary()
                 self.app.settings["pattern_library"] = library._convert_to_settings_format()
-                self.app.logger.info(f"Loaded comprehensive pattern library with {len(self.app.settings['pattern_library'])} patterns")
+                pattern_count = len(self.app.settings.get("pattern_library", []))
+                self.app.logger.info(f"Loaded comprehensive pattern library with {pattern_count} patterns")
             except ImportError:
                 # Fallback to basic patterns if comprehensive library is not available
                 self.app.settings["pattern_library"] = [

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/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(