pomera-ai-commander 1.2.8 → 1.2.9

package/core/mcp/tool_registry.py

@@ -202,6 +202,10 @@ class ToolRegistry:
         # Find & Replace Diff Tool (Phase 6) - regex find/replace with diff preview and Notes backup
         self._register_find_replace_diff_tool()
         
+        # Web Search and URL Reader Tools (Phase 7)
+        self._register_web_search_tool()
+        self._register_read_url_tool()
+        
         self._logger.info(f"Registered {len(self._tools)} built-in MCP tools")
 
     
@@ -2711,6 +2715,329 @@ class ToolRegistry:
                 registry._logger.warning(f"Failed to get note: {e}")
                 return None
         return get_note
+    
+    def _register_web_search_tool(self) -> None:
+        """Register the Web Search Tool."""
+        self.register(MCPToolAdapter(
+            name="pomera_web_search",
+            description="Search the web using multiple engines. Engines: tavily (AI-optimized, recommended), "
+                       "google (100/day free), brave (2000/month free), duckduckgo (free, no key), "
+                       "serpapi (100 total free), serper (2500 total free).",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query"
+                    },
+                    "engine": {
+                        "type": "string",
+                        "enum": ["tavily", "google", "brave", "duckduckgo", "serpapi", "serper"],
+                        "description": "Search engine to use",
+                        "default": "tavily"
+                    },
+                    "count": {
+                        "type": "integer",
+                        "description": "Number of results (1-20)",
+                        "default": 5,
+                        "minimum": 1,
+                        "maximum": 20
+                    }
+                },
+                "required": ["query"]
+            },
+            handler=self._handle_web_search
+        ))
+    
+    def _handle_web_search(self, args: Dict[str, Any]) -> str:
+        """Handle web search tool execution using encrypted API keys from database settings."""
+        import json
+        import urllib.request
+        import urllib.parse
+        
+        query = args.get("query", "").strip()
+        engine = args.get("engine", "duckduckgo").lower()
+        count = args.get("count", 5)
+        
+        # Validate inputs
+        if not query:
+            return json.dumps({"success": False, "error": "Query is required"})
+        
+        valid_engines = ["duckduckgo", "tavily", "google", "brave", "serpapi", "serper"]
+        if engine not in valid_engines:
+            return json.dumps({
+                "success": False, 
+                "error": f"Invalid engine: '{engine}'. Valid engines: {', '.join(valid_engines)}"
+            })
+        
+        try:
+            # Get API key from encrypted database settings
+            api_key = self._get_encrypted_web_search_api_key(engine)
+            cse_id = self._get_web_search_setting(engine, "cse_id", "")
+            
+            # Execute search based on engine
+            if engine == "duckduckgo":
+                results = self._mcp_search_duckduckgo(query, count)
+            elif engine == "tavily":
+                if not api_key:
+                    return json.dumps({"success": False, "error": "Tavily API key required. Configure in Web Search settings."})
+                results = self._mcp_search_tavily(query, count, api_key)
+            elif engine == "google":
+                if not api_key or not cse_id:
+                    return json.dumps({"success": False, "error": "Google API key and CSE ID required. Configure in Web Search settings."})
+                results = self._mcp_search_google(query, count, api_key, cse_id)
+            elif engine == "brave":
+                if not api_key:
+                    return json.dumps({"success": False, "error": "Brave API key required. Configure in Web Search settings."})
+                results = self._mcp_search_brave(query, count, api_key)
+            elif engine == "serpapi":
+                if not api_key:
+                    return json.dumps({"success": False, "error": "SerpApi key required. Configure in Web Search settings."})
+                results = self._mcp_search_serpapi(query, count, api_key)
+            elif engine == "serper":
+                if not api_key:
+                    return json.dumps({"success": False, "error": "Serper API key required. Configure in Web Search settings."})
+                results = self._mcp_search_serper(query, count, api_key)
+            else:
+                return json.dumps({"success": False, "error": f"Unknown engine: {engine}"})
+            
+            output = {
+                "success": True,
+                "query": query,
+                "engine": engine,
+                "count": len(results),
+                "results": results
+            }
+            return json.dumps(output, indent=2, ensure_ascii=False)
+        except Exception as e:
+            return json.dumps({"success": False, "error": str(e)})
+    
+    def _get_encrypted_web_search_api_key(self, engine_key: str) -> str:
+        """Load encrypted API key for a search engine from database settings.
+        
+        Uses the same database path as the Pomera UI to ensure keys are loaded
+        from the correct location.
+        """
+        try:
+            from tools.ai_tools import decrypt_api_key
+            from core.database_settings_manager import DatabaseSettingsManager
+            
+            # Get the correct database path (same as UI uses)
+            try:
+                from core.data_directory import get_database_path
+                db_path = get_database_path("settings.db")
+            except ImportError:
+                # Fallback to relative path
+                db_path = "settings.db"
+            
+            settings_manager = DatabaseSettingsManager(db_path=db_path)
+            web_search_settings = settings_manager.get_tool_settings("Web Search")
+            
+            encrypted = web_search_settings.get(f"{engine_key}_api_key", "")
+            if encrypted:
+                return decrypt_api_key(encrypted)
+        except Exception as e:
+            self._logger.warning(f"Failed to load API key for {engine_key}: {e}")
+        return ""
+    
+    def _get_web_search_setting(self, engine_key: str, setting: str, default: str) -> str:
+        """Get a web search setting from database.
+        
+        Uses the same database path as the Pomera UI.
+        """
+        try:
+            from core.database_settings_manager import DatabaseSettingsManager
+            
+            # Get the correct database path (same as UI uses)
+            try:
+                from core.data_directory import get_database_path
+                db_path = get_database_path("settings.db")
+            except ImportError:
+                db_path = "settings.db"
+            
+            settings_manager = DatabaseSettingsManager(db_path=db_path)
+            web_search_settings = settings_manager.get_tool_settings("Web Search")
+            
+            return web_search_settings.get(f"{engine_key}_{setting}", default)
+        except Exception:
+            return default
+    
+    def _mcp_search_duckduckgo(self, query: str, count: int) -> list:
+        """Search DuckDuckGo (free, no API key)."""
+        try:
+            from ddgs import DDGS
+        except ImportError:
+            return [{"title": "Error", "snippet": "DuckDuckGo requires: pip install ddgs", "url": ""}]
+        
+        try:
+            with DDGS() as ddgs:
+                results = []
+                for r in ddgs.text(query, max_results=count):
+                    results.append({
+                        "title": r.get("title", ""),
+                        "snippet": r.get("body", ""),
+                        "url": r.get("href", ""),
+                        "source": "duckduckgo"
+                    })
+                return results
+        except Exception as e:
+            return [{"title": "Error", "snippet": str(e), "url": ""}]
+    
+    def _mcp_search_tavily(self, query: str, count: int, api_key: str) -> list:
+        """Search using Tavily API."""
+        import urllib.request
+        import json
+        
+        url = "https://api.tavily.com/search"
+        data = json.dumps({
+            "api_key": api_key,
+            "query": query,
+            "search_depth": "basic",
+            "max_results": count
+        }).encode()
+        
+        req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
+        with urllib.request.urlopen(req, timeout=30) as response:
+            result = json.loads(response.read().decode())
+        
+        return [
+            {"title": item.get("title", ""), "snippet": item.get("content", ""), 
+             "url": item.get("url", ""), "source": "tavily"}
+            for item in result.get("results", [])
+        ]
+    
+    def _mcp_search_google(self, query: str, count: int, api_key: str, cse_id: str) -> list:
+        """Search using Google Custom Search API."""
+        import urllib.request
+        import urllib.parse
+        import json
+        
+        url = f"https://www.googleapis.com/customsearch/v1?key={api_key}&cx={cse_id}&q={urllib.parse.quote(query)}&num={min(count, 10)}"
+        
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req, timeout=30) as response:
+            data = json.loads(response.read().decode())
+        
+        return [
+            {"title": item.get("title", ""), "snippet": item.get("snippet", ""), 
+             "url": item.get("link", ""), "source": "google"}
+            for item in data.get("items", [])
+        ]
+    
+    def _mcp_search_brave(self, query: str, count: int, api_key: str) -> list:
+        """Search using Brave Search API."""
+        import urllib.request
+        import urllib.parse
+        import json
+        
+        url = f"https://api.search.brave.com/res/v1/web/search?q={urllib.parse.quote(query)}&count={min(count, 20)}"
+        
+        req = urllib.request.Request(url, headers={
+            "Accept": "application/json",
+            "X-Subscription-Token": api_key
+        })
+        with urllib.request.urlopen(req, timeout=30) as response:
+            data = json.loads(response.read().decode())
+        
+        return [
+            {"title": item.get("title", ""), "snippet": item.get("description", ""), 
+             "url": item.get("url", ""), "source": "brave"}
+            for item in data.get("web", {}).get("results", [])
+        ]
+    
+    def _mcp_search_serpapi(self, query: str, count: int, api_key: str) -> list:
+        """Search using SerpApi."""
+        import urllib.request
+        import urllib.parse
+        import json
+        
+        url = f"https://serpapi.com/search?q={urllib.parse.quote(query)}&api_key={api_key}&num={min(count, 10)}"
+        
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req, timeout=30) as response:
+            data = json.loads(response.read().decode())
+        
+        return [
+            {"title": item.get("title", ""), "snippet": item.get("snippet", ""), 
+             "url": item.get("link", ""), "source": "serpapi"}
+            for item in data.get("organic_results", [])[:count]
+        ]
+    
+    def _mcp_search_serper(self, query: str, count: int, api_key: str) -> list:
+        """Search using Serper.dev."""
+        import urllib.request
+        import json
+        
+        url = "https://google.serper.dev/search"
+        data = json.dumps({"q": query, "num": min(count, 10)}).encode()
+        
+        req = urllib.request.Request(url, data=data, headers={
+            "X-API-KEY": api_key,
+            "Content-Type": "application/json"
+        })
+        with urllib.request.urlopen(req, timeout=30) as response:
+            result = json.loads(response.read().decode())
+        
+        return [
+            {"title": item.get("title", ""), "snippet": item.get("snippet", ""), 
+             "url": item.get("link", ""), "source": "serper"}
+            for item in result.get("organic", [])
+        ]
+    
+    def _register_read_url_tool(self) -> None:
+        """Register the URL Content Reader Tool."""
+        self.register(MCPToolAdapter(
+            name="pomera_read_url",
+            description="Fetch URL content and convert HTML to Markdown. "
+                       "Extracts main content area and outputs clean markdown format.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string",
+                        "description": "URL to fetch"
+                    },
+                    "timeout": {
+                        "type": "integer",
+                        "description": "Request timeout in seconds",
+                        "default": 30,
+                        "minimum": 5,
+                        "maximum": 120
+                    },
+                    "extract_main_content": {
+                        "type": "boolean",
+                        "description": "Try to extract main content area only",
+                        "default": True
+                    }
+                },
+                "required": ["url"]
+            },
+            handler=self._handle_read_url
+        ))
+    
+    def _handle_read_url(self, args: Dict[str, Any]) -> str:
+        """Handle URL content reader tool execution."""
+        from tools.url_content_reader import URLContentReader
+        import json
+        
+        url = args.get("url", "")
+        timeout = args.get("timeout", 30)
+        extract_main = args.get("extract_main_content", True)
+        
+        if not url:
+            return json.dumps({"success": False, "error": "URL is required"})
+        
+        try:
+            reader = URLContentReader()
+            markdown = reader.fetch_and_convert(url, timeout=timeout, extract_main_content=extract_main)
+            return json.dumps({
+                "success": True,
+                "url": url,
+                "markdown": markdown,
+                "length": len(markdown)
+            }, ensure_ascii=False)
+        except Exception as e:
+            return json.dumps({"success": False, "error": f"Error fetching URL: {str(e)}"})
 
 
 # Singleton instance for convenience

