kollabor 0.4.9__py3-none-any.whl

core/plugins/registry.py

@@ -0,0 +1,152 @@
+"""Plugin registry system for Kollabor CLI."""
+
+from pathlib import Path
+from typing import Any, Dict, List, Type
+
+import logging
+
+from ..utils import deep_merge
+from .discovery import PluginDiscovery
+from .factory import PluginFactory
+from .collector import PluginStatusCollector
+
+logger = logging.getLogger(__name__)
+
+
+class PluginRegistry:
+    """Simplified registry coordinating plugin discovery, instantiation, and status collection.
+    
+    This class coordinates between three specialized components:
+    - PluginDiscovery: File system scanning and module loading
+    - PluginFactory: Plugin instantiation with dependencies
+    - PluginStatusCollector: Status aggregation from plugin instances
+    """
+    
+    def __init__(self, plugins_dir: Path) -> None:
+        """Initialize the plugin registry with specialized components.
+        
+        Args:
+            plugins_dir: Directory containing plugin modules.
+        """
+        self.plugins_dir = plugins_dir
+        self.discovery = PluginDiscovery(plugins_dir)
+        self.factory = PluginFactory()
+        self.collector = PluginStatusCollector()
+        logger.info(f"Plugin registry initialized with specialized components: {plugins_dir}")
+    
+    def discover_plugins(self) -> List[str]:
+        """Discover available plugins in the plugins directory.
+        
+        Returns:
+            List of discovered plugin module names.
+        """
+        return self.discovery.scan_plugin_files()
+    
+    def load_plugin(self, module_name: str) -> None:
+        """Load a plugin module and register its configuration.
+        
+        Args:
+            module_name: Name of the plugin module to load.
+        """
+        self.discovery.load_module(module_name)
+    
+    def load_all_plugins(self) -> None:
+        """Discover and load all available plugins."""
+        self.discovery.discover_and_load()
+        logger.info(f"Plugin registry loaded {len(self.discovery.loaded_classes)} plugins")
+    
+    def get_merged_config(self) -> Dict[str, Any]:
+        """Get merged configuration from all registered plugins.
+        
+        Returns:
+            Merged configuration dictionary from all plugins.
+        """
+        merged_config = {}
+        plugin_configs = self.discovery.get_all_configs()
+        
+        for plugin_name, plugin_config in plugin_configs.items():
+            # Deep merge plugin config into merged_config
+            merged_config = deep_merge(merged_config, plugin_config)
+            logger.debug(f"Merged config from plugin: {plugin_name}")
+        
+        return merged_config
+    
+    def get_plugin_class(self, plugin_name: str) -> Type:
+        """Get a registered plugin class by name.
+        
+        Args:
+            plugin_name: Name of the plugin class.
+            
+        Returns:
+            Plugin class if found.
+            
+        Raises:
+            KeyError: If plugin is not registered.
+        """
+        return self.discovery.get_plugin_class(plugin_name)
+    
+    def get_plugin_startup_info(self, plugin_name: str, config) -> List[str]:
+        """Get startup information for a plugin.
+        
+        Args:
+            plugin_name: Name of the plugin class.
+            config: Configuration manager instance.
+            
+        Returns:
+            List of startup info strings, or empty list if no info available.
+        """
+        try:
+            plugin_class = self.discovery.get_plugin_class(plugin_name)
+            return self.collector.get_plugin_startup_info(plugin_name, plugin_class, config)
+        except KeyError:
+            logger.warning(f"Plugin {plugin_name} not found for startup info")
+            return []
+    
+    def list_plugins(self) -> List[str]:
+        """Get list of registered plugin names.
+        
+        Returns:
+            List of registered plugin names.
+        """
+        return list(self.discovery.loaded_classes.keys())
+    
+    def instantiate_plugins(self, state_manager, event_bus, renderer, config) -> Dict[str, Any]:
+        """Create instances of all registered plugins that can be instantiated.
+        
+        Args:
+            state_manager: State management system.
+            event_bus: Event bus for hook registration.
+            renderer: Terminal renderer.
+            config: Configuration manager.
+            
+        Returns:
+            Dictionary mapping plugin names to their instances.
+        """
+        plugin_classes = self.discovery.loaded_classes
+        return self.factory.instantiate_all(
+            plugin_classes, state_manager, event_bus, renderer, config
+        )
+    
+    def collect_status_lines(self, plugin_instances: Dict[str, Any]) -> Dict[str, List[str]]:
+        """Collect status lines from all plugins organized by area.
+        
+        Args:
+            plugin_instances: Dictionary of plugin instances.
+            
+        Returns:
+            Dictionary with areas A, B, C containing lists of status lines.
+        """
+        return self.collector.collect_all_status(plugin_instances)
+    
+    def get_registry_stats(self) -> Dict[str, Any]:
+        """Get comprehensive statistics about the registry and its components.
+        
+        Returns:
+            Dictionary with detailed registry statistics.
+        """
+        return {
+            "plugins_directory": str(self.plugins_dir),
+            "discovery_stats": self.discovery.get_discovery_stats(),
+            "factory_stats": self.factory.get_factory_stats(), 
+            "collector_stats": self.collector.get_collector_stats()
+        }

