kollabor 0.4.9__py3-none-any.whl

core/logging/setup.py

@@ -0,0 +1,208 @@
+"""Centralized logging configuration and setup.
+
+This module handles all logging configuration for the application,
+reading from the config system when available and providing sensible
+defaults during bootstrap.
+"""
+
+import logging
+import logging.handlers
+import threading
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+class CompactFormatter(logging.Formatter):
+    """Custom formatter that compacts level names and includes file location."""
+
+    def format(self, record):
+        # Map long level names to 4-char versions
+        level_mapping = {
+            'WARNING': 'WARN',
+            'CRITICAL': 'CRIT',
+            'DEBUG': 'DEBG'
+        }
+        record.levelname = level_mapping.get(record.levelname, record.levelname)
+        return super().format(record)
+
+
+class LoggingSetup:
+    """Centralized logging configuration manager."""
+
+    def __init__(self):
+        self._configured = False
+        self._current_config = {}
+
+    def setup_bootstrap_logging(self, log_dir: Optional[Path] = None):
+        """Setup minimal logging before config system is available.
+
+        Args:
+            log_dir: Optional log directory, defaults to .kollabor-cli/logs
+        """
+        if log_dir is None:
+            from ..utils.config_utils import get_config_directory
+            config_dir = get_config_directory()
+            log_dir = config_dir / "logs"
+
+        # Ensure log directory exists
+        log_dir.mkdir(parents=True, exist_ok=True)
+
+        # Setup with hardcoded defaults that match current behavior
+        log_file = log_dir / "kollabor.log"
+
+        handler = logging.handlers.TimedRotatingFileHandler(
+            filename=str(log_file),
+            when='D',  # Daily rotation
+            interval=1,
+            backupCount=1,
+            encoding='utf-8'
+        )
+
+        # Add thread safety
+        handler.lock = threading.RLock()
+
+        # Use compact formatter
+        formatter = CompactFormatter(
+            "%(asctime)s - %(levelname)-4s - %(message)-100s - %(filename)s:%(lineno)04d"
+        )
+        handler.setFormatter(formatter)
+
+        # Configure logging
+        logging.basicConfig(
+            level=logging.INFO,
+            handlers=[
+                handler,
+                logging.NullHandler()  # Suppress console output
+            ]
+        )
+
+        self._configured = True
+        self._current_config = {
+            'level': 'INFO',
+            'file': str(log_file),
+            'format': 'compact'
+        }
+
+        # Apply formatter to all existing handlers
+        self._apply_formatter_to_all_loggers(formatter)
+
+    def setup_from_config(self, config: Dict[str, Any]):
+        """Setup logging from configuration system.
+
+        Args:
+            config: Configuration dictionary with logging settings
+        """
+        logging_config = config.get('logging', {})
+
+        # Extract configuration values
+        level = logging_config.get('level', 'INFO').upper()
+        log_file = logging_config.get('file', '.kollabor-cli/logs/kollabor.log')
+        format_type = logging_config.get('format_type', 'compact')
+        custom_format = logging_config.get('format', None)
+
+        # Convert string level to logging constant
+        numeric_level = getattr(logging, level, logging.INFO)
+
+        # Ensure log directory exists
+        log_path = Path(log_file)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Create new handler
+        handler = logging.handlers.TimedRotatingFileHandler(
+            filename=str(log_path),
+            when='D',
+            interval=1,
+            backupCount=1,
+            encoding='utf-8'
+        )
+
+        # Add thread safety
+        handler.lock = threading.RLock()
+
+        # Choose formatter based on config
+        if format_type == 'compact':
+            formatter = CompactFormatter(
+                "%(asctime)s - %(levelname)-4s - %(message)-100s - %(filename)s:%(lineno)04d"
+            )
+        elif custom_format:
+            formatter = logging.Formatter(custom_format)
+        else:
+            # Standard format
+            formatter = logging.Formatter(
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            )
+
+        handler.setFormatter(formatter)
+
+        # Clear existing handlers and setup new one
+        root_logger = logging.getLogger()
+        for old_handler in root_logger.handlers[:]:
+            root_logger.removeHandler(old_handler)
+
+        logging.basicConfig(
+            level=numeric_level,
+            handlers=[
+                handler,
+                logging.NullHandler()
+            ],
+            force=True  # Force reconfiguration
+        )
+
+        self._configured = True
+        self._current_config = {
+            'level': level,
+            'file': str(log_path),
+            'format': format_type,
+            'custom_format': custom_format
+        }
+
+        # Apply formatter to all existing loggers
+        self._apply_formatter_to_all_loggers(formatter)
+
+        logging.getLogger(__name__).info(
+            f"Logging reconfigured - Level: {level}, File: {log_file}, Format: {format_type}"
+        )
+
+    def _apply_formatter_to_all_loggers(self, formatter):
+        """Apply formatter to all existing loggers and handlers."""
+        # Apply to root logger handlers
+        for root_handler in logging.getLogger().handlers:
+            root_handler.setFormatter(formatter)
+
+        # Apply to all existing logger handlers
+        for logger_name in logging.Logger.manager.loggerDict:
+            existing_logger = logging.getLogger(logger_name)
+            for existing_handler in existing_logger.handlers:
+                existing_handler.setFormatter(formatter)
+
+    def get_current_config(self) -> Dict[str, Any]:
+        """Get current logging configuration."""
+        return self._current_config.copy()
+
+    def is_configured(self) -> bool:
+        """Check if logging has been configured."""
+        return self._configured
+
+
+# Global instance
+logging_setup = LoggingSetup()
+
+
+def setup_bootstrap_logging(log_dir: Optional[Path] = None):
+    """Setup bootstrap logging before config system is available."""
+    logging_setup.setup_bootstrap_logging(log_dir)
+
+
+def setup_from_config(config: Dict[str, Any]):
+    """Setup logging from configuration system."""
+    logging_setup.setup_from_config(config)
+
+
+def get_current_config() -> Dict[str, Any]:
+    """Get current logging configuration."""
+    return logging_setup.get_current_config()
+
+
+def is_configured() -> bool:
+    """Check if logging has been configured."""
+    return logging_setup.is_configured()