package/core/settings_defaults_registry.py

@@ -5,6 +5,8 @@ Centralizes all tool default settings into a single registry system for consiste
 first-launch initialization. Provides schema validation, deep merge capability,
 and backward compatibility with existing tools.
 
+Supports loading custom defaults from external defaults.json file.
+
 Author: Pomera AI Commander Team
 """
 
@@ -12,6 +14,8 @@ from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Callable, Set, Tuple
 from copy import deepcopy
 import logging
+import json
+import os
 
 
 @dataclass
@@ -47,6 +51,7 @@ class SettingsDefaultsRegistry:
     - Schema validation for tool settings
     - Deep merge capability for user settings with defaults
     - Backward compatibility with existing tools
+    - External defaults.json file support for user customization
     """
     
     _instance: Optional['SettingsDefaultsRegistry'] = None
@@ -67,9 +72,103 @@ class SettingsDefaultsRegistry:
         self._tool_specs: Dict[str, ToolDefaultsSpec] = {}
         self._app_defaults: Dict[str, Any] = {}
         self._initialized = True
+        self._json_defaults_loaded = False
         
         # Register all built-in tool defaults
         self._register_builtin_defaults()
+        
+        # Load custom defaults from external JSON file (overrides builtins)
+        self._load_from_json_file()
+    
+    def _load_from_json_file(self) -> bool:
+        """
+        Load custom defaults from external defaults.json file.
+        
+        This allows users to customize tool defaults without modifying Python code.
+        The JSON file overrides built-in defaults for matching tool names.
+        
+        Returns:
+            True if JSON was loaded successfully, False otherwise.
+        """
+        try:
+            # Try multiple locations for defaults.json
+            possible_paths = [
+                os.path.join(os.path.dirname(__file__), "..", "defaults.json"),  # app root
+                os.path.join(os.path.dirname(__file__), "defaults.json"),  # core directory
+            ]
+            
+            json_path = None
+            for path in possible_paths:
+                if os.path.exists(path):
+                    json_path = os.path.abspath(path)
+                    break
+            
+            if not json_path:
+                self.logger.debug("No external defaults.json found - using built-in defaults")
+                return False
+            
+            with open(json_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            tools_data = data.get("tools", {})
+            
+            # Override defaults for matching tools
+            for tool_name, custom_defaults in tools_data.items():
+                # Skip metadata keys
+                if tool_name.startswith("_"):
+                    continue
+                    
+                if tool_name in self._tool_specs:
+                    # Merge custom defaults with existing (custom takes precedence)
+                    existing = self._tool_specs[tool_name]
+                    merged_defaults = deepcopy(existing.defaults)
+                    for key, value in custom_defaults.items():
+                        if not key.startswith("_"):  # Skip metadata keys like _note
+                            merged_defaults[key] = value
+                    
+                    # Update the spec with merged defaults
+                    self._tool_specs[tool_name] = ToolDefaultsSpec(
+                        tool_name=existing.tool_name,
+                        defaults=merged_defaults,
+                        required_keys=existing.required_keys,
+                        description=existing.description,
+                        version=existing.version
+                    )
+                    self.logger.debug(f"Loaded custom defaults for '{tool_name}' from JSON")
+                else:
+                    # New tool not in builtins - create new spec
+                    self._tool_specs[tool_name] = ToolDefaultsSpec(
+                        tool_name=tool_name,
+                        defaults={k: v for k, v in custom_defaults.items() if not k.startswith("_")},
+                        description=f"Custom tool from defaults.json"
+                    )
+                    self.logger.debug(f"Added new tool '{tool_name}' from JSON")
+            
+            self._json_defaults_loaded = True
+            self.logger.info(f"Loaded custom defaults from: {json_path}")
+            return True
+            
+        except json.JSONDecodeError as e:
+            self.logger.error(f"Invalid JSON in defaults.json: {e}")
+            return False
+        except Exception as e:
+            self.logger.warning(f"Could not load defaults.json: {e}")
+            return False
+    
+    def get_json_defaults_path(self) -> Optional[str]:
+        """Get the path to the defaults.json file if it exists."""
+        possible_paths = [
+            os.path.join(os.path.dirname(__file__), "..", "defaults.json"),
+            os.path.join(os.path.dirname(__file__), "defaults.json"),
+        ]
+        for path in possible_paths:
+            if os.path.exists(path):
+                return os.path.abspath(path)
+        return None
+    
+    def is_json_defaults_loaded(self) -> bool:
+        """Check if external defaults.json was loaded."""
+        return self._json_defaults_loaded
     
     def _register_builtin_defaults(self) -> None:
         """Register all built-in tool default settings."""
@@ -406,21 +505,25 @@ class SettingsDefaultsRegistry:
             description="Cohere AI integration"
         ))
         
