kollabor 0.4.9__py3-none-any.whl

core/cli.py

@@ -0,0 +1,193 @@
+"""CLI entry point for kollab command."""
+
+import asyncio
+import argparse
+import logging
+import sys
+import re
+from pathlib import Path
+from importlib.metadata import version, PackageNotFoundError
+
+# Import from the same directory
+from .application import TerminalLLMChat
+from .logging import setup_bootstrap_logging
+
+# Get version from package metadata (set in pyproject.toml)
+try:
+    __version__ = version("kollabor")
+except PackageNotFoundError:
+    __version__ = "0.4.7"  # Fallback for development mode
+
+
+def parse_timeout(timeout_str: str) -> int:
+    """Parse timeout string into seconds.
+
+    Args:
+        timeout_str: Timeout string like "30s", "2min", "1h"
+
+    Returns:
+        Timeout in seconds
+
+    Raises:
+        ValueError: If timeout format is invalid
+    """
+    timeout_str = timeout_str.strip().lower()
+
+    # Match pattern like "30s", "2min", "1h"
+    match = re.match(
+        r"^(\d+(?:\.\d+)?)(s|sec|second|seconds|m|min|minute|minutes|h|hour|hours)$",
+        timeout_str,
+    )
+    if not match:
+        raise ValueError(
+            f"Invalid timeout format: {timeout_str}. Use format like '30s', '2min', or '1h'"
+        )
+
+    value = float(match.group(1))
+    unit = match.group(2)
+
+    # Convert to seconds
+    if unit in ("s", "sec", "second", "seconds"):
+        return int(value)
+    elif unit in ("m", "min", "minute", "minutes"):
+        return int(value * 60)
+    elif unit in ("h", "hour", "hours"):
+        return int(value * 3600)
+    else:
+        raise ValueError(f"Unknown time unit: {unit}")
+
+
+def parse_arguments():
+    """Parse command-line arguments.
+
+    Returns:
+        Parsed arguments namespace
+    """
+    parser = argparse.ArgumentParser(
+        description="Kollab - Terminal-based LLM chat interface",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  kollab                                    # Start interactive mode
+  kollab "what is 1+1?"                     # Pipe mode with query
+  kollab -p "what is 1+1?"                  # Pipe mode with query
+  kollab --timeout 30s "complex query"      # Custom timeout (30 seconds)
+  kollab --timeout 5min "long task"         # Custom timeout (5 minutes)
+  echo "hello" | kollab -p                  # Pipe input from stdin
+  cat file.txt | kollab -p --timeout 1h     # Process file with 1 hour timeout
+        """,
+    )
+
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show version number and exit",
+    )
+
+    parser.add_argument(
+        "query",
+        nargs="?",
+        help="Query to process in pipe mode (if not provided, reads from stdin)",
+    )
+
+    parser.add_argument(
+        "-p",
+        "--pipe",
+        action="store_true",
+        help="Pipe mode: process input and exit (automatically enabled if query is provided)",
+    )
+
+    parser.add_argument(
+        "--timeout",
+        type=str,
+        default="2min",
+        help="Timeout for pipe mode processing (e.g., 30s, 2min, 1h). Default: 2min",
+    )
+
+    return parser.parse_args()
+
+
+async def async_main() -> None:
+    """Main async entry point for the application with proper error handling."""
+    # Setup bootstrap logging before application starts
+    setup_bootstrap_logging()
+    logger = logging.getLogger(__name__)
+
+    args = parse_arguments()
+
+    # Determine if we're in pipe mode and what the input is
+    piped_input = None
+
+    # If query argument is provided, use it (automatically enables pipe mode)
+    if args.query:
+        piped_input = args.query.strip()
+    # Otherwise, check if stdin is being piped or -p flag is set
+    elif args.pipe or not sys.stdin.isatty():
+        # Read from stdin
+        piped_input = sys.stdin.read().strip()
+        if not piped_input:
+            print("Error: No input received from pipe", file=sys.stderr)
+            sys.exit(1)
+
+    app = None
+    try:
+        logger.info("Creating application instance...")
+        app = TerminalLLMChat()
+        logger.info("Starting application...")
+
+        if piped_input:
+            # Parse timeout for pipe mode
+            try:
+                timeout_seconds = parse_timeout(args.timeout)
+            except ValueError as e:
+                print(f"Error: {e}", file=sys.stderr)
+                sys.exit(1)
+
+            # Pipe mode: send input and exit after response
+            await app.start_pipe_mode(piped_input, timeout=timeout_seconds)
+        else:
+            # Interactive mode
+            await app.start()
+    except KeyboardInterrupt:
+        # print("\n\nApplication interrupted by user")
+        logger.info("Application interrupted by user")
+    except Exception as e:
+        print(f"\n\nApplication failed to start: {e}")
+        logger.error(f"Application startup failed: {type(e).__name__}: {e}")
+        # Print helpful error message for common issues
+        if "permission" in str(e).lower():
+            print(
+                "\nTip: Check file permissions and try running with appropriate privileges"
+            )
+        elif "already in use" in str(e).lower():
+            print(
+                "\nTip: Another instance may be running. Try closing other applications."
+            )
+        elif "not found" in str(e).lower():
+            print("\nTip: Check that all required dependencies are installed.")
+        raise  # Re-raise for full traceback in debug mode
+    finally:
+        # Ensure cleanup happens even if startup fails (skip if in pipe mode and already cleaned up)
+        pipe_mode = getattr(app, "pipe_mode", False) if app else False
+        if app and not app._startup_complete and not pipe_mode:
+            logger.info("Performing emergency cleanup after startup failure...")
+            try:
+                await app.cleanup()
+            except Exception as cleanup_error:
+                logger.error(f"Emergency cleanup failed: {cleanup_error}")
+                # print("Warning: Some resources may not have been cleaned up properly")
+
+
+def cli_main() -> None:
+    """Synchronous entry point for pip-installed CLI command."""
+    try:
+        asyncio.run(async_main())
+    except KeyboardInterrupt:
+        # print("\n\nExited cleanly!")
+        pass
+    except Exception as e:
+        print(f"\n\nFatal error: {e}")
+        # Exit with error code for scripts that depend on it
+        sys.exit(1)

core/commands/__init__.py

@@ -0,0 +1,43 @@
+"""Slash command system for Kollabor CLI.
+
+This module provides a comprehensive slash command system that integrates
+with the EventBus architecture and plugin system.
+
+Key Components:
+- Parser: Detects and parses slash commands from user input
+- Registry: Manages command registration and discovery
+- Executor: Executes commands with proper error handling
+- UI: Handles command menus and status area interactions
+
+Example Usage:
+    # Register a command in a plugin
+    self.register_command(
+        name="save",
+        handler=self.handle_save,
+        description="Save conversation to file",
+        mode=CommandMode.INLINE_INPUT
+    )
+
+    # Execute a command
+    result = await command_executor.execute(command, event_bus)
+"""
+
+from ..events.models import (
+    CommandMode,
+    CommandCategory,
+    CommandDefinition,
+    SlashCommand,
+    CommandResult,
+    UIConfig,
+    ParameterDefinition
+)
+
+__all__ = [
+    "CommandMode",
+    "CommandCategory",
+    "CommandDefinition",
+    "SlashCommand",
+    "CommandResult",
+    "UIConfig",
+    "ParameterDefinition"
+]

core/commands/executor.py

@@ -0,0 +1,277 @@
+"""Command executor for slash command execution."""
+
+import asyncio
+import logging
+from typing import Dict, Any
+
+from ..events.models import SlashCommand, CommandResult, EventType, CommandMode
+from .registry import SlashCommandRegistry
+
+logger = logging.getLogger(__name__)
+
+
+class SlashCommandExecutor:
+    """Executes slash commands with proper event integration.
+
+    Handles command execution, error handling, and event bus integration
+    for all command modes and types.
+    """
+
+    def __init__(self, command_registry: SlashCommandRegistry) -> None:
+        """Initialize the command executor.
+
+        Args:
+            command_registry: Registry containing command definitions.
+        """
+        self.command_registry = command_registry
+        self.logger = logger
+
+    async def execute_command(self, command: SlashCommand, event_bus) -> CommandResult:
+        """Execute a slash command.
+
+        Args:
+            command: Parsed slash command to execute.
+            event_bus: Event bus for command lifecycle events.
+
+        Returns:
+            Command execution result.
+        """
+        try:
+            # Emit command detection event
+            await event_bus.emit_with_hooks(
+                EventType.SLASH_COMMAND_DETECTED,
+                {
+                    "command_name": command.name,
+                    "args": command.args,
+                    "raw_input": command.raw_input
+                },
+                "commands"
+            )
+
+            # Look up command definition
+            command_def = self.command_registry.get_command(command.name)
+            if not command_def:
+                error_result = CommandResult(
+                    success=False,
+                    message=f"Unknown command: /{command.name}",
+                    display_type="error"
+                )
+                await self._emit_command_error(event_bus, command, "command_not_found", error_result)
+                return error_result
+
+            # Check if command is enabled
+            if not command_def.enabled:
+                error_result = CommandResult(
+                    success=False,
+                    message=f"Command /{command.name} is currently disabled",
+                    display_type="warning"
+                )
+                await self._emit_command_error(event_bus, command, "command_disabled", error_result)
+                return error_result
+
+            # Emit command execution start event
+            await event_bus.emit_with_hooks(
+                EventType.SLASH_COMMAND_EXECUTE,
+                {
+                    "command": command,
+                    "command_def": command_def,
+                    "mode": command_def.mode.value
+                },
+                "commands"
+            )
+
+            # Execute the command handler
+            self.logger.info(f"Executing command /{command.name} from plugin {command_def.plugin_name}")
+
+            try:
+                # Call the command handler
+                if asyncio.iscoroutinefunction(command_def.handler):
+                    result = await command_def.handler(command)
+                else:
+                    result = command_def.handler(command)
+
+                # Ensure result is a CommandResult
+                if not isinstance(result, CommandResult):
+                    result = CommandResult(
+                        success=True,
+                        message=str(result) if result is not None else "Command completed successfully"
+                    )
+
+                # Emit command completion event
+                await event_bus.emit_with_hooks(
+                    EventType.SLASH_COMMAND_COMPLETE,
+                    {
+                        "command": command,
+                        "command_def": command_def,
+                        "result": result
+                    },
+                    "commands"
+                )
+
+                # Handle modal UI configs
+                if result.ui_config and result.ui_config.type == "modal":
+                    await self._trigger_modal_mode(result.ui_config, event_bus)
+                elif result.ui_config and result.ui_config.type == "status_modal":
+                    await self._trigger_status_modal_mode(result.ui_config, event_bus)
+                elif result.status_ui:
+                    # Handle status_ui component (e.g., from /status command)
+                    await self._display_status_ui(result.status_ui, event_bus)
+                else:
+                    # Handle non-modal command output display
+                    await self._display_command_result(result, event_bus)
+
+                self.logger.info(f"Command /{command.name} completed successfully")
+                return result
+
+            except Exception as handler_error:
+                error_result = CommandResult(
+                    success=False,
+                    message=f"Command /{command.name} failed: {str(handler_error)}",
+                    display_type="error",
+                    data={"error": str(handler_error)}
+                )
+
+                await self._emit_command_error(event_bus, command, "handler_error", error_result)
+                self.logger.error(f"Command /{command.name} handler failed: {handler_error}")
+                return error_result
+
+        except Exception as e:
+            error_result = CommandResult(
+                success=False,
+                message=f"Internal error executing command /{command.name}",
+                display_type="error",
+                data={"error": str(e)}
+            )
+
+            await self._emit_command_error(event_bus, command, "internal_error", error_result)
+            self.logger.error(f"Internal error executing command /{command.name}: {e}")
+            return error_result
+
+    async def _emit_command_error(self, event_bus, command: SlashCommand, error_type: str, result: CommandResult) -> None:
+        """Emit command error event.
+
+        Args:
+            event_bus: Event bus for error events.
+            command: Command that failed.
+            error_type: Type of error that occurred.
+            result: Error result details.
+        """
+        try:
+            await event_bus.emit_with_hooks(
+                EventType.SLASH_COMMAND_ERROR,
+                {
+                    "command": command,
+                    "error_type": error_type,
+                    "result": result
+                },
+                "commands"
+            )
+        except Exception as e:
+            self.logger.error(f"Failed to emit command error event: {e}")
+
+    def get_execution_stats(self) -> Dict[str, Any]:
+        """Get execution statistics for monitoring.
+
+        Returns:
+            Dictionary with execution statistics.
+        """
+        # In a full implementation, this would track execution metrics
+        return {
+            "registry_stats": self.command_registry.get_registry_stats()
+        }
+
+    async def _display_command_result(self, result: CommandResult, event_bus):
+        """Display non-modal command result through event bus.
+
+        Args:
+            result: Command result to display.
+            event_bus: Event bus for display events.
+        """
+        try:
+            if result.message:
+                # Emit command output event for display
+                await event_bus.emit_with_hooks(
+                    EventType.COMMAND_OUTPUT_DISPLAY,
+                    {
+                        "message": result.message,
+                        "display_type": result.display_type or "info",
+                        "success": result.success,
+                        "data": result.data
+                    },
+                    "command_output"
+                )
+                self.logger.info(f"Command output displayed: {result.display_type}")
+        except Exception as e:
+            self.logger.error(f"Error displaying command result: {e}")
+
+    async def _trigger_modal_mode(self, ui_config, event_bus):
+        """Trigger modal mode through event bus.
+
+        Args:
+            ui_config: UI configuration for the modal.
+            event_bus: Event bus for modal events.
+        """
+        try:
+            # Emit modal trigger event that input handler will listen for
+            await event_bus.emit_with_hooks(
+                EventType.MODAL_TRIGGER,  # Use dedicated modal trigger event
+                {
+                    "ui_config": ui_config,
+                    "action": "show_modal"
+                },
+                "modal_trigger"
+            )
+            self.logger.info("Modal UI config triggered through event bus")
+        except Exception as e:
+            self.logger.error(f"Error triggering modal mode: {e}")
+
+    async def _trigger_status_modal_mode(self, ui_config, event_bus):
+        """Trigger status modal mode through event bus.
+
+        Args:
+            ui_config: UI configuration for the status modal.
+            event_bus: Event bus for modal events.
+        """
+        try:
+            # Emit status modal trigger event that input handler will listen for
+            await event_bus.emit_with_hooks(
+                EventType.STATUS_MODAL_TRIGGER,  # New event type for status modals
+                {
+                    "ui_config": ui_config,
+                    "action": "show_status_modal"
+                },
+                "status_modal_trigger"
+            )
+            self.logger.info("Status modal UI config triggered through event bus")
+        except Exception as e:
+            self.logger.error(f"Error triggering status modal mode: {e}")
+
+    async def _display_status_ui(self, status_ui, event_bus):
+        """Display status UI component through event bus.
+
+        Args:
+            status_ui: Status UI component with render() method.
+            event_bus: Event bus for display events.
+        """
+        try:
+            # Render the status UI if it has a render method
+            if hasattr(status_ui, 'render'):
+                lines = status_ui.render()
+                message = '\n'.join(lines) if isinstance(lines, list) else str(lines)
+            else:
+                message = str(status_ui)
+
+            # Emit status display event
+            await event_bus.emit_with_hooks(
+                EventType.COMMAND_OUTPUT_DISPLAY,
+                {
+                    "message": message,
+                    "display_type": "info",
+                    "success": True,
+                    "is_status_ui": True
+                },
+                "status_display"
+            )
+            self.logger.info("Status UI displayed")
+        except Exception as e:
+            self.logger.error(f"Error displaying status UI: {e}")