core/models/__init__.py

@@ -0,0 +1,5 @@
+"""Shared models for Kollabor CLI."""
+
+from .base import ConversationMessage
+
+__all__ = ['ConversationMessage']

core/models/base.py

@@ -0,0 +1,23 @@
+"""Shared data models for Kollabor CLI."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConversationMessage:
+    """A single message in the conversation.
+    
+    Attributes:
+        role: Role of the message sender (user, assistant, system, tool).
+        content: The message content.
+        timestamp: When the message was created.
+        metadata: Additional metadata.
+        thinking: Optional thinking process information.
+    """
+    role: str
+    content: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    thinking: Optional[str] = None

core/plugins/__init__.py

@@ -0,0 +1,13 @@
+"""Plugin subsystem for Kollabor CLI."""
+
+from .registry import PluginRegistry
+from .discovery import PluginDiscovery
+from .factory import PluginFactory
+from .collector import PluginStatusCollector
+
+__all__ = [
+    'PluginRegistry',
+    'PluginDiscovery', 
+    'PluginFactory',
+    'PluginStatusCollector'
+]

core/plugins/collector.py

@@ -0,0 +1,212 @@
+"""Plugin status collector for aggregating status information from plugins."""
+
+import logging
+from typing import Any, Dict, List
+
+from ..utils.plugin_utils import collect_plugin_status_safely
+from ..utils.error_utils import safe_execute
+
+logger = logging.getLogger(__name__)
+
+
+class PluginStatusCollector:
+    """Collects and aggregates status information from plugin instances.
+    
+    This class is responsible for gathering status lines from all plugins,
+    organizing them by display areas, and providing aggregated status data.
+    """
+    
+    def __init__(self):
+        """Initialize the plugin status collector."""
+        self.last_status_collection: Dict[str, Dict[str, List[str]]] = {}
+        self.collection_errors: Dict[str, str] = {}
+        logger.info("PluginStatusCollector initialized")
+    
+    def collect_plugin_status(self, plugin_name: str, plugin_instance: Any) -> Dict[str, List[str]]:
+        """Collect status information from a single plugin.
+        
+        Args:
+            plugin_name: Name of the plugin.
+            plugin_instance: The plugin instance to collect status from.
+            
+        Returns:
+            Dictionary with areas A, B, C containing lists of status lines.
+        """
+        plugin_status = collect_plugin_status_safely(plugin_instance, plugin_name)
+        
+        # Store the status for this plugin
+        self.last_status_collection[plugin_name] = plugin_status
+        
+        # Clear any previous collection errors for this plugin
+        if plugin_name in self.collection_errors:
+            del self.collection_errors[plugin_name]
+        
+        return plugin_status
+    
+    def collect_all_status(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 aggregated status lines.
+        """
+        status_areas = {"A": [], "B": [], "C": []}
+        
+        for plugin_name, plugin_instance in plugin_instances.items():
+            plugin_status = self.collect_plugin_status(plugin_name, plugin_instance)
+            
+            # Merge the status from this plugin into our aggregated status
+            for area in ["A", "B", "C"]:
+                if area in plugin_status:
+                    status_areas[area].extend(plugin_status[area])
+        
+        #logger.debug(f"Collected status from {len(plugin_instances)} plugins")
+        return status_areas
+    
+    def get_plugin_startup_info(self, plugin_name: str, plugin_class: type, config: Any) -> List[str]:
+        """Get startup information for a specific plugin.
+        
+        Args:
+            plugin_name: Name of the plugin.
+            plugin_class: The plugin class.
+            config: Configuration manager instance.
+            
+        Returns:
+            List of startup info strings, or empty list if no info available.
+        """
+        def get_startup_info():
+            return plugin_class.get_startup_info(config)
+        
+        result = safe_execute(
+            get_startup_info,
+            f"getting startup info from plugin {plugin_name}",
+            default=[],
+            logger_instance=logger
+        )
+        
+        return result if isinstance(result, list) else []
+    
+    def collect_all_startup_info(self, plugin_classes: Dict[str, type], config: Any) -> Dict[str, List[str]]:
+        """Collect startup information from all plugin classes.
+        
+        Args:
+            plugin_classes: Dictionary mapping plugin names to classes.
+            config: Configuration manager instance.
+            
+        Returns:
+            Dictionary mapping plugin names to their startup info lists.
+        """
+        startup_info = {}
+        
+        for plugin_name, plugin_class in plugin_classes.items():
+            info_list = self.get_plugin_startup_info(plugin_name, plugin_class, config)
+            if info_list:
+                startup_info[plugin_name] = info_list
+        
+        logger.debug(f"Collected startup info from {len(startup_info)} plugins")
+        return startup_info
+    
+    def get_status_summary(self) -> Dict[str, Any]:
+        """Get a summary of the last status collection.
+        
+        Returns:
+            Dictionary with status collection summary.
+        """
+        total_lines = 0
+        areas_summary = {"A": 0, "B": 0, "C": 0}
+        
+        for plugin_name, status in self.last_status_collection.items():
+            for area in ["A", "B", "C"]:
+                if area in status:
+                    line_count = len(status[area])
+                    areas_summary[area] += line_count
+                    total_lines += line_count
+        
+        return {
+            "total_plugins": len(self.last_status_collection),
+            "total_status_lines": total_lines,
+            "lines_per_area": areas_summary,
+            "collection_errors": len(self.collection_errors),
+            "plugins_with_status": [
+                name for name, status in self.last_status_collection.items() 
+                if any(status.get(area) for area in ["A", "B", "C"])
+            ]
+        }
+    
+    def get_plugin_status_details(self, plugin_name: str) -> Dict[str, Any]:
+        """Get detailed status information for a specific plugin.
+        
+        Args:
+            plugin_name: Name of the plugin.
+            
+        Returns:
+            Dictionary with detailed status information for the plugin.
+        """
+        if plugin_name not in self.last_status_collection:
+            return {
+                "plugin_name": plugin_name,
+                "status_collected": False,
+                "error": "No status collection found"
+            }
+        
+        status = self.last_status_collection[plugin_name]
+        
+        return {
+            "plugin_name": plugin_name,
+            "status_collected": True,
+            "areas": {
+                area: {
+                    "line_count": len(lines),
+                    "lines": lines
+                }
+                for area, lines in status.items()
+            },
+            "has_error": plugin_name in self.collection_errors,
+            "error": self.collection_errors.get(plugin_name)
+        }
+    
+    def clear_status_history(self) -> None:
+        """Clear all stored status collection history."""
+        self.last_status_collection.clear()
+        self.collection_errors.clear()
+        logger.debug("Cleared status collection history")
+    
+    def get_status_by_area(self, area: str) -> List[str]:
+        """Get all status lines for a specific area across all plugins.
+        
+        Args:
+            area: The area to get status for ("A", "B", or "C").
+            
+        Returns:
+            List of status lines for the specified area.
+        """
+        if area not in ["A", "B", "C"]:
+            logger.warning(f"Invalid status area: {area}")
+            return []
+        
+        lines = []
+        for plugin_name, status in self.last_status_collection.items():
+            if area in status:
+                lines.extend(status[area])
+        
+        return lines
+    
+    def get_collector_stats(self) -> Dict[str, Any]:
+        """Get statistics about the collector's operations.
+        
+        Returns:
+            Dictionary with collector statistics.
+        """
+        total_collections = len(self.last_status_collection)
+        successful_collections = total_collections - len(self.collection_errors)
+        
+        return {
+            "total_collections": total_collections,
+            "successful_collections": successful_collections,
+            "collection_errors": len(self.collection_errors),
+            "plugins_tracked": list(self.last_status_collection.keys()),
+            "error_plugins": list(self.collection_errors.keys()),
+            "status_summary": self.get_status_summary()
+        }