-        # HuggingFace AI - Updated December 2025
-        # Latest: Llama 3.3, Mistral Small 3, Qwen 2.5
+        # HuggingFace AI - Updated January 2026
+        # Free inference API - most popular open models
         self.register_tool(ToolDefaultsSpec(
             tool_name="HuggingFace AI",
             defaults={
                 "API_KEY": "putinyourkey",
                 "MODEL": "meta-llama/Llama-3.3-70B-Instruct",
                 "MODELS_LIST": [
+                    # Most popular free inference models
                     "meta-llama/Llama-3.3-70B-Instruct",
                     "meta-llama/Meta-Llama-3.1-70B-Instruct",
                     "meta-llama/Meta-Llama-3.1-8B-Instruct",
-                    "mistralai/Mistral-Small-3-Instruct",
-                    "mistralai/Mistral-7B-Instruct-v0.3",
                     "Qwen/Qwen2.5-72B-Instruct",
-                    "google/gemma-2-27b-it"
+                    "Qwen/Qwen2.5-Coder-32B-Instruct",
+                    "mistralai/Mistral-Small-3.1-24B-Instruct-2503",
+                    "mistralai/Mistral-7B-Instruct-v0.3",
+                    "deepseek-ai/DeepSeek-V3",
+                    "google/gemma-2-27b-it",
+                    "microsoft/Phi-3.5-mini-instruct"
                 ],
                 "system_prompt": "You are a helpful assistant.",
                 "max_tokens": 4096,
@@ -430,7 +533,7 @@ class SettingsDefaultsRegistry:
                 "seed": ""
             },
             required_keys={"API_KEY", "MODEL"},
-            description="HuggingFace AI integration"
+            description="HuggingFace AI free inference (popular open models)"
         ))
         
         # Groq AI - Updated December 2025