core/storage/__init__.py

@@ -0,0 +1,5 @@
+"""Storage subsystem for Kollabor CLI."""
+
+from .state_manager import StateManager
+
+__all__ = ['StateManager']

core/storage/state_manager.py

@@ -0,0 +1,84 @@
+"""State management system for Kollabor CLI."""
+
+import json
+import logging
+import sqlite3
+import threading
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class StateManager:
+    """SQLite-based state management system.
+    
+    Provides persistent storage for application and plugin state.
+    """
+    
+    def __init__(self, db_path: str) -> None:
+        """Initialize the state manager.
+        
+        Args:
+            db_path: Path to the SQLite database file.
+        """
+        self.db_path = db_path
+        self.conn = sqlite3.connect(db_path, check_same_thread=False)
+        self._lock = threading.Lock()
+        self._init_database()
+        logger.info(f"State manager initialized with database: {db_path}")
+    
+    def _init_database(self) -> None:
+        """Initialize the database schema."""
+        cursor = self.conn.cursor()
+        
+        # Main state table
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS state (
+                key TEXT PRIMARY KEY,
+                value TEXT,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        ''')
+        
+        self.conn.commit()
+        logger.debug("Database schema initialized")
+    
+    def set(self, key: str, value: Any) -> None:
+        """Set a state value.
+        
+        Args:
+            key: State key.
+            value: Value to store (will be JSON serialized).
+        """
+        with self._lock:
+            cursor = self.conn.cursor()
+            cursor.execute('''
+                INSERT OR REPLACE INTO state (key, value, updated_at)
+                VALUES (?, ?, CURRENT_TIMESTAMP)
+            ''', (key, json.dumps(value)))
+            self.conn.commit()
+            logger.debug(f"Set state: {key}")
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a state value.
+        
+        Args:
+            key: State key.
+            default: Default value if key not found.
+            
+        Returns:
+            The stored value or default.
+        """
+        with self._lock:
+            cursor = self.conn.cursor()
+            cursor.execute('SELECT value FROM state WHERE key = ?', (key,))
+            row = cursor.fetchone()
+            if row:
+                return json.loads(row[0])
+            return default
+    
+    def close(self) -> None:
+        """Close the database connection."""
+        if self.conn:
+            self.conn.close()
+            logger.info("Database connection closed")

core/ui/__init__.py

@@ -0,0 +1,6 @@
+"""Modal UI system for Kollabor CLI."""
+
+from .modal_renderer import ModalRenderer
+from .live_modal_renderer import LiveModalRenderer, LiveModalConfig
+
+__all__ = ["ModalRenderer", "LiveModalRenderer", "LiveModalConfig"]

core/ui/config_merger.py

@@ -0,0 +1,176 @@
+"""Config persistence system for modal UI changes."""
+
+import logging
+from typing import Dict, Any, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigMerger:
+    """Handles saving widget changes to config.json using existing config system."""
+
+    @staticmethod
+    def apply_widget_changes(config_service, widget_changes: Dict[str, Any]) -> bool:
+        """Apply widget changes to config.json using existing config system.
+
+        Args:
+            config_service: ConfigService instance for managing configuration.
+            widget_changes: Dictionary mapping config paths to new values.
+
+        Returns:
+            True if all changes applied successfully, False otherwise.
+        """
+        try:
+            logger.info(f"Applying {len(widget_changes)} widget changes to config")
+
+            # Create backup before making changes
+            backup_path = config_service.backup_config(".pre-modal-changes")
+            if backup_path:
+                logger.debug(f"Config backup created: {backup_path}")
+
+            # Apply all changes atomically
+            success_count = 0
+            failed_changes = []
+
+            for path, value in widget_changes.items():
+                try:
+                    # Use existing config system
+                    if config_service.set(path, value):
+                        success_count += 1
+                        logger.debug(f"Successfully set {path} = {value}")
+                    else:
+                        failed_changes.append((path, value, "set_failed"))
+                        logger.error(f"Failed to set config: {path} = {value}")
+                except Exception as e:
+                    failed_changes.append((path, value, str(e)))
+                    logger.error(f"Error setting {path}: {e}")
+
+            # Report results
+            if failed_changes:
+                logger.error(f"Failed to apply {len(failed_changes)} changes: {failed_changes}")
+                return False
+
+            logger.info(f"Successfully applied all {success_count} config changes")
+
+            # Notify plugins using existing event system
+            ConfigMerger.notify_plugins_config_changed(config_service, list(widget_changes.keys()))
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Critical error applying widget changes: {e}")
+            return False
+
+    @staticmethod
+    def notify_plugins_config_changed(config_service, changed_paths: List[str]) -> None:
+        """Notify plugins their config changed using existing event system.
+
+        Args:
+            config_service: ConfigService instance.
+            changed_paths: List of config paths that changed.
+        """
+        try:
+            # Trigger the existing config reload callbacks
+            config_service._notify_reload_callbacks()
+            logger.debug(f"Notified plugins of config changes: {changed_paths}")
+        except Exception as e:
+            logger.error(f"Error notifying plugins of config changes: {e}")
+
+    @staticmethod
+    def collect_widget_changes(widgets: List[Any]) -> Dict[str, Any]:
+        """Collect all widget value changes.
+
+        Args:
+            widgets: List of widgets to collect changes from.
+
+        Returns:
+            Dictionary mapping config paths to new values.
+        """
+        changes = {}
+
+        for widget in widgets:
+            # Check if widget has a pending value that differs from current
+            if hasattr(widget, '_pending_value') and hasattr(widget, 'config_path'):
+                # Use get_value() method instead of current_value attribute
+                current_value = widget.get_value() if hasattr(widget, 'get_value') else None
+                pending_value = widget._pending_value
+
+                # Only include changes where value actually changed
+                # Note: pending_value being None means no change was made
+                if pending_value is not None and pending_value != current_value:
+                    changes[widget.config_path] = pending_value
+                    logger.debug(f"Collected change: {widget.config_path} = {pending_value} (was {current_value})")
+
+        logger.info(f"Collected {len(changes)} widget changes")
+        return changes
+
+    @staticmethod
+    def validate_config_changes(config_service, changes: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate config changes before applying them.
+
+        Args:
+            config_service: ConfigService instance.
+            changes: Dictionary of proposed changes.
+
+        Returns:
+            Validation result with 'valid' boolean and 'errors' list.
+        """
+        validation_result = {
+            "valid": True,
+            "errors": [],
+            "warnings": []
+        }
+
+        try:
+            # Create a temporary config to test validation
+            original_config = config_service.config_manager.config.copy()
+
+            # Apply changes temporarily
+            for path, value in changes.items():
+                try:
+                    from ..utils import safe_set
+                    safe_set(config_service.config_manager.config, path, value)
+                except Exception as e:
+                    validation_result["errors"].append(f"Invalid path {path}: {e}")
+                    validation_result["valid"] = False
+
+            # Use existing validation
+            if validation_result["valid"]:
+                system_validation = config_service.validate_config()
+                if not system_validation["valid"]:
+                    validation_result["valid"] = False
+                    validation_result["errors"].extend(system_validation["errors"])
+                validation_result["warnings"].extend(system_validation.get("warnings", []))
+
+            # Restore original config
+            config_service.config_manager.config = original_config
+
+        except Exception as e:
+            validation_result["valid"] = False
+            validation_result["errors"].append(f"Validation error: {e}")
+
+        return validation_result
+
+    @staticmethod
+    def get_config_values(config_service, config_paths: List[str]) -> Dict[str, Any]:
+        """Get current values for config paths.
+
+        Args:
+            config_service: ConfigService instance.
+            config_paths: List of config paths to retrieve.
+
+        Returns:
+            Dictionary mapping paths to their current values.
+        """
+        values = {}
+
+        for path in config_paths:
+            try:
+                value = config_service.get(path)
+                values[path] = value
+                logger.debug(f"Retrieved config value: {path} = {value}")
+            except Exception as e:
+                logger.error(f"Error retrieving config {path}: {e}")
+                values[path] = None
+
+        return values