kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

core/models/resume.py

@@ -0,0 +1,54 @@
+"""Data models for resume functionality."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class SessionMetadata:
+    """Metadata for a conversation session."""
+    session_id: str
+    start_time: Optional[datetime]
+    end_time: Optional[datetime]
+    message_count: int
+    turn_count: int
+    working_directory: str
+    git_branch: str
+    themes: List[str]
+    files_mentioned: List[str]
+    last_activity: Optional[datetime]
+    size_bytes: int
+    is_valid: bool
+    validation_issues: List[str]
+
+
+@dataclass
+class SessionSummary:
+    """Summary of a conversation session."""
+    metadata: SessionMetadata
+    preview_messages: List[Dict]
+    key_topics: List[str]
+    user_patterns: List[str]
+    project_context: Dict[str, Any]
+    compatibility_score: float
+
+
+@dataclass
+class ConversationMetadata:
+    """Metadata for conversation discovery."""
+    file_path: str
+    session_id: str
+    title: str
+    message_count: int
+    created_time: Optional[datetime]
+    modified_time: Optional[datetime]
+    last_message_preview: str
+    topics: List[str]
+    file_id: str  # Short ID for display (#12345)
+    working_directory: str
+    git_branch: str
+    duration: Optional[str]
+    size_bytes: int
+    preview_messages: List[Dict]
+    search_relevance: Optional[float] = None

core/plugins/__init__.py

@@ -4,10 +4,12 @@ from .registry import PluginRegistry
 from .discovery import PluginDiscovery
 from .factory import PluginFactory
 from .collector import PluginStatusCollector
+from .base import BasePlugin
 
 __all__ = [
     'PluginRegistry',
-    'PluginDiscovery', 
+    'PluginDiscovery',
     'PluginFactory',
-    'PluginStatusCollector'
+    'PluginStatusCollector',
+    'BasePlugin'
 ]

core/plugins/base.py

@@ -0,0 +1,127 @@
+"""Base plugin class for Kollabor CLI plugins.
+
+This module defines the BasePlugin class that all plugins can inherit from.
+It provides default implementations for plugin lifecycle methods including
+CLI argument registration.
+"""
+
+import argparse
+from typing import Any
+
+
+class BasePlugin:
+    """Base class for all Kollabor CLI plugins.
+
+    Plugins can inherit from this class to get default implementations
+    of common plugin methods. The class provides static methods for
+    CLI argument registration and early argument handling.
+    """
+
+    @staticmethod
+    def register_cli_args(parser: argparse.ArgumentParser) -> None:
+        """Register custom CLI arguments.
+
+        Called during early plugin discovery, before app initialization.
+        Use parser.add_argument_group() to organize args by plugin.
+
+        Args:
+            parser: The ArgumentParser instance to add arguments to.
+
+        Example:
+            @staticmethod
+            def register_cli_args(parser):
+                group = parser.add_argument_group("My Plugin")
+                group.add_argument("--my-arg", type=str,
+                                  help="My custom argument")
+        """
+        pass
+
+    @staticmethod
+    def handle_early_args(args: argparse.Namespace) -> bool:
+        """Handle args that should exit before app starts.
+
+        Called after argument parsing but before app initialization.
+        Return True to exit immediately (e.g., --capture mode).
+        Return False to continue normal startup.
+
+        Args:
+            args: The parsed CLI arguments namespace.
+
+        Returns:
+            True to exit immediately, False to continue normal startup.
+
+        Example:
+            @staticmethod
+            def handle_early_args(args):
+                if hasattr(args, 'my_flag') and args.my_flag:
+                    print("Early exit triggered")
+                    return True
+                return False
+        """
+        return False
+
+    def initialize(self, args: argparse.Namespace = None, **kwargs) -> None:
+        """Initialize the plugin.
+
+        Called during app startup. The args parameter contains
+        parsed CLI arguments including any plugin-registered args.
+
+        Args:
+            args: Parsed CLI arguments (optional, None if not available).
+            **kwargs: Additional initialization parameters including:
+                - event_bus: Event bus for hook registration
+                - config: Configuration manager
+                - command_registry: Command registry for slash commands
+                - input_handler: Input handler instance
+                - renderer: Terminal renderer
+                - llm_service: LLM service instance
+                - conversation_logger: Conversation logger instance
+                - conversation_manager: Conversation manager instance
+        """
+        pass
+
+    def register_hooks(self) -> None:
+        """Register plugin hooks with the event bus.
+
+        Called during plugin initialization after initialize().
+        Override this method to register event hooks.
+        """
+        pass
+
+    def shutdown(self) -> None:
+        """Shutdown the plugin.
+
+        Called during app shutdown. Override this method to
+        perform cleanup tasks.
+        """
+        pass
+
+    @staticmethod
+    def get_default_config() -> dict[str, Any]:
+        """Get default configuration for this plugin.
+
+        Returns:
+            Dictionary with default configuration values.
+        """
+        return {}
+
+    @staticmethod
+    def get_startup_info(config) -> list[str]:
+        """Get startup information for this plugin.
+
+        Args:
+            config: Configuration manager instance.
+
+        Returns:
+            List of strings to display during startup.
+        """
+        return []
+
+    @staticmethod
+    def get_config_widgets() -> dict[str, Any]:
+        """Get configuration widgets for this plugin.
+
+        Returns:
+            Widget section definition for the config modal.
+        """
+        return {}

core/plugins/collector.py

@@ -1,212 +1,74 @@
-"""Plugin status collector for aggregating status information from plugins."""
+"""Plugin collector for gathering plugin information."""
 
 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.
+    """Collects plugin information like startup info.
+
+    Note: Status line collection has been removed in favor of
+    content provider-based status views.
     """
-    
+
     def __init__(self):
-        """Initialize the plugin status collector."""
-        self.last_status_collection: Dict[str, Dict[str, List[str]]] = {}
-        self.collection_errors: Dict[str, str] = {}
+        """Initialize the plugin collector."""
         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.
-        
+        """Get statistics about the collector.
+
         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()