@@ -462,23 +565,31 @@ class SettingsDefaultsRegistry:
             description="Groq AI integration"
         ))
         
-        # OpenRouterAI - Updated December 2025
-        # Latest: Claude Opus 4.5, GPT-4.1, Gemini 2.5, DeepSeek 3.2
+        # OpenRouterAI - Updated January 2026
+        # Latest: Claude Opus 4.5, GPT-4.1, Gemini 2.5, DeepSeek V3
+        # Includes FREE tier models marked with :free suffix
         self.register_tool(ToolDefaultsSpec(
             tool_name="OpenRouterAI",
             defaults={
                 "API_KEY": "putinyourkey",
                 "MODEL": "anthropic/claude-sonnet-4.5",
                 "MODELS_LIST": [
+                    # Premium models
                     "anthropic/claude-sonnet-4.5",
                     "anthropic/claude-opus-4.5",
-                    "openai/gpt-4.1",
+                    "openai/gpt-4o",
                     "google/gemini-2.5-pro",
                     "google/gemini-2.5-flash",
                     "deepseek/deepseek-chat",
                     "meta-llama/llama-3.3-70b-instruct",
+                    # FREE models (no cost)
+                    "google/gemini-2.5-flash:free",
                     "google/gemini-2.0-flash:free",
-                    "meta-llama/llama-3.1-8b-instruct:free"
+                    "meta-llama/llama-3.3-70b-instruct:free",
+                    "meta-llama/llama-3.1-8b-instruct:free",
+                    "qwen/qwen-2.5-72b-instruct:free",
+                    "mistralai/mistral-7b-instruct:free",
+                    "deepseek/deepseek-chat:free"
                 ],
                 "system_prompt": "You are a helpful assistant.",
                 "temperature": 0.7,
@@ -492,7 +603,34 @@ class SettingsDefaultsRegistry:
                 "stop": ""
             },
             required_keys={"API_KEY", "MODEL"},
-            description="OpenRouter AI integration"
+            description="OpenRouter AI integration (includes free models)"
+        ))
+        
+        # Studio LM - Local LLM support via LM Studio or Ollama (January 2026)
+        # Default endpoint is LM Studio (port 1234), Ollama uses port 11434
+        self.register_tool(ToolDefaultsSpec(
+            tool_name="Studio LM",
+            defaults={
+                "API_KEY": "",  # Often not required for local
+                "MODEL": "local-model",
+                "MODELS_LIST": [
+                    "local-model",
+                    "llama-3.3-70b",
+                    "qwen2.5-72b",
+                    "mistral-7b",
+                    "phi-3.5-mini",
+                    "gemma-2-9b",
+                    "deepseek-coder-v2"
+                ],
+                "ENDPOINT": "http://127.0.0.1:1234/v1",  # LM Studio default
+                "system_prompt": "You are a helpful assistant.",
+                "temperature": 0.7,
+                "max_tokens": 4096,
+                "top_p": 0.95,
+                "stream": True
+            },
+            required_keys={"ENDPOINT", "MODEL"},
+            description="Local LLM via LM Studio or Ollama (OpenAI-compatible API)"
         ))
         
         # AWS Bedrock - Updated December 2025
