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

core/__init__.py

@@ -5,7 +5,6 @@ from .config import ConfigManager
 from .events import EventBus, Event, EventType, Hook, HookStatus, HookPriority
 from .io import InputHandler, TerminalRenderer
 from .plugins import PluginRegistry
-from .storage import StateManager
 from .models import ConversationMessage
 
 __all__ = [
@@ -13,6 +12,5 @@ __all__ = [
     'EventBus', 'Event', 'EventType', 'Hook', 'HookStatus', 'HookPriority',
     'InputHandler', 'TerminalRenderer',
     'PluginRegistry',
-    'StateManager',
     'ConversationMessage'
 ]

core/application.py

@@ -9,37 +9,107 @@ from importlib.metadata import version as get_version, PackageNotFoundError
 
 from .config import ConfigService
 
-# Get version from package metadata (always authoritative)
-try:
-    __version__ = get_version("kollabor")
-except PackageNotFoundError:
-    __version__ = "0.4.7"  # Fallback for development mode
+def _get_version_from_pyproject() -> str:
+    """Read version from pyproject.toml for development mode."""
+    try:
+        pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
+        if pyproject_path.exists():
+            content = pyproject_path.read_text()
+            for line in content.splitlines():
+                if line.startswith("version ="):
+                    # Extract version from: version = "0.4.10"
+                    return line.split("=")[1].strip().strip('"').strip("'")
+    except Exception:
+        pass
+    return None  # Return None if not found
+
+def _is_running_from_source() -> bool:
+    """Check if we're running from source (development mode) vs installed package."""
+    try:
+        # If pyproject.toml exists in parent directory, we're running from source
+        pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
+        return pyproject_path.exists()
+    except Exception:
+        return False
+
+# Get version: prefer pyproject.toml when running from source, otherwise use installed version
+if _is_running_from_source():
+    # Development mode: use pyproject.toml
+    __version__ = _get_version_from_pyproject() or "0.0.0"
+else:
+    # Production mode: use installed package version
+    try:
+        __version__ = get_version("kollabor")
+    except PackageNotFoundError:
+        __version__ = "0.0.0"
 from .events import EventBus
 from .io import InputHandler, TerminalRenderer
 from .io.visual_effects import VisualEffects
-from .llm import LLMService, KollaborConversationLogger, LLMHookSystem, MCPIntegration, KollaborPluginSDK
+from .llm import LLMService, KollaborConversationLogger, MCPIntegration, KollaborPluginSDK
+from .llm.profile_manager import ProfileManager
+from .llm.agent_manager import AgentManager
 from .logging import setup_from_config
 from .plugins import PluginRegistry
-from .storage import StateManager
+from .updates import VersionCheckService
 
 logger = logging.getLogger(__name__)
 
 
 class TerminalLLMChat:
     """Main Kollabor CLI application.
-    
+
     Orchestrates all components including rendering, input handling,
     event processing, and plugin management.
     """
-    
-    def __init__(self) -> None:
-        """Initialize the chat application."""
+
+    def __init__(
+        self,
+        args=None,
+        system_prompt_file: str | None = None,
+        agent_name: str | None = None,
+        profile_name: str | None = None,
+        save_profile: bool = False,
+        skill_names: list[str] | None = None,
+    ) -> None:
+        """Initialize the chat application.
+
+        Args:
+            args: Parsed CLI arguments namespace (includes plugin args).
+            system_prompt_file: Optional path to a custom system prompt file
+                               (overrides all other system prompt sources)
+            agent_name: Optional agent name to use (e.g., "lint-editor")
+            profile_name: Optional LLM profile name to use (e.g., "claude")
+            save_profile: If True, save auto-created profile to global config
+            skill_names: Optional list of skill names to load for the agent
+        """
+        # Store CLI args for plugins to access
+        self.args = args
+
         # Get configuration directory using standard resolution
-        from .utils.config_utils import get_config_directory, ensure_config_directory, initialize_system_prompt
+        from .utils.config_utils import (
+            get_config_directory,
+            ensure_config_directory,
+            initialize_system_prompt,
+            initialize_config,
+            set_cli_system_prompt_file,
+            get_project_data_dir,
+            get_conversations_dir,
+        )
+
+        # Set CLI system prompt override if provided
+        if system_prompt_file:
+            set_cli_system_prompt_file(system_prompt_file)
+
+        # Check if this is first install BEFORE creating directories
+        global_config_path = Path.home() / ".kollabor-cli" / "config.json"
+        self._is_first_install = not global_config_path.exists()
 
         self.config_dir = ensure_config_directory()
         logger.info(f"Using config directory: {self.config_dir}")
 
+        # Initialize config.json (creates global with profiles, copies to local)
+        initialize_config()
+
         # Initialize system prompt (copies default.md to config directories)
         initialize_system_prompt()
 
@@ -65,12 +135,55 @@ class TerminalLLMChat:
         # Update config file with plugin configurations
         self.config.update_from_plugins()
 
+        # Initialize profile manager (for LLM endpoint profiles)
+        self.profile_manager = ProfileManager(self.config)
+        if profile_name:
+            # CLI --profile is a one-time override, don't persist active selection
+            if not self.profile_manager.set_active_profile(profile_name, persist=False):
+                logger.warning(f"Profile '{profile_name}' not found, using default")
+            elif save_profile:
+                # Save auto-created profile to global config if --save was used
+                profile = self.profile_manager.get_profile(profile_name)
+                if profile and profile.description == "Auto-created from environment variables":
+                    self.profile_manager.save_profile_values_to_config(profile)
+                    logger.info(f"Saved profile '{profile_name}' to global config")
+
+        # Initialize agent manager (for agent/skill system)
+        self.agent_manager = AgentManager(self.config)
+        # Load default agent using priority system (CLI > project > global > fallback)
+        if not self.agent_manager.load_default_agent(agent_name):
+            logger.warning("Failed to load any agent, system may not function correctly")
+
+        # If agent has a preferred profile, use it (unless profile was explicitly set)
+        # Don't persist agent's profile - it's automatic based on agent selection
+        if not profile_name:
+            agent_profile = self.agent_manager.get_preferred_profile()
+            if agent_profile:
+                if self.profile_manager.set_active_profile(agent_profile, persist=False):
+                    logger.info(f"Using agent's preferred profile: {agent_profile}")
+
+        # Load skills if specified (requires an active agent)
+        if skill_names:
+            if self.agent_manager.get_active_agent():
+                for skill_name in skill_names:
+                    if self.agent_manager.load_skill(skill_name):
+                        logger.info(f"Loaded skill: {skill_name}")
+                    else:
+                        logger.warning(f"Skill '{skill_name}' not found")
+            else:
+                logger.warning("Cannot load skills without an active agent")
+
         # Reconfigure logging now that config system is available
         setup_from_config(self.config.config_manager.config)
-        
+
+        # Initialize version check service
+        self.version_check_service = VersionCheckService(
+            config=self.config,
+            current_version=__version__
+        )
+
         # Initialize core components
-        self.state_manager = StateManager(str(self.config_dir / "state.db"))
-        self.event_bus = EventBus()
+        self.event_bus = EventBus(config=self.config.config_manager.config)
 
         # Initialize status view registry for flexible status display
         from .io.status_renderer import StatusViewRegistry
@@ -104,19 +217,33 @@ class TerminalLLMChat:
         logger.info("Slash command system initialization completed")
 
         # Initialize LLM core service components
-        conversations_dir = self.config_dir / "conversations"
+        self.project_data_dir = get_project_data_dir()
+        conversations_dir = get_conversations_dir()
         conversations_dir.mkdir(parents=True, exist_ok=True)
         self.conversation_logger = KollaborConversationLogger(conversations_dir)
-        self.llm_hook_system = LLMHookSystem(self.event_bus)
         self.mcp_integration = MCPIntegration()
         self.plugin_sdk = KollaborPluginSDK()
         self.llm_service = LLMService(
             config=self.config,
-            state_manager=self.state_manager,
             event_bus=self.event_bus,
-            renderer=self.renderer
+            renderer=self.renderer,
+            profile_manager=self.profile_manager,
+            agent_manager=self.agent_manager,
         )
-        
+
+        # Register hot reload callbacks for config changes
+        self.config.register_reload_callback(self._on_config_reload)
+
+        # Inject active skills as user messages (after LLM service is ready)
+        active_agent = self.agent_manager.get_active_agent()
+        if active_agent and active_agent.active_skills:
+            for skill_name in active_agent.active_skills:
+                skill = active_agent.get_skill(skill_name)
+                if skill:
+                    skill_message = f"## Skill: {skill_name}\n\n{skill.content}"
+                    self.llm_service._add_conversation_message("user", skill_message)
+                    logger.debug(f"Injected skill as user message: {skill_name}")
+
         # Configure renderer with thinking effect and shimmer parameters
         thinking_effect = self.config.get("terminal.thinking_effect", "shimmer")
         shimmer_speed = self.config.get("terminal.shimmer_speed", 3)
@@ -129,7 +256,7 @@ class TerminalLLMChat:
         
         # Dynamically instantiate all discovered plugins
         self.plugin_instances = self.plugin_registry.instantiate_plugins(
-            self.state_manager, self.event_bus, self.renderer, self.config
+            self.event_bus, self.renderer, self.config
         )
 
         # Task tracking for race condition prevention
@@ -143,7 +270,7 @@ class TerminalLLMChat:
     async def start(self) -> None:
         """Start the chat application with guaranteed cleanup."""
         # Display startup messages using config
-        self._display_startup_messages()
+        await self._display_startup_messages()
 
         logger.info("Application starting")
 
@@ -164,7 +291,7 @@ class TerminalLLMChat:
             self._startup_complete = True
             logger.info("Application startup complete")
 
-            # Start main loops with task tracking
+            # Start main loops with task tracking (needed for raw mode and input routing)
             self.running = True
             render_task = self.create_background_task(
                 self._render_loop(), "render_loop"
@@ -173,6 +300,12 @@ class TerminalLLMChat:
                 self.input_handler.start(), "input_handler"
             )
 
+            # Wait a moment for input handler to initialize (enter raw mode, register hooks)
+            await asyncio.sleep(0.1)
+
+            # Check for first-run and launch setup wizard if needed
+            await self._check_first_run_wizard()
+
             # Wait for completion
             await asyncio.gather(render_task, input_task)
 
@@ -253,12 +386,15 @@ class TerminalLLMChat:
             await self.cleanup()
             # DON'T reset pipe_mode here - let main.py's finally block check it to avoid double cleanup
 
-    def _display_startup_messages(self) -> None:
+    async def _display_startup_messages(self) -> None:
         """Display startup messages with plugin information."""
         # Display Kollabor banner with version from package metadata
         kollabor_banner = self.renderer.create_kollabor_banner(f"v{__version__}")
         print(kollabor_banner)
 
+        # Check for updates
+        await self._check_for_updates()
+
         # LLM Core status
         #print(f"\033[2;35mLLM Core: \033[2;32mActive\033[0m")
 
@@ -286,26 +422,53 @@ class TerminalLLMChat:
         print(gradient_msg + bold_enter + gradient_end)
         print()
 
-    
+    async def _check_for_updates(self) -> None:
+        """Check for updates and display notification if newer version available."""
+        try:
+            # Initialize version check service
+            await self.version_check_service.initialize()
+
+            # Check for updates (uses cache if valid)
+            release_info = await self.version_check_service.check_for_updates()
+
+            # Display notification if newer version available
+            if release_info:
+                update_msg = (
+                    f"\033[1;33mUpdate available:\033[0m "
+                    f"v{release_info.version} is now available "
+                    f"(current: v{__version__})"
+                )
+                download_msg = f"\033[2;36mDownload:\033[0m {release_info.url}"
+
+                print(update_msg)
+                print(download_msg)
+                print()  # Spacing before plugin list
+
+                logger.info(f"Update available: {release_info.version}")
+
+        except Exception as e:
+            # Graceful degradation - log but don't crash startup
+            logger.warning(f"Failed to check for updates: {e}")
+
+
     async def _initialize_llm_core(self) -> None:
         """Initialize LLM core service components."""
         # Initialize LLM service
         await self.llm_service.initialize()
         logger.info("LLM core service initialized")
-        
-        # Register LLM hooks
-        await self.llm_hook_system.register_hooks()
-        logger.info("LLM hook system registered")
-        
+
+        # Update system_commands with llm_service reference (it was None during init)
+        if hasattr(self, 'system_commands') and self.system_commands:
+            self.system_commands.llm_service = self.llm_service
+            logger.debug("Updated system_commands with llm_service reference")
+
         # Initialize conversation logger
         await self.conversation_logger.initialize()
         logger.info("Conversation logger initialized")
-        
-        # Discover MCP servers
-        mcp_servers = await self.mcp_integration.discover_mcp_servers()
-        if mcp_servers:
-            logger.info(f"Discovered {len(mcp_servers)} MCP servers")
-        
+
+        # Note: MCP server discovery is handled in background by llm_service.initialize()
+        # to avoid blocking startup (see llm_service._background_mcp_discovery)
+
         # Register LLM service hooks for user input processing
         await self.llm_service.register_hooks()
     
@@ -324,14 +487,18 @@ class TerminalLLMChat:
             initialized_instances.add(instance_id)
 
             if hasattr(plugin_instance, 'initialize'):
-                # Pass command registry, input handler, llm_service, and renderer to plugins that might need it
+                # Pass command registry, input handler, llm_service, renderer, and args to plugins
                 init_kwargs = {
+                    'args': self.args,  # Parsed CLI arguments including plugin args
                     'event_bus': self.event_bus,
                     'config': self.config,
                     'command_registry': getattr(self.input_handler, 'command_registry', None),
                     'input_handler': self.input_handler,
                     'renderer': self.renderer,
-                    'llm_service': self.llm_service
+                    'llm_service': self.llm_service,
+                    # Use llm_service's conversation_logger (the one actively logging)
+                    'conversation_logger': getattr(self.llm_service, 'conversation_logger', self.conversation_logger),
+                    'conversation_manager': getattr(self.llm_service, 'conversation_manager', None)
                 }
 
                 # Check if initialize method accepts keyword arguments
@@ -347,6 +514,21 @@ class TerminalLLMChat:
                 await plugin_instance.register_hooks()
                 logger.debug(f"Registered hooks for plugin: {plugin_name}")
 
+        # Register system commands hooks (for modal command handling)
+        if hasattr(self, 'system_commands') and self.system_commands:
+            await self.system_commands.register_hooks()
+            logger.debug("Registered hooks for system commands")
+
+        # Set plugin instances on LLM service for system prompt additions
+        if hasattr(self, 'llm_service') and self.llm_service:
+            self.llm_service.set_plugin_instances(self.plugin_instances)
+
+            # Check if any plugin wants to add to system prompt and rebuild if needed
+            additions = self.llm_service._get_plugin_system_prompt_additions()
+            if additions:
+                self.llm_service.rebuild_system_prompt()
+                logger.info(f"System prompt rebuilt with {len(additions)} plugin additions")
+
     def _initialize_slash_commands(self) -> None:
         """Initialize the slash command system with core commands."""
         logger.info("Starting slash command system initialization...")
@@ -355,15 +537,19 @@ class TerminalLLMChat:
             logger.info("SystemCommandsPlugin imported successfully")
 
             # Create and register system commands
-            system_commands = SystemCommandsPlugin(
+            # Note: llm_service is passed if available, but may be None at this point
+            self.system_commands = SystemCommandsPlugin(
                 command_registry=self.input_handler.command_registry,
                 event_bus=self.event_bus,
-                config_manager=self.config
+                config_manager=self.config,
+                llm_service=getattr(self, 'llm_service', None),
+                profile_manager=getattr(self, 'profile_manager', None),
+                agent_manager=getattr(self, 'agent_manager', None),
             )
             logger.info("SystemCommandsPlugin instance created")
 
             # Register all system commands
-            system_commands.register_commands()
+            self.system_commands.register_commands()
             logger.info("System commands registration completed")
 
             stats = self.input_handler.command_registry.get_registry_stats()
@@ -375,15 +561,80 @@ class TerminalLLMChat:
             import traceback
             logger.error(f"[INFO] Traceback: {traceback.format_exc()}")
 
+    async def _check_first_run_wizard(self) -> None:
+        """Check if this is first run and launch setup wizard if needed."""
+        try:
+            # Only show wizard on first install (when global config didn't exist before)
+            if not self._is_first_install:
+                logger.info("Not a first install, skipping wizard")
+                return
+
+            # Double-check the config flag in case wizard was already run
+            setup_completed = self.config.get("application.setup_completed", False)
+            if setup_completed:
+                logger.info("Setup already completed, skipping wizard")
+                return
+
+            # Check if we have the fullscreen integrator
+            if not hasattr(self, 'fullscreen_integrator') or not self.fullscreen_integrator:
+                logger.warning("Fullscreen integrator not available, skipping wizard")
+                return
+
+            # Check if setup plugin is registered
+            if "setup" not in self.fullscreen_integrator.registered_plugins:
+                logger.info("Setup wizard plugin not found, skipping")
+                return
+
+            logger.info("First run detected - launching setup wizard")
+
+            # Get the setup plugin instance and pass managers
+            plugin_class = self.fullscreen_integrator.registered_plugins["setup"]
+            plugin_instance = plugin_class()
+            plugin_instance.set_managers(self.config, self.profile_manager)
+
+            # Ensure fullscreen manager is initialized (it's lazily created in command handlers)
+            if not self.fullscreen_integrator._fullscreen_manager:
+                from core.fullscreen import FullScreenManager
+                self.fullscreen_integrator._fullscreen_manager = FullScreenManager(
+                    self.fullscreen_integrator.event_bus,
+                    self.fullscreen_integrator.terminal_renderer
+                )
+
+            # Register and launch
+            self.fullscreen_integrator._fullscreen_manager.register_plugin(plugin_instance)
+            await self.fullscreen_integrator._fullscreen_manager.launch_plugin("setup")
+
+            # Check wizard completion status and mark setup as completed
+            if plugin_instance.completed:
+                logger.info("Setup wizard completed successfully")
+            elif plugin_instance.skipped:
+                logger.info("Setup wizard skipped by user")
+            else:
+                logger.info("Setup wizard exited")
+
+            # Mark setup as completed to avoid showing wizard on next startup
+            self.config.set("application.setup_completed", True)
+
+        except Exception as e:
+            logger.error(f"Error launching setup wizard: {e}")
+            import traceback
+            logger.error(f"Setup wizard traceback: {traceback.format_exc()}")
+            # Don't fail startup if wizard fails
+            # Mark as completed so we don't retry
+            self.config.set("application.setup_completed", True)
+
     def _initialize_fullscreen_commands(self) -> None:
         """Initialize dynamic fullscreen plugin commands."""
         try:
             from core.fullscreen.command_integration import FullScreenCommandIntegrator
 
-            # Create the integrator
+            # Create the integrator with managers for plugins that need them
             self.fullscreen_integrator = FullScreenCommandIntegrator(
                 command_registry=self.input_handler.command_registry,
-                event_bus=self.event_bus
+                event_bus=self.event_bus,
+                config=self.config,
+                profile_manager=self.profile_manager,
+                terminal_renderer=self.renderer
             )
 
             # Discover and register all fullscreen plugins
@@ -406,50 +657,13 @@ class TerminalLLMChat:
         logger.info("Render loop starting...")
         while self.running:
             try:
-                # Update status areas dynamically from plugins
-                status_areas = {"A": [], "B": [], "C": []}
-                
-                # Core system status goes to area A
-                registry_stats = self.event_bus.get_registry_stats()
-                hook_count = registry_stats.get("total_hooks", 0)
-                status_areas["A"].append(f"Hooks: {hook_count}")
-                
-                # LLM Core status
-                llm_status = self.llm_service.get_status_line()
-                if llm_status:
-                    for area in ["A", "B", "C"]:
-                        if area in llm_status:
-                            status_areas[area].extend(llm_status[area])
-                
-                # Collect status from all plugins (organized by area)
-                plugin_status_areas = self.plugin_registry.collect_status_lines(self.plugin_instances)
-                
-                # Merge plugin status into our areas
-                for area in ["A", "B", "C"]:
-                    status_areas[area].extend(plugin_status_areas[area])
-                
-                # Handle spinner for processing status across all areas
-                for area in ["A", "B", "C"]:
-                    for i, line in enumerate(status_areas[area]):
-                        if line.startswith("Processing: Yes"):
-                            spinner = self.renderer.thinking_animation.get_next_frame()
-                            status_areas[area][i] = f"Processing: {spinner} Yes"
-                        elif line.startswith("Processing: ") and "tokens" in line:
-                            # Extract token count and add spinner
-                            spinner = self.renderer.thinking_animation.get_next_frame()
-                            token_part = line.replace("Processing: ", "")
-                            status_areas[area][i] = f"Processing: {spinner} {token_part}"
-                
-                # Update renderer with status areas
-                self.renderer.status_areas = status_areas
-
-                # Render active area
+                # Render active area (status views use content providers)
                 await self.renderer.render_active_area()
 
                 # Use configured FPS for render timing
                 render_fps = self.config.get("terminal.render_fps", 20)
                 await asyncio.sleep(1.0 / render_fps)
-                
+
             except Exception as e:
                 logger.error(f"Render loop error: {e}")
                 error_delay = self.config.get("terminal.render_error_delay", 0.1)
@@ -459,7 +673,12 @@ class TerminalLLMChat:
         """Register default core status views."""
         try:
             from .io.core_status_views import CoreStatusViews
-            core_views = CoreStatusViews(self.llm_service, self.config)
+            core_views = CoreStatusViews(
+                llm_service=self.llm_service,
+                config=self.config,
+                profile_manager=getattr(self, 'profile_manager', None),
+                agent_manager=getattr(self, 'agent_manager', None),
+            )
             core_views.register_all_views(self.status_registry)
         except Exception as e:
             logger.error(f"Failed to register core status views: {e}")
@@ -529,6 +748,36 @@ class TerminalLLMChat:
 
         logger.info("Application cleanup complete")
 
+    def _on_config_reload(self) -> None:
+        """Handle configuration reload (hot reload support).
+
+        Called when configuration changes via /config modal or file watcher.
+        Updates all services with new configuration values.
+        """
+        logger.info("Hot reloading application configuration...")
+
+        # Reload LLM service settings
+        if hasattr(self, 'llm_service'):
+            self.llm_service.reload_config()
+
+        # Reload logging level
+        from .logging import set_level
+        new_level = self.config.get("logging.level", "INFO")
+        set_level(new_level)
+
+        # Reload terminal renderer settings
+        if hasattr(self, 'renderer'):
+            thinking_effect = self.config.get("terminal.thinking_effect", "shimmer")
+            shimmer_speed = self.config.get("terminal.shimmer_speed", 3)
+            shimmer_wave_width = self.config.get("terminal.shimmer_wave_width", 4)
+            thinking_limit = self.config.get("terminal.thinking_message_limit", 2)
+
+            self.renderer.set_thinking_effect(thinking_effect)
+            self.renderer.configure_shimmer(shimmer_speed, shimmer_wave_width)
+            self.renderer.configure_thinking_limit(thinking_limit)
+
+        logger.info("Hot reload complete")
+
     def get_system_status(self):
         """Get current system status for monitoring and debugging.
 
@@ -556,7 +805,12 @@ class TerminalLLMChat:
         await self.conversation_logger.shutdown()
         await self.mcp_integration.shutdown()
         logger.info("LLM core service shutdown complete")
-        
+
+        # Shutdown version check service
+        if hasattr(self, 'version_check_service'):
+            await self.version_check_service.shutdown()
+            logger.debug("Version check service shutdown complete")
+
         # Shutdown all plugins dynamically
         for plugin_name, plugin_instance in self.plugin_instances.items():
             if hasattr(plugin_instance, 'shutdown'):
@@ -566,13 +820,14 @@ class TerminalLLMChat:
                 except Exception as e:
                     logger.warning(f"Error shutting down plugin {plugin_name}: {e}")
         
+        # Clear active area (input box) before restoring terminal
+        if not self.pipe_mode:
+            self.renderer.clear_active_area(force=True)
+
         # Restore terminal
         self.renderer.exit_raw_mode()
         # Only show cursor if not in pipe mode
         if not self.pipe_mode:
             print("\033[?25h")  # Show cursor
-            # print("Exiting...")
-        
-        # Close state manager
-        self.state_manager.close()
+
         logger.info("Application shutdown complete")