alloy-runtime-cli 0.1.0__py3-none-any.whl

cli/tui/chat/slash_commands.py

@@ -0,0 +1,424 @@
+"""Slash command system for the chat interface.
+
+Provides a registry-based system for defining and executing slash commands
+like /clear, /help, /copy, etc. Commands are parsed from user input and
+executed with access to the chat context.
+"""
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Protocol
+
+from cli.tui.chat.store import ChatStore
+
+if TYPE_CHECKING:
+    from cli.tui.app import AlloyRuntimeApp
+
+
+@dataclass
+class SlashContext:
+    """Context provided to slash commands during execution.
+
+    Contains all the resources a command might need to perform its action.
+    """
+
+    store: ChatStore
+    app: "AlloyRuntimeApp"
+
+    def notify(self, message: str, severity: str = "information") -> None:
+        """Notify the user with a message.
+
+        Args:
+            message: The message to display.
+            severity: Notification severity (information, warning, error).
+        """
+        self.app.notify(message, severity=severity)  # type: ignore[arg-type]
+
+
+class SlashCommand(Protocol):
+    """Protocol for slash commands.
+
+    All slash commands must implement this protocol to be registered.
+    """
+
+    @property
+    def name(self) -> str:
+        """Primary command name (without slash)."""
+        ...
+
+    @property
+    def description(self) -> str:
+        """Short description shown in /help."""
+        ...
+
+    @property
+    def aliases(self) -> tuple[str, ...]:
+        """Alternative names for the command."""
+        ...
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Execute the command.
+
+        Args:
+            args: Arguments passed after the command name.
+            context: Execution context with store, app, and notify.
+        """
+        ...
+
+
+@dataclass
+class ParseResult:
+    """Result of parsing user input for slash commands."""
+
+    is_command: bool
+    command: SlashCommand | None = None
+    args: str = ""
+    raw_input: str = ""
+
+
+class SlashCommandRegistry:
+    """Registry of available slash commands.
+
+    Manages command registration, lookup by name/alias, and parsing.
+    """
+
+    def __init__(self) -> None:
+        self._commands: dict[str, SlashCommand] = {}
+        self._all_commands: list[SlashCommand] = []
+
+    def register(self, command: SlashCommand) -> None:
+        """Register a slash command.
+
+        Args:
+            command: The command to register.
+        """
+        self._commands[command.name] = command
+        for alias in command.aliases:
+            self._commands[alias] = command
+        self._all_commands.append(command)
+
+    def get(self, name: str) -> SlashCommand | None:
+        """Get a command by name or alias.
+
+        Args:
+            name: Command name (without slash).
+
+        Returns:
+            The command if found, None otherwise.
+        """
+        return self._commands.get(name.lower())
+
+    def list_commands(self) -> list[SlashCommand]:
+        """Get all registered commands (no duplicates from aliases)."""
+        return list(self._all_commands)
+
+    def parse(self, text: str) -> ParseResult:
+        """Parse user input to detect slash commands.
+
+        Args:
+            text: Raw user input.
+
+        Returns:
+            ParseResult indicating if input is a command and which one.
+        """
+        text = text.strip()
+
+        if not text.startswith("/"):
+            return ParseResult(is_command=False, raw_input=text)
+
+        # Split into command and args
+        parts = text[1:].split(maxsplit=1)
+        name = parts[0].lower() if parts else ""
+        args = parts[1] if len(parts) > 1 else ""
+
+        command = self.get(name)
+        return ParseResult(
+            is_command=True,
+            command=command,
+            args=args,
+            raw_input=text,
+        )
+
+
+# =============================================================================
+# Built-in Commands
+# =============================================================================
+
+
+@dataclass
+class ClearCommand:
+    """Clear the message display and show welcome."""
+
+    name: str = field(default="clear", init=False)
+    description: str = field(default="Clear the message display", init=False)
+    aliases: tuple[str, ...] = field(default=("c", "cls"), init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Clear display - args are ignored."""
+        del args  # Unused
+        context.store.clear_session()
+        context.notify("Display cleared", "information")
+
+
+@dataclass
+class HelpCommand:
+    """Show available slash commands."""
+
+    name: str = field(default="help", init=False)
+    description: str = field(default="Show available commands", init=False)
+    aliases: tuple[str, ...] = field(default=("h", "?"), init=False)
+    registry: SlashCommandRegistry | None = None
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Display help - args can filter to specific command."""
+        del args  # Could be used for command-specific help later
+
+        if not self.registry:
+            context.notify("Help unavailable", "warning")
+            return
+
+        # Build help text
+        lines = ["[bold]Available Commands:[/]", ""]
+        for cmd in self.registry.list_commands():
+            alias_str = ""
+            if cmd.aliases:
+                alias_str = (
+                    f" [dim](aliases: {', '.join('/' + a for a in cmd.aliases)})[/]"
+                )
+            lines.append(f"  [cyan]/{cmd.name}[/] - {cmd.description}{alias_str}")
+
+        lines.append("")
+        lines.append(
+            "[dim]Keyboard shortcuts also available: Ctrl+N (new), Ctrl+R (regenerate), etc.[/]"
+        )
+
+        # Show as notification - in a real impl could show in a modal
+        context.notify("\n".join(lines), "information")
+
+
+@dataclass
+class CopyCommand:
+    """Copy the last assistant response to clipboard."""
+
+    name: str = field(default="copy", init=False)
+    description: str = field(default="Copy last response to clipboard", init=False)
+    aliases: tuple[str, ...] = field(default=("cp", "y"), init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Copy last assistant message - args are ignored."""
+        del args  # Unused
+
+        from cli.tui.chat.types import extract_message_text
+
+        messages = context.store.state.messages
+        if not messages:
+            context.notify("No messages to copy", "warning")
+            return
+
+        # Find last assistant message
+        for msg in reversed(messages):
+            if msg.role == "assistant":
+                text = extract_message_text(msg)
+                if text:
+                    from cli.infrastructure.tui.clipboard import copy_to_clipboard
+
+                    copy_to_clipboard(context.app, text, "Last response")
+                    return
+
+        context.notify("No assistant message to copy", "warning")
+
+
+@dataclass
+class NewCommand:
+    """Request a new chat session."""
+
+    name: str = field(default="new", init=False)
+    description: str = field(default="Start a new chat session", init=False)
+    aliases: tuple[str, ...] = field(default=("n",), init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Request new session - signals to screen to open modal."""
+        del args, context  # Command handled by screen via message
+
+
+@dataclass
+class SessionsCommand:
+    """Focus the session sidebar for browsing."""
+
+    name: str = field(default="sessions", init=False)
+    description: str = field(default="Focus session sidebar", init=False)
+    aliases: tuple[str, ...] = field(default=("s", "list"), init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Focus sessions - signals to screen to focus sidebar."""
+        del args, context  # Command handled by screen via message
+
+
+@dataclass
+class UndoCommand:
+    """Undo the last conversation turn."""
+
+    name: str = field(default="undo", init=False)
+    description: str = field(default="Undo last conversation turn", init=False)
+    aliases: tuple[str, ...] = field(default=("u", "z"), init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Undo last turn - signals to screen to perform undo."""
+        del args, context  # Command handled by screen via message
+
+
+@dataclass
+class RegenerateCommand:
+    """Regenerate the last AI response."""
+
+    name: str = field(default="regenerate", init=False)
+    description: str = field(default="Regenerate last response", init=False)
+    aliases: tuple[str, ...] = field(default=("r", "regen"), init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Regenerate - signals to screen to perform regeneration."""
+        del args, context  # Command handled by screen via message
+
+
+@dataclass
+class AutoNameCommand:
+    """Toggle automatic session naming."""
+
+    name: str = field(default="autoname", init=False)
+    description: str = field(default="Toggle automatic session naming", init=False)
+    aliases: tuple[str, ...] = field(default=("an",), init=False)
+
+    # Storage key for the preference
+    _PREF_KEY: str = field(default="auto_name_sessions", init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Toggle auto-naming or set to specific value.
+
+        Args can be:
+        - (empty): Toggle the current setting
+        - "on" / "true" / "1": Enable auto-naming
+        - "off" / "false" / "0": Disable auto-naming
+        """
+        from cli.infrastructure.local_storage import get_storage
+
+        storage = get_storage()
+        current = storage.get("preferences", self._PREF_KEY, True)
+
+        # Parse args to determine new value
+        args_lower = args.strip().lower()
+        if args_lower in ("on", "true", "1", "enable", "yes"):
+            new_value = True
+        elif args_lower in ("off", "false", "0", "disable", "no"):
+            new_value = False
+        else:
+            # Toggle
+            new_value = not current
+
+        storage.set("preferences", self._PREF_KEY, new_value)
+
+        status = "enabled" if new_value else "disabled"
+        context.notify(f"Automatic session naming {status}", "information")
+
+
+@dataclass
+class SplitCommand:
+    """Toggle split-pane view for comparing models."""
+
+    name: str = field(default="split", init=False)
+    description: str = field(default="Toggle split-pane view", init=False)
+    aliases: tuple[str, ...] = field(default=(), init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Toggle split view - handled by screen via message."""
+        del args, context  # Command handled by screen via message
+
+
+@dataclass
+class SyncCommand:
+    """Toggle synchronized input mode in split view."""
+
+    name: str = field(default="sync", init=False)
+    description: str = field(
+        default="Toggle sync mode (send to both panes)", init=False
+    )
+    aliases: tuple[str, ...] = field(default=(), init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Toggle sync mode - handled by screen via message."""
+        del args, context  # Command handled by screen via message
+
+
+@dataclass
+class SwitchPaneCommand:
+    """Switch focus between panes in split view."""
+
+    name: str = field(default="switch", init=False)
+    description: str = field(default="Switch between panes in split view", init=False)
+    aliases: tuple[str, ...] = field(default=("sw",), init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Switch pane focus - handled by screen via message."""
+        del args, context  # Command handled by screen via message
+
+
+@dataclass
+class MarkdownToggleCommand:
+    """Toggle markdown rendering on/off."""
+
+    name: str = field(default="markdown", init=False)
+    description: str = field(default="Toggle markdown rendering", init=False)
+    aliases: tuple[str, ...] = field(default=("md", "plain"), init=False)
+
+    def execute(self, args: str, context: SlashContext) -> None:
+        """Toggle render mode between markdown and plain text."""
+        del args  # Unused
+
+        from cli.tui.chat.types import RenderMode
+
+        old_mode = context.store.state.render_mode
+        context.store.toggle_render_mode()
+        new_mode = context.store.state.render_mode
+        mode_name = "Markdown" if new_mode == RenderMode.MARKDOWN else "Plain text"
+        context.notify(f"Render mode: {mode_name} (was {old_mode.name})", "information")
+
+
+def create_default_registry() -> SlashCommandRegistry:
+    """Create a registry with all built-in commands.
+
+    Returns:
+        SlashCommandRegistry populated with default commands.
+    """
+    registry = SlashCommandRegistry()
+
+    # Create help command with registry reference
+    help_cmd = HelpCommand()
+    help_cmd.registry = registry
+
+    # Register all commands
+    registry.register(ClearCommand())
+    registry.register(help_cmd)
+    registry.register(CopyCommand())
+    registry.register(NewCommand())
+    registry.register(SessionsCommand())
+    registry.register(UndoCommand())
+    registry.register(RegenerateCommand())
+    registry.register(AutoNameCommand())
+    # Split view commands
+    registry.register(SplitCommand())
+    registry.register(SyncCommand())
+    registry.register(SwitchPaneCommand())
+    # Rendering commands
+    registry.register(MarkdownToggleCommand())
+
+    return registry
+
+
+# Default global registry
+_default_registry: SlashCommandRegistry | None = None
+
+
+def get_default_registry() -> SlashCommandRegistry:
+    """Get the default slash command registry (lazy-initialized singleton)."""
+    global _default_registry
+    if _default_registry is None:
+        _default_registry = create_default_registry()
+    return _default_registry

cli/tui/chat/store.py

@@ -0,0 +1,280 @@
+"""Reactive state store for the chat module.
+
+Provides centralized state management with subscriber notifications.
+Widgets subscribe to state changes and react accordingly.
+"""
+
+from dataclasses import replace
+from typing import Callable
+from uuid import UUID
+
+from alloy_runtime_types.dtos.sessions import MessageResponse, SessionSummary
+from alloy_runtime_sdk.logging.config import get_logger
+
+from cli.tui.chat.types import ChatPhase, ChatState, RenderMode, SessionContext
+
+logger = get_logger(__name__)
+
+
+class ChatStore:
+    """Reactive state store for chat screen.
+
+    Follows the observable store pattern:
+    - State is accessed via .state property (immutable snapshot)
+    - Mutations happen through methods that create new state
+    - Subscribers are notified on every state change
+
+    Usage:
+        store = ChatStore()
+
+        # Subscribe to changes
+        def on_change(state: ChatState):
+            print(f"Phase: {state.phase}")
+
+        unsubscribe = store.subscribe(on_change)
+
+        # Mutate state
+        store.set_phase(ChatPhase.STREAMING)  # triggers on_change
+
+        # Unsubscribe when done
+        unsubscribe()
+    """
+
+    def __init__(self) -> None:
+        """Initialize with default state."""
+        self._state = ChatState()
+        self._subscribers: list[Callable[[ChatState], None]] = []
+
+    @property
+    def state(self) -> ChatState:
+        """Get current immutable state snapshot."""
+        return self._state
+
+    def subscribe(self, callback: Callable[[ChatState], None]) -> Callable[[], None]:
+        """Subscribe to state changes.
+
+        Args:
+            callback: Function called with new state on every change.
+
+        Returns:
+            Unsubscribe function - call to stop receiving updates.
+        """
+        self._subscribers.append(callback)
+        return lambda: self._subscribers.remove(callback)
+
+    def _notify(self) -> None:
+        """Notify all subscribers of state change."""
+        for subscriber in self._subscribers:
+            subscriber(self._state)
+
+    def _update(self, **changes: object) -> None:
+        """Update state with changes and notify subscribers.
+
+        Creates a new ChatState with the given field changes.
+        """
+        self._state = replace(self._state, **changes)
+        self._notify()
+
+    # === Phase Management ===
+
+    def set_phase(self, phase: ChatPhase) -> None:
+        """Set the current chat phase."""
+        old_phase = self._state.phase
+        if old_phase != phase:
+            logger.debug(
+                "store_phase_changed", old_phase=old_phase.name, new_phase=phase.name
+            )
+        self._update(phase=phase)
+
+    def is_busy(self) -> bool:
+        """Check if the chat is in a busy state (can't accept new actions)."""
+        return self._state.phase not in (ChatPhase.IDLE,)
+
+    # === Session Management ===
+
+    def set_session(
+        self,
+        session_id: UUID,
+        session_name: str | None,
+        agent_id: UUID | None,
+        agent_name: str | None,
+        message_count: int,
+        provider_key: str | None = None,
+        model_name: str | None = None,
+        system_instruction: str | None = None,
+    ) -> None:
+        """Set the active session context.
+
+        Args:
+            session_id: The session ID.
+            session_name: Optional session name.
+            agent_id: Agent ID (for agent mode).
+            agent_name: Agent name (for agent mode).
+            message_count: Number of messages in session.
+            provider_key: Provider key (for direct model mode).
+            model_name: Model name (for direct model mode).
+            system_instruction: System instruction (for direct model mode).
+        """
+        session = SessionContext(
+            session_id=session_id,
+            session_name=session_name,
+            agent_id=agent_id,
+            agent_name=agent_name,
+            message_count=message_count,
+            provider_key=provider_key,
+            model_name=model_name,
+            system_instruction=system_instruction,
+        )
+        logger.info(
+            "store_session_set",
+            session_id=str(session_id),
+            session_name=session_name,
+            agent_name=agent_name,
+            model_name=model_name,
+            message_count=message_count,
+        )
+        self._update(session=session)
+
+    def clear_session(self) -> None:
+        """Clear the active session."""
+        logger.debug("store_session_cleared")
+        self._update(session=None, messages=())
+
+    def set_sessions(self, sessions: list[SessionSummary]) -> None:
+        """Set the session list."""
+        self._update(sessions=tuple(sessions))
+
+    def set_session_search_query(self, query: str) -> None:
+        """Set the session search query."""
+        self._update(session_search_query=query)
+
+    # === Message Management ===
+
+    def set_messages(self, messages: list[MessageResponse]) -> None:
+        """Set the message list for current session."""
+        logger.debug("store_messages_set", message_count=len(messages))
+        self._update(messages=tuple(messages))
+
+    def append_streaming_content(self, chunk: str) -> None:
+        """Append content to streaming buffer."""
+        new_content = self._state.streaming_content + chunk
+        self._update(streaming_content=new_content)
+
+    def append_streaming_thinking_content(self, chunk: str) -> None:
+        """Append content to streaming thinking/reasoning buffer."""
+        new_content = self._state.streaming_thinking_content + chunk
+        self._update(streaming_thinking_content=new_content)
+
+    def clear_streaming_content(self) -> None:
+        """Clear the streaming content buffer."""
+        self._update(streaming_content="", streaming_thinking_content="")
+
+    # === Error Management ===
+
+    def set_error(self, error: str | None) -> None:
+        """Set or clear error state."""
+        if error:
+            logger.warning("store_error_set", error=error)
+        self._update(error=error)
+
+    def clear_error(self) -> None:
+        """Clear error state."""
+        self._update(error=None)
+
+    # === Convenience Methods ===
+
+    def start_streaming(self, user_message: str | None = None) -> None:
+        """Transition to streaming state with optional pending user message."""
+        logger.info(
+            "store_streaming_started",
+            has_user_message=user_message is not None,
+            message_preview=user_message[:50] if user_message else None,
+        )
+        self._update(
+            phase=ChatPhase.STREAMING,
+            streaming_content="",
+            streaming_thinking_content="",
+            error=None,
+            pending_user_message=user_message,
+            cancel_requested=False,  # Reset cancellation flag on new stream
+        )
+
+    def finish_streaming(self, cancelled: bool = False) -> None:
+        """Transition from streaming back to idle.
+
+        Args:
+            cancelled: If True, keep streaming content visible for cancelled streams.
+        """
+        content_length = len(self._state.streaming_content)
+        logger.info(
+            "store_streaming_finished",
+            cancelled=cancelled,
+            content_length=content_length,
+        )
+        if cancelled:
+            # Keep the partial content visible when cancelled
+            self._update(
+                phase=ChatPhase.IDLE,
+                cancel_requested=False,
+            )
+        else:
+            # Normal completion - clear streaming content
+            self._update(
+                phase=ChatPhase.IDLE,
+                streaming_content="",
+                streaming_thinking_content="",
+                pending_user_message=None,
+                cancel_requested=False,
+            )
+
+    def request_cancel(self) -> None:
+        """Request cancellation of current streaming operation."""
+        if self._state.phase == ChatPhase.STREAMING:
+            logger.info("store_cancel_requested")
+            self._update(cancel_requested=True)
+
+    def toggle_thinking_collapsed(self) -> None:
+        """Toggle whether thinking blocks are collapsed."""
+        self._update(thinking_collapsed=not self._state.thinking_collapsed)
+
+    def set_thinking_collapsed(self, collapsed: bool) -> None:
+        """Set whether thinking blocks are collapsed."""
+        self._update(thinking_collapsed=collapsed)
+
+    def set_pending_user_message(self, message: str | None) -> None:
+        """Set the pending user message (shown optimistically before server confirms)."""
+        self._update(pending_user_message=message)
+
+    def clear_pending_user_message(self) -> None:
+        """Clear the pending user message."""
+        self._update(pending_user_message=None)
+
+    def reset(self) -> None:
+        """Reset to initial state."""
+        self._state = ChatState()
+        self._notify()
+
+    # === UI State ===
+
+    def toggle_sidebar(self) -> None:
+        """Toggle sidebar visibility."""
+        self._update(sidebar_visible=not self._state.sidebar_visible)
+
+    def set_sidebar_visible(self, visible: bool) -> None:
+        """Set sidebar visibility."""
+        self._update(sidebar_visible=visible)
+
+    def toggle_render_mode(self) -> None:
+        """Toggle between markdown and plain text rendering."""
+        current = self._state.render_mode
+        new_mode = (
+            RenderMode.PLAIN if current == RenderMode.MARKDOWN else RenderMode.MARKDOWN
+        )
+        logger.debug(
+            "store_render_mode_toggled", old_mode=current.name, new_mode=new_mode.name
+        )
+        self._update(render_mode=new_mode)
+
+    def set_render_mode(self, mode: RenderMode) -> None:
+        """Set the render mode."""
+        self._update(render_mode=mode)