pomera-ai-commander 1.1.1 → 1.2.2

package/core/database_settings_manager_interface.py

@@ -1,457 +1,457 @@
-"""
-Database Settings Manager Interface Compatibility Layer
-
-This module provides interface compatibility classes that ensure all existing
-settings manager interfaces work with the database backend without requiring
-code changes in the tools that use them.
-
-Author: Pomera AI Commander
-"""
-
-import logging
-from typing import Dict, List, Any, Optional
-from abc import ABC, abstractmethod
-
-from .database_settings_manager import DatabaseSettingsManager
-from .database_curl_settings_manager import DatabaseCurlSettingsManager
-from .database_promera_ai_settings_manager import DatabasePromeraAISettingsManager, DatabaseDialogSettingsAdapter
-
-
-class SettingsManagerInterface(ABC):
-    """
-    Abstract base class defining the settings manager interface expected by tools.
-    
-    This interface ensures compatibility with existing tool code while allowing
-    different backend implementations (JSON file, database, etc.).
-    """
-    
-    @abstractmethod
-    def get_tool_settings(self, tool_name: str) -> Dict[str, Any]:
-        """Get settings for a specific tool."""
-        pass
-    
-    @abstractmethod
-    def save_settings(self):
-        """Save current settings to persistent storage."""
-        pass
-    
-    @abstractmethod
-    def get_pattern_library(self) -> List[Dict[str, str]]:
-        """Get the regex pattern library."""
-        pass
-
-
-class DatabaseSettingsManagerAdapter(SettingsManagerInterface):
-    """
-    Adapter that provides the SettingsManager interface using database backend.
-    
-    This adapter ensures that existing tools like FindReplaceWidget can work
-    with the database backend without any code changes.
-    """
-    
-    def __init__(self, database_settings_manager: DatabaseSettingsManager, logger=None):
-        """
-        Initialize the settings manager adapter.
-        
-        Args:
-            database_settings_manager: DatabaseSettingsManager instance
-            logger: Optional logger instance
-        """
-        self.database_manager = database_settings_manager
-        self.promera_ai_manager = DatabasePromeraAISettingsManager(database_settings_manager, logger)
-        self.logger = logger or logging.getLogger(__name__)
-    
-    def get_tool_settings(self, tool_name: str) -> Dict[str, Any]:
-        """
-        Get settings for a specific tool.
-        
-        Args:
-            tool_name: Name of the tool
-            
-        Returns:
-            Dictionary of tool settings
-        """
-        return self.promera_ai_manager.get_tool_settings(tool_name)
-    
-    def save_settings(self):
-        """Save current settings to persistent storage."""
-        self.promera_ai_manager.save_settings()
-    
-    def get_pattern_library(self) -> List[Dict[str, str]]:
-        """
-        Get the regex pattern library.
-        
-        Returns:
-            List of pattern dictionaries
-        """
-        return self.promera_ai_manager.get_pattern_library()
-    
-    # Additional methods for enhanced functionality
-    
-    def set_tool_setting(self, tool_name: str, key: str, value: Any) -> None:
-        """Set a specific tool setting."""
-        self.promera_ai_manager.set_tool_setting(tool_name, key, value)
-    
-    def get_tool_setting(self, tool_name: str, key: str, default: Any = None) -> Any:
-        """Get a specific tool setting."""
-        return self.promera_ai_manager.get_tool_setting(tool_name, key, default)
-    
-    def get_setting(self, key: str, default: Any = None) -> Any:
-        """Get a core application setting."""
-        return self.promera_ai_manager.get_setting(key, default)
-    
-    def set_setting(self, key: str, value: Any) -> None:
-        """Set a core application setting."""
-        self.promera_ai_manager.set_setting(key, value)
-
-
-class DatabaseSettingsManagerFactory:
-    """
-    Factory class for creating database-compatible settings managers.
-    
-    This factory provides a centralized way to create all the different types
-    of settings managers needed by the application while ensuring they all
-    use the same database backend.
-    """
-    
-    def __init__(self, db_path: str = ":memory:", backup_path: Optional[str] = None,
-                 json_settings_path: str = "settings.json", logger=None):
-        """
-        Initialize the settings manager factory.
-        
-        Args:
-            db_path: Path to SQLite database file
-            backup_path: Path for automatic backups
-            json_settings_path: Path to JSON settings file for migration
-            logger: Optional logger instance
-        """
-        self.db_path = db_path
-        self.backup_path = backup_path
-        self.json_settings_path = json_settings_path
-        self.logger = logger or logging.getLogger(__name__)
-        
-        # Create the main database settings manager
-        self.database_manager = DatabaseSettingsManager(
-            db_path=db_path,
-            backup_path=backup_path,
-            json_settings_path=json_settings_path
-        )
-        
-        # Cache for created managers
-        self._managers_cache = {}
-    
-    def get_main_settings_manager(self) -> DatabaseSettingsManager:
-        """
-        Get the main database settings manager.
-        
-        Returns:
-            DatabaseSettingsManager instance
-        """
-        return self.database_manager
-    
-    def get_curl_settings_manager(self) -> DatabaseCurlSettingsManager:
-        """
-        Get a cURL-specific settings manager.
-        
-        Returns:
-            DatabaseCurlSettingsManager instance
-        """
-        if 'curl' not in self._managers_cache:
-            self._managers_cache['curl'] = DatabaseCurlSettingsManager(
-                self.database_manager, self.logger
-            )
-        return self._managers_cache['curl']
-    
-    def get_promera_ai_settings_manager(self) -> DatabasePromeraAISettingsManager:
-        """
-        Get a PromeraAI-compatible settings manager.
-        
-        Returns:
-            DatabasePromeraAISettingsManager instance
-        """
-        if 'promera_ai' not in self._managers_cache:
-            self._managers_cache['promera_ai'] = DatabasePromeraAISettingsManager(
-                self.database_manager, self.logger
-            )
-        return self._managers_cache['promera_ai']
-    
-    def get_settings_manager_adapter(self) -> DatabaseSettingsManagerAdapter:
-        """
-        Get a settings manager adapter for tool compatibility.
-        
-        Returns:
-            DatabaseSettingsManagerAdapter instance
-        """
-        if 'adapter' not in self._managers_cache:
-            self._managers_cache['adapter'] = DatabaseSettingsManagerAdapter(
-                self.database_manager, self.logger
-            )
-        return self._managers_cache['adapter']
-    
-    def get_dialog_settings_adapter(self) -> DatabaseDialogSettingsAdapter:
-        """
-        Get a dialog settings adapter.
-        
-        Returns:
-            DatabaseDialogSettingsAdapter instance
-        """
-        if 'dialog' not in self._managers_cache:
-            self._managers_cache['dialog'] = DatabaseDialogSettingsAdapter(
-                self.database_manager, self.logger
-            )
-        return self._managers_cache['dialog']
-    
-    def create_tool_specific_manager(self, tool_name: str) -> 'ToolSpecificSettingsManager':
-        """
-        Create a tool-specific settings manager.
-        
-        Args:
-            tool_name: Name of the tool
-            
-        Returns:
-            ToolSpecificSettingsManager instance
-        """
-        return ToolSpecificSettingsManager(self.database_manager, tool_name, self.logger)
-    
-    def close_all(self) -> None:
-        """Close all settings managers and cleanup resources."""
-        try:
-            self.database_manager.close()
-            self._managers_cache.clear()
-            self.logger.info("All settings managers closed")
-        except Exception as e:
-            self.logger.error(f"Error closing settings managers: {e}")
-
-
-class ToolSpecificSettingsManager:
-    """
-    A tool-specific settings manager that provides a focused interface
-    for individual tools to manage their settings.
-    """
-    
-    def __init__(self, database_settings_manager: DatabaseSettingsManager, 
-                 tool_name: str, logger=None):
-        """
-        Initialize the tool-specific settings manager.
-        
-        Args:
-            database_settings_manager: DatabaseSettingsManager instance
-            tool_name: Name of the tool this manager is for
-            logger: Optional logger instance
-        """
-        self.database_manager = database_settings_manager
-        self.tool_name = tool_name
-        self.logger = logger or logging.getLogger(__name__)
-    
-    def get_settings(self) -> Dict[str, Any]:
-        """
-        Get all settings for this tool.
-        
-        Returns:
-            Dictionary of tool settings
-        """
-        return self.database_manager.get_tool_settings(self.tool_name)
-    
-    def get_setting(self, key: str, default: Any = None) -> Any:
-        """
-        Get a specific setting for this tool.
-        
-        Args:
-            key: Setting key
-            default: Default value if not found
-            
-        Returns:
-            Setting value or default
-        """
-        settings = self.get_settings()
-        return settings.get(key, default)
-    
-    def set_setting(self, key: str, value: Any) -> None:
-        """
-        Set a specific setting for this tool.
-        
-        Args:
-            key: Setting key
-            value: Setting value
-        """
-        self.database_manager.set_tool_setting(self.tool_name, key, value)
-    
-    def update_settings(self, settings_update: Dict[str, Any]) -> None:
-        """
-        Update multiple settings for this tool.
-        
-        Args:
-            settings_update: Dictionary of setting updates
-        """
-        for key, value in settings_update.items():
-            self.set_setting(key, value)
-    
-    def reset_to_defaults(self, defaults: Dict[str, Any]) -> None:
-        """
-        Reset tool settings to provided defaults.
-        
-        Args:
-            defaults: Dictionary of default settings
-        """
-        # Clear existing settings for this tool
-        current_settings = self.get_settings()
-        for key in current_settings.keys():
-            if key not in defaults:
-                # Remove settings that are no longer in defaults
-                # Note: This would require implementing a delete method
-                pass
-        
-        # Set all default values
-        self.update_settings(defaults)
-    
-    def export_settings(self, filepath: str) -> bool:
-        """
-        Export this tool's settings to a file.
-        
-        Args:
-            filepath: Target file path
-            
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            import json
-            settings = self.get_settings()
-            
-            with open(filepath, 'w', encoding='utf-8') as f:
-                json.dump({self.tool_name: settings}, f, indent=4, ensure_ascii=False)
-            
-            self.logger.info(f"Tool settings for {self.tool_name} exported to {filepath}")
-            return True
-            
-        except Exception as e:
-            self.logger.error(f"Error exporting tool settings for {self.tool_name}: {e}")
-            return False
-    
-    def import_settings(self, filepath: str) -> bool:
-        """
-        Import this tool's settings from a file.
-        
-        Args:
-            filepath: Source file path
-            
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            import json
-            import os
-            
-            if not os.path.exists(filepath):
-                self.logger.error(f"Import file not found: {filepath}")
-                return False
-            
-            with open(filepath, 'r', encoding='utf-8') as f:
-                imported_data = json.load(f)
-            
-            # Handle different import formats
-            if self.tool_name in imported_data:
-                settings = imported_data[self.tool_name]
-            elif isinstance(imported_data, dict):
-                # Assume the entire file is settings for this tool
-                settings = imported_data
-            else:
-                self.logger.error("Invalid import file format")
-                return False
-            
-            self.update_settings(settings)
-            self.logger.info(f"Tool settings for {self.tool_name} imported from {filepath}")
-            return True
-            
-        except Exception as e:
-            self.logger.error(f"Error importing tool settings for {self.tool_name}: {e}")
-            return False
-
-
-# Convenience functions for backward compatibility
-
-def create_find_replace_settings_manager(database_settings_manager: DatabaseSettingsManager, 
-                                       logger=None) -> DatabaseSettingsManagerAdapter:
-    """
-    Create a settings manager compatible with FindReplaceWidget.
-    
-    Args:
-        database_settings_manager: DatabaseSettingsManager instance
-        logger: Optional logger instance
-        
-    Returns:
-        DatabaseSettingsManagerAdapter instance
-    """
-    return DatabaseSettingsManagerAdapter(database_settings_manager, logger)
-
-
-def create_legacy_settings_manager(database_settings_manager: DatabaseSettingsManager, 
-                                 logger=None) -> DatabasePromeraAISettingsManager:
-    """
-    Create a legacy-compatible settings manager.
-    
-    This function provides backward compatibility for code that expects
-    the original PromeraAISettingsManager interface.
-    
-    Args:
-        database_settings_manager: DatabaseSettingsManager instance
-        logger: Optional logger instance
-        
-    Returns:
-        DatabasePromeraAISettingsManager instance
-    """
-    return DatabasePromeraAISettingsManager(database_settings_manager, logger)
-
-
-# Global factory instance for easy access
-_global_factory: Optional[DatabaseSettingsManagerFactory] = None
-
-
-def initialize_global_settings_factory(db_path: str = ":memory:", 
-                                     backup_path: Optional[str] = None,
-                                     json_settings_path: str = "settings.json", 
-                                     logger=None) -> DatabaseSettingsManagerFactory:
-    """
-    Initialize the global settings manager factory.
-    
-    Args:
-        db_path: Path to SQLite database file
-        backup_path: Path for automatic backups
-        json_settings_path: Path to JSON settings file for migration
-        logger: Optional logger instance
-        
-    Returns:
-        DatabaseSettingsManagerFactory instance
-    """
-    global _global_factory
-    _global_factory = DatabaseSettingsManagerFactory(
-        db_path=db_path,
-        backup_path=backup_path,
-        json_settings_path=json_settings_path,
-        logger=logger
-    )
-    return _global_factory
-
-
-def get_global_settings_factory() -> DatabaseSettingsManagerFactory:
-    """
-    Get the global settings manager factory.
-    
-    Returns:
-        DatabaseSettingsManagerFactory instance
-        
-    Raises:
-        RuntimeError: If factory not initialized
-    """
-    global _global_factory
-    if _global_factory is None:
-        raise RuntimeError("Global settings factory not initialized. Call initialize_global_settings_factory() first.")
-    return _global_factory
-
-
-def close_global_settings_factory() -> None:
-    """Close the global settings manager factory."""
-    global _global_factory
-    if _global_factory is not None:
-        _global_factory.close_all()
+"""
+Database Settings Manager Interface Compatibility Layer
+
+This module provides interface compatibility classes that ensure all existing
+settings manager interfaces work with the database backend without requiring
+code changes in the tools that use them.
+
+Author: Pomera AI Commander
+"""
+
+import logging
+from typing import Dict, List, Any, Optional
+from abc import ABC, abstractmethod
+
+from .database_settings_manager import DatabaseSettingsManager
+from .database_curl_settings_manager import DatabaseCurlSettingsManager
+from .database_promera_ai_settings_manager import DatabasePromeraAISettingsManager, DatabaseDialogSettingsAdapter
+
+
+class SettingsManagerInterface(ABC):
+    """
+    Abstract base class defining the settings manager interface expected by tools.
+    
+    This interface ensures compatibility with existing tool code while allowing
+    different backend implementations (JSON file, database, etc.).
+    """
+    
+    @abstractmethod
+    def get_tool_settings(self, tool_name: str) -> Dict[str, Any]:
+        """Get settings for a specific tool."""
+        pass
+    
+    @abstractmethod
+    def save_settings(self):
+        """Save current settings to persistent storage."""
+        pass
+    
+    @abstractmethod
+    def get_pattern_library(self) -> List[Dict[str, str]]:
+        """Get the regex pattern library."""
+        pass
+
+
+class DatabaseSettingsManagerAdapter(SettingsManagerInterface):
+    """
+    Adapter that provides the SettingsManager interface using database backend.
+    
+    This adapter ensures that existing tools like FindReplaceWidget can work
+    with the database backend without any code changes.
+    """
+    
+    def __init__(self, database_settings_manager: DatabaseSettingsManager, logger=None):
+        """
+        Initialize the settings manager adapter.
+        
+        Args:
+            database_settings_manager: DatabaseSettingsManager instance
+            logger: Optional logger instance
+        """
+        self.database_manager = database_settings_manager
+        self.promera_ai_manager = DatabasePromeraAISettingsManager(database_settings_manager, logger)
+        self.logger = logger or logging.getLogger(__name__)
+    
+    def get_tool_settings(self, tool_name: str) -> Dict[str, Any]:
+        """
+        Get settings for a specific tool.
+        
+        Args:
+            tool_name: Name of the tool
+            
+        Returns:
+            Dictionary of tool settings
+        """
+        return self.promera_ai_manager.get_tool_settings(tool_name)
+    
+    def save_settings(self):
+        """Save current settings to persistent storage."""
+        self.promera_ai_manager.save_settings()
+    
+    def get_pattern_library(self) -> List[Dict[str, str]]:
+        """
+        Get the regex pattern library.
+        
+        Returns:
+            List of pattern dictionaries
+        """
+        return self.promera_ai_manager.get_pattern_library()
+    
+    # Additional methods for enhanced functionality
+    
+    def set_tool_setting(self, tool_name: str, key: str, value: Any) -> None:
+        """Set a specific tool setting."""
+        self.promera_ai_manager.set_tool_setting(tool_name, key, value)
+    
+    def get_tool_setting(self, tool_name: str, key: str, default: Any = None) -> Any:
+        """Get a specific tool setting."""
+        return self.promera_ai_manager.get_tool_setting(tool_name, key, default)
+    
+    def get_setting(self, key: str, default: Any = None) -> Any:
+        """Get a core application setting."""
+        return self.promera_ai_manager.get_setting(key, default)
+    
+    def set_setting(self, key: str, value: Any) -> None:
+        """Set a core application setting."""
+        self.promera_ai_manager.set_setting(key, value)
+
+
+class DatabaseSettingsManagerFactory:
+    """
+    Factory class for creating database-compatible settings managers.
+    
+    This factory provides a centralized way to create all the different types
+    of settings managers needed by the application while ensuring they all
+    use the same database backend.
+    """
+    
+    def __init__(self, db_path: str = ":memory:", backup_path: Optional[str] = None,
+                 json_settings_path: str = "settings.json", logger=None):
+        """
+        Initialize the settings manager factory.
+        
+        Args:
+            db_path: Path to SQLite database file
+            backup_path: Path for automatic backups
+            json_settings_path: Path to JSON settings file for migration
+            logger: Optional logger instance
+        """
+        self.db_path = db_path
+        self.backup_path = backup_path
+        self.json_settings_path = json_settings_path
+        self.logger = logger or logging.getLogger(__name__)
+        
+        # Create the main database settings manager
+        self.database_manager = DatabaseSettingsManager(
+            db_path=db_path,
+            backup_path=backup_path,
+            json_settings_path=json_settings_path
+        )
+        
+        # Cache for created managers
+        self._managers_cache = {}
+    
+    def get_main_settings_manager(self) -> DatabaseSettingsManager:
+        """
+        Get the main database settings manager.
+        
+        Returns:
+            DatabaseSettingsManager instance
+        """
+        return self.database_manager
+    
+    def get_curl_settings_manager(self) -> DatabaseCurlSettingsManager:
+        """
+        Get a cURL-specific settings manager.
+        
+        Returns:
+            DatabaseCurlSettingsManager instance
+        """
+        if 'curl' not in self._managers_cache:
+            self._managers_cache['curl'] = DatabaseCurlSettingsManager(
+                self.database_manager, self.logger
+            )
+        return self._managers_cache['curl']
+    
+    def get_promera_ai_settings_manager(self) -> DatabasePromeraAISettingsManager:
+        """
+        Get a PromeraAI-compatible settings manager.
+        
+        Returns:
+            DatabasePromeraAISettingsManager instance
+        """
+        if 'promera_ai' not in self._managers_cache:
+            self._managers_cache['promera_ai'] = DatabasePromeraAISettingsManager(
+                self.database_manager, self.logger
+            )
+        return self._managers_cache['promera_ai']
+    
+    def get_settings_manager_adapter(self) -> DatabaseSettingsManagerAdapter:
+        """
+        Get a settings manager adapter for tool compatibility.
+        
+        Returns:
+            DatabaseSettingsManagerAdapter instance
+        """
+        if 'adapter' not in self._managers_cache:
+            self._managers_cache['adapter'] = DatabaseSettingsManagerAdapter(
+                self.database_manager, self.logger
+            )
+        return self._managers_cache['adapter']
+    
+    def get_dialog_settings_adapter(self) -> DatabaseDialogSettingsAdapter:
+        """
+        Get a dialog settings adapter.
+        
+        Returns:
+            DatabaseDialogSettingsAdapter instance
+        """
+        if 'dialog' not in self._managers_cache:
+            self._managers_cache['dialog'] = DatabaseDialogSettingsAdapter(
+                self.database_manager, self.logger
+            )
+        return self._managers_cache['dialog']
+    
+    def create_tool_specific_manager(self, tool_name: str) -> 'ToolSpecificSettingsManager':
+        """
+        Create a tool-specific settings manager.
+        
+        Args:
+            tool_name: Name of the tool
+            
+        Returns:
+            ToolSpecificSettingsManager instance
+        """
+        return ToolSpecificSettingsManager(self.database_manager, tool_name, self.logger)
+    
+    def close_all(self) -> None:
+        """Close all settings managers and cleanup resources."""
+        try:
+            self.database_manager.close()
+            self._managers_cache.clear()
+            self.logger.info("All settings managers closed")
+        except Exception as e:
+            self.logger.error(f"Error closing settings managers: {e}")
+
+
+class ToolSpecificSettingsManager:
+    """
+    A tool-specific settings manager that provides a focused interface
+    for individual tools to manage their settings.
+    """
+    
+    def __init__(self, database_settings_manager: DatabaseSettingsManager, 
+                 tool_name: str, logger=None):
+        """
+        Initialize the tool-specific settings manager.
+        
+        Args:
+            database_settings_manager: DatabaseSettingsManager instance
+            tool_name: Name of the tool this manager is for
+            logger: Optional logger instance
+        """
+        self.database_manager = database_settings_manager
+        self.tool_name = tool_name
+        self.logger = logger or logging.getLogger(__name__)
+    
+    def get_settings(self) -> Dict[str, Any]:
+        """
+        Get all settings for this tool.
+        
+        Returns:
+            Dictionary of tool settings
+        """
+        return self.database_manager.get_tool_settings(self.tool_name)
+    
+    def get_setting(self, key: str, default: Any = None) -> Any:
+        """
+        Get a specific setting for this tool.
+        
+        Args:
+            key: Setting key
+            default: Default value if not found
+            
+        Returns:
+            Setting value or default
+        """
+        settings = self.get_settings()
+        return settings.get(key, default)
+    
+    def set_setting(self, key: str, value: Any) -> None:
+        """
+        Set a specific setting for this tool.
+        
+        Args:
+            key: Setting key
+            value: Setting value
+        """
+        self.database_manager.set_tool_setting(self.tool_name, key, value)
+    
+    def update_settings(self, settings_update: Dict[str, Any]) -> None:
+        """
+        Update multiple settings for this tool.
+        
+        Args:
+            settings_update: Dictionary of setting updates
+        """
+        for key, value in settings_update.items():
+            self.set_setting(key, value)
+    
+    def reset_to_defaults(self, defaults: Dict[str, Any]) -> None:
+        """
+        Reset tool settings to provided defaults.
+        
+        Args:
+            defaults: Dictionary of default settings
+        """
+        # Clear existing settings for this tool
+        current_settings = self.get_settings()
+        for key in current_settings.keys():
+            if key not in defaults:
+                # Remove settings that are no longer in defaults
+                # Note: This would require implementing a delete method
+                pass
+        
+        # Set all default values
+        self.update_settings(defaults)
+    
+    def export_settings(self, filepath: str) -> bool:
+        """
+        Export this tool's settings to a file.
+        
+        Args:
+            filepath: Target file path
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            import json
+            settings = self.get_settings()
+            
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump({self.tool_name: settings}, f, indent=4, ensure_ascii=False)
+            
+            self.logger.info(f"Tool settings for {self.tool_name} exported to {filepath}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Error exporting tool settings for {self.tool_name}: {e}")
+            return False
+    
+    def import_settings(self, filepath: str) -> bool:
+        """
+        Import this tool's settings from a file.
+        
+        Args:
+            filepath: Source file path
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            import json
+            import os
+            
+            if not os.path.exists(filepath):
+                self.logger.error(f"Import file not found: {filepath}")
+                return False
+            
+            with open(filepath, 'r', encoding='utf-8') as f:
+                imported_data = json.load(f)
+            
+            # Handle different import formats
+            if self.tool_name in imported_data:
+                settings = imported_data[self.tool_name]
+            elif isinstance(imported_data, dict):
+                # Assume the entire file is settings for this tool
+                settings = imported_data
+            else:
+                self.logger.error("Invalid import file format")
+                return False
+            
+            self.update_settings(settings)
+            self.logger.info(f"Tool settings for {self.tool_name} imported from {filepath}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Error importing tool settings for {self.tool_name}: {e}")
+            return False
+
+
+# Convenience functions for backward compatibility
+
+def create_find_replace_settings_manager(database_settings_manager: DatabaseSettingsManager, 
+                                       logger=None) -> DatabaseSettingsManagerAdapter:
+    """
+    Create a settings manager compatible with FindReplaceWidget.
+    
+    Args:
+        database_settings_manager: DatabaseSettingsManager instance
+        logger: Optional logger instance
+        
+    Returns:
+        DatabaseSettingsManagerAdapter instance
+    """
+    return DatabaseSettingsManagerAdapter(database_settings_manager, logger)
+
+
+def create_legacy_settings_manager(database_settings_manager: DatabaseSettingsManager, 
+                                 logger=None) -> DatabasePromeraAISettingsManager:
+    """
+    Create a legacy-compatible settings manager.
+    
+    This function provides backward compatibility for code that expects
+    the original PromeraAISettingsManager interface.
+    
+    Args:
+        database_settings_manager: DatabaseSettingsManager instance
+        logger: Optional logger instance
+        
+    Returns:
+        DatabasePromeraAISettingsManager instance
+    """
+    return DatabasePromeraAISettingsManager(database_settings_manager, logger)
+
+
+# Global factory instance for easy access
+_global_factory: Optional[DatabaseSettingsManagerFactory] = None
+
+
+def initialize_global_settings_factory(db_path: str = ":memory:", 
+                                     backup_path: Optional[str] = None,
+                                     json_settings_path: str = "settings.json", 
+                                     logger=None) -> DatabaseSettingsManagerFactory:
+    """
+    Initialize the global settings manager factory.
+    
+    Args:
+        db_path: Path to SQLite database file
+        backup_path: Path for automatic backups
+        json_settings_path: Path to JSON settings file for migration
+        logger: Optional logger instance
+        
+    Returns:
+        DatabaseSettingsManagerFactory instance
+    """
+    global _global_factory
+    _global_factory = DatabaseSettingsManagerFactory(
+        db_path=db_path,
+        backup_path=backup_path,
+        json_settings_path=json_settings_path,
+        logger=logger
+    )
+    return _global_factory
+
+
+def get_global_settings_factory() -> DatabaseSettingsManagerFactory:
+    """
+    Get the global settings manager factory.
+    
+    Returns:
+        DatabaseSettingsManagerFactory instance
+        
+    Raises:
+        RuntimeError: If factory not initialized
+    """
+    global _global_factory
+    if _global_factory is None:
+        raise RuntimeError("Global settings factory not initialized. Call initialize_global_settings_factory() first.")
+    return _global_factory
+
+
+def close_global_settings_factory() -> None:
+    """Close the global settings manager factory."""
+    global _global_factory
+    if _global_factory is not None:
+        _global_factory.close_all()
         _global_factory = None