@@ -913,15 +1051,21 @@ class SettingsDefaultsRegistry:
         """
         Get complete default settings including app-level and all tool defaults.
         
+        NOTE: This method intentionally EXCLUDES input_tabs and output_tabs.
+        Tab content is user data that must be loaded from persistent storage,
+        not overwritten with empty defaults. Including tabs here caused a
+        regression where saved tab content was lost on app restart.
+        
         Args:
-            tab_count: Number of tabs for input/output (default 7)
+            tab_count: Number of tabs for input/output (default 7, unused but kept for API compatibility)
             
         Returns:
-            Complete default settings dictionary
+            Complete default settings dictionary (excludes tab content)
         """
         defaults = deepcopy(self._app_defaults)
-        defaults["input_tabs"] = [""] * tab_count
-        defaults["output_tabs"] = [""] * tab_count
+        # NOTE: input_tabs and output_tabs are intentionally NOT included here.
+        # They are user data stored in the database, not default configurations.
+        # Adding them here would overwrite saved user content with empty arrays.
         defaults["tool_settings"] = self.get_all_tool_defaults()
         return defaults
     

package/mcp.json

@@ -1,6 +1,6 @@
 {
   "name": "pomera-ai-commander",
-  "version": "1.2.8",
+  "version": "1.2.9",
   "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.8",
+  "version": "1.2.9",
   "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": {