-        }
+            "type": "startup_info_collector",
+            "description": "Collects plugin startup information"
+        }

core/plugins/discovery.py

@@ -275,18 +275,52 @@ class PluginDiscovery:
     
     def discover_and_load(self) -> Dict[str, Type]:
         """Perform complete discovery and loading process.
-        
+
         Returns:
             Dictionary mapping plugin names to their classes.
         """
         # Scan for plugin files
         self.scan_plugin_files()
-        
+
         # Load all discovered modules
         self.load_all_modules()
-        
+
         logger.info(f"Discovery complete: {len(self.loaded_classes)} plugins loaded")
         return self.loaded_classes
+
+    def discover_classes_only(self) -> List[Type]:
+        """Lightweight discovery that only loads plugin classes.
+
+        Does NOT instantiate plugins. Used for CLI arg registration
+        before app initialization. This allows plugins to register
+        custom CLI arguments without full plugin initialization.
+
+        Returns:
+            List of plugin class types.
+
+        Note:
+            This is a minimal discovery that loads modules and extracts
+            plugin classes but does not perform full instantiation or
+            configuration merging.
+        """
+        # Scan for plugin files
+        self.scan_plugin_files()
+
+        plugin_classes = []
+
+        for module_name in self.discovered_modules:
+            try:
+                # Load each module and extract plugin classes
+                if self.load_module(module_name):
+                    # Get all loaded plugin classes from this module
+                    for class_name, class_obj in self.loaded_classes.items():
+                        if class_obj not in plugin_classes:
+                            plugin_classes.append(class_obj)
+            except Exception as e:
+                logger.warning(f"Failed to load plugin {module_name} for CLI arg discovery: {e}")
+
+        logger.info(f"CLI arg discovery: {len(plugin_classes)} plugin classes found")
+        return plugin_classes
     
     def get_plugin_class(self, plugin_name: str) -> Type:
         """Get a loaded plugin class by name.

core/plugins/factory.py

@@ -26,21 +26,19 @@ class PluginFactory:
         self,
         plugin_class: Type,
         plugin_name: str,
-        state_manager: Any,
         event_bus: Any,
         renderer: Any,
         config: Any
     ) -> Any:
         """Instantiate a single plugin with dependencies.
-        
+
         Args:
             plugin_class: The plugin class to instantiate.
             plugin_name: Name of the plugin.
-            state_manager: State management system.
             event_bus: Event bus for hook registration.
             renderer: Terminal renderer.
             config: Configuration manager.
-            
+
         Returns:
             Plugin instance if successful, None otherwise.
         """
@@ -48,7 +46,7 @@ class PluginFactory:
         if not has_method(plugin_class, '__init__'):
             logger.debug(f"Plugin {plugin_name} is not instantiable (no __init__ method)")
             return None
-        
+
         # Try to instantiate the plugin
         # Clean plugin name: remove 'Plugin' suffix if present and use as name
         clean_name = plugin_name
@@ -58,7 +56,6 @@ class PluginFactory:
         instance = instantiate_plugin_safely(
             plugin_class,
             name=clean_name,
-            state_manager=state_manager,
             event_bus=event_bus,
             renderer=renderer,
             config=config
@@ -78,30 +75,27 @@ class PluginFactory:
     def instantiate_all(
         self,
         plugin_classes: Dict[str, Type],
-        state_manager: Any,
         event_bus: Any,
         renderer: Any,
         config: Any
     ) -> Dict[str, Any]:
         """Instantiate all provided plugin classes.
-        
+
         Args:
             plugin_classes: Dictionary mapping plugin names to classes.
-            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.
         """
         error_accumulator = ErrorAccumulator(logger)
-        
+
         for plugin_name, plugin_class in plugin_classes.items():
             instance = self.instantiate_plugin(
                 plugin_class,
                 plugin_name,
-                state_manager,
                 event_bus,
                 renderer,
                 config

core/plugins/registry.py

@@ -110,34 +110,22 @@ class PluginRegistry:
         """
         return list(self.discovery.loaded_classes.keys())
     
-    def instantiate_plugins(self, state_manager, event_bus, renderer, config) -> Dict[str, Any]:
+    def instantiate_plugins(self, 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
+            plugin_classes, 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.