praisonai-code 0.0.1__py3-none-any.whl

praisonai_code/cli/features/tui/widgets/chat.py

@@ -0,0 +1,263 @@
+"""
+Chat Widget for PraisonAI TUI.
+
+Displays chat history with streaming support.
+"""
+
+from typing import List, Optional
+from dataclasses import dataclass, field
+import time
+
+try:
+    from textual.widget import Widget
+    from textual.widgets import Static
+    from textual.containers import VerticalScroll
+    from textual.message import Message
+    from rich.markdown import Markdown
+    from rich.panel import Panel
+    from rich.text import Text
+    TEXTUAL_AVAILABLE = True
+except ImportError:
+    TEXTUAL_AVAILABLE = False
+    Widget = object
+    Message = object
+
+
+@dataclass
+class ChatMessage:
+    """A single chat message."""
+    role: str  # "user", "assistant", "system", "tool"
+    content: str
+    timestamp: float = field(default_factory=time.time)
+    run_id: Optional[str] = None
+    agent_name: Optional[str] = None
+    is_streaming: bool = False
+    
+    @property
+    def display_role(self) -> str:
+        """Get display name for role."""
+        if self.role == "user":
+            return "You"
+        elif self.role == "assistant":
+            return self.agent_name or "Assistant"
+        elif self.role == "system":
+            return "System"
+        elif self.role == "tool":
+            return "Tool"
+        return self.role.title()
+
+
+if TEXTUAL_AVAILABLE:
+    class ChatWidget(VerticalScroll):
+        """
+        Widget for displaying chat history with scrollbar.
+        
+        Uses VerticalScroll for proper scrollbar support.
+        Messages are mounted directly to this container.
+        """
+        
+        DEFAULT_CSS = """
+        ChatWidget {
+            height: 1fr;
+            border: solid $primary;
+            background: $surface;
+            padding: 0 1;
+            overflow-y: auto;
+        }
+        
+        ChatWidget .message-user {
+            background: $primary-darken-2;
+            margin: 1 0;
+            padding: 1;
+        }
+        
+        ChatWidget .message-assistant {
+            background: $surface-darken-1;
+            margin: 1 0;
+            padding: 1;
+        }
+        
+        ChatWidget .message-system {
+            background: $warning-darken-3;
+            margin: 1 0;
+            padding: 1;
+            color: $text-muted;
+        }
+        
+        ChatWidget .message-streaming {
+            border: dashed $accent;
+        }
+        """
+        
+        class MessageAdded(Message):
+            """Event when a message is added."""
+            def __init__(self, message: ChatMessage):
+                self.message = message
+                super().__init__()
+        
+        class StreamingUpdate(Message):
+            """Event when streaming content updates."""
+            def __init__(self, run_id: str, content: str):
+                self.run_id = run_id
+                self.content = content
+                super().__init__()
+        
+        def __init__(
+            self,
+            max_messages: int = 1000,
+            name: Optional[str] = None,
+            id: Optional[str] = None,
+            classes: Optional[str] = None,
+        ):
+            super().__init__(name=name, id=id, classes=classes)
+            self._messages: List[ChatMessage] = []
+            self._max_messages = max_messages
+            self._streaming_widgets: dict = {}
+        
+        def compose(self):
+            """Compose the widget - no inner container needed."""
+            # Messages are mounted directly to this VerticalScroll
+            # Must yield from empty iterable (not return None)
+            yield from ()
+        
+        async def add_message(self, message: ChatMessage) -> None:
+            """Add a message to the chat.
+            
+            NEW BEHAVIOR: Messages render NEWEST at TOP.
+            This guarantees visibility without relying on scroll.
+            """
+            self._messages.append(message)
+            
+            # Trim old messages if needed
+            if len(self._messages) > self._max_messages:
+                self._messages = self._messages[-self._max_messages:]
+            
+            # Render message and scroll to show it
+            await self._render_message(message)
+            
+            self.post_message(self.MessageAdded(message))
+        
+        async def _render_message(self, message: ChatMessage) -> None:
+            """Render a message and scroll to show it."""
+            # Create role label
+            role_style = {
+                "user": "bold cyan",
+                "assistant": "bold green",
+                "system": "bold yellow",
+                "tool": "bold magenta",
+            }.get(message.role, "bold")
+            
+            role_text = Text(f"{message.display_role}:", style=role_style)
+            
+            # Create content
+            try:
+                content = Markdown(message.content) if message.content else Text("")
+            except Exception:
+                content = Text(message.content)
+            
+            # Create panel
+            css_class = f"message-{message.role}"
+            if message.is_streaming:
+                css_class += " message-streaming"
+            
+            widget_id = f"msg-{message.run_id or id(message)}"
+            
+            panel = Static(
+                Panel(content, title=str(role_text), border_style=role_style),
+                id=widget_id,
+                classes=css_class,
+            )
+            
+            # Mount directly to this VerticalScroll container
+            await self.mount(panel)
+            
+            # Scroll to end to show new message
+            self.scroll_end(animate=True)
+            
+            if message.is_streaming:
+                self._streaming_widgets[message.run_id] = widget_id
+        
+        async def update_streaming(self, run_id: str, content: str) -> None:
+            """Update a streaming message."""
+            if run_id not in self._streaming_widgets:
+                return
+            
+            widget_id = self._streaming_widgets[run_id]
+            
+            try:
+                widget = self.query_one(f"#{widget_id}", Static)
+                
+                # Find the message
+                for msg in self._messages:
+                    if msg.run_id == run_id:
+                        msg.content = content
+                        break
+                
+                # Update content
+                try:
+                    rendered = Markdown(content + " ▌")
+                except Exception:
+                    rendered = Text(content + " ▌")
+                
+                widget.update(Panel(rendered, title="Assistant", border_style="bold green"))
+                
+                # Scroll to end to keep streaming content visible
+                self.scroll_end(animate=True)
+                
+            except Exception:
+                pass
+        
+        async def complete_streaming(self, run_id: str, final_content: str) -> None:
+            """Complete a streaming message."""
+            if run_id not in self._streaming_widgets:
+                return
+            
+            widget_id = self._streaming_widgets.pop(run_id)
+            
+            try:
+                widget = self.query_one(f"#{widget_id}", Static)
+                
+                # Update message
+                for msg in self._messages:
+                    if msg.run_id == run_id:
+                        msg.content = final_content
+                        msg.is_streaming = False
+                        break
+                
+                # Update content without cursor
+                try:
+                    rendered = Markdown(final_content)
+                except Exception:
+                    rendered = Text(final_content)
+                
+                widget.update(Panel(rendered, title="Assistant", border_style="bold green"))
+                widget.remove_class("message-streaming")
+                
+            except Exception:
+                pass
+        
+        async def clear(self) -> None:
+            """Clear all messages."""
+            self._messages.clear()
+            self._streaming_widgets.clear()
+            
+            # Remove all children from this container
+            await self.remove_children()
+        
+        @property
+        def messages(self) -> List[ChatMessage]:
+            """Get all messages."""
+            return self._messages.copy()
+        
+        @property
+        def message_count(self) -> int:
+            """Get message count."""
+            return len(self._messages)
+
+else:
+    class ChatWidget:
+        """Placeholder when Textual is not available."""
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "Textual is required for TUI. Install with: pip install praisonai[tui]"
+            )

praisonai_code/cli/features/tui/widgets/command_popup.py

@@ -0,0 +1,258 @@
+"""
+Command Popup Widget for PraisonAI TUI.
+
+Shows a searchable list of available commands when user types backslash.
+Inspired by Claude Code's command discovery UX.
+"""
+
+from typing import List, Optional, Callable
+from dataclasses import dataclass
+
+try:
+    from textual.widget import Widget
+    from textual.widgets import Static, Input, OptionList
+    from textual.widgets.option_list import Option
+    from textual.containers import Vertical, Container
+    from textual.reactive import reactive
+    from textual.message import Message
+    from textual import events
+    from rich.text import Text
+    TEXTUAL_AVAILABLE = True
+except ImportError:
+    TEXTUAL_AVAILABLE = False
+    Widget = object
+    Message = object
+
+
+@dataclass
+class CommandInfo:
+    """Information about a command for display."""
+    name: str
+    description: str
+    aliases: List[str]
+    category: str = "general"
+    
+    @property
+    def display_name(self) -> str:
+        """Get display name with aliases."""
+        if self.aliases:
+            return f"{self.name} ({', '.join(self.aliases)})"
+        return self.name
+
+
+if TEXTUAL_AVAILABLE:
+    class CommandPopupWidget(Container):
+        """
+        Popup widget for command discovery and selection.
+        
+        Features:
+        - Shows all available commands
+        - Searchable/filterable
+        - Keyboard navigation
+        - Category grouping
+        """
+        
+        DEFAULT_CSS = """
+        CommandPopupWidget {
+            layer: popup;
+            width: 60;
+            height: auto;
+            max-height: 20;
+            background: $surface;
+            border: solid $primary;
+            padding: 1;
+            margin: 0 0 0 2;
+        }
+        
+        CommandPopupWidget #popup-title {
+            height: 1;
+            background: $primary;
+            color: $text;
+            text-align: center;
+            margin-bottom: 1;
+        }
+        
+        CommandPopupWidget #popup-search {
+            height: 3;
+            margin-bottom: 1;
+        }
+        
+        CommandPopupWidget #popup-list {
+            height: auto;
+            max-height: 12;
+            background: $surface-darken-1;
+        }
+        
+        CommandPopupWidget .command-item {
+            padding: 0 1;
+        }
+        
+        CommandPopupWidget .command-item:hover {
+            background: $primary-darken-1;
+        }
+        
+        CommandPopupWidget #popup-hint {
+            height: 1;
+            color: $text-muted;
+            text-align: center;
+            margin-top: 1;
+        }
+        """
+        
+        class CommandSelected(Message):
+            """Event when a command is selected."""
+            def __init__(self, command: str, args: str = ""):
+                self.command = command
+                self.args = args
+                super().__init__()
+        
+        class Dismissed(Message):
+            """Event when popup is dismissed."""
+            pass
+        
+        # Reactive properties
+        filter_text: reactive[str] = reactive("")
+        
+        def __init__(
+            self,
+            commands: Optional[List[CommandInfo]] = None,
+            name: Optional[str] = None,
+            id: Optional[str] = None,
+            classes: Optional[str] = None,
+        ):
+            super().__init__(name=name, id=id, classes=classes)
+            self._commands = commands or []
+            self._filtered_commands: List[CommandInfo] = []
+        
+        def compose(self):
+            """Compose the widget."""
+            yield Static("Commands", id="popup-title")
+            yield Input(placeholder="Type to filter...", id="popup-search")
+            yield OptionList(id="popup-list")
+            yield Static("↑↓ Navigate • Enter Select • Esc Cancel", id="popup-hint")
+        
+        def on_mount(self) -> None:
+            """Handle mount."""
+            self._update_list()
+            # Focus the search input
+            search = self.query_one("#popup-search", Input)
+            search.focus()
+        
+        def set_commands(self, commands: List[CommandInfo]) -> None:
+            """Set the available commands."""
+            self._commands = commands
+            self._update_list()
+        
+        def watch_filter_text(self, value: str) -> None:
+            """React to filter text changes."""
+            self._update_list()
+        
+        def _update_list(self) -> None:
+            """Update the command list based on filter."""
+            filter_lower = self.filter_text.lower()
+            
+            if filter_lower:
+                self._filtered_commands = [
+                    cmd for cmd in self._commands
+                    if (filter_lower in cmd.name.lower() or
+                        filter_lower in cmd.description.lower() or
+                        any(filter_lower in alias.lower() for alias in cmd.aliases))
+                ]
+            else:
+                self._filtered_commands = self._commands.copy()
+            
+            # Update the option list
+            try:
+                option_list = self.query_one("#popup-list", OptionList)
+                option_list.clear_options()
+                
+                for cmd in self._filtered_commands:
+                    # Create rich text for the option
+                    text = Text()
+                    text.append(f"/{cmd.name}", style="bold cyan")
+                    if cmd.aliases:
+                        text.append(f" ({', '.join(cmd.aliases)})", style="dim")
+                    text.append(f"\n  {cmd.description}", style="")
+                    
+                    option_list.add_option(Option(text, id=cmd.name))
+            except Exception:
+                pass
+        
+        def on_input_changed(self, event: Input.Changed) -> None:
+            """Handle search input changes."""
+            if event.input.id == "popup-search":
+                self.filter_text = event.value
+        
+        def on_input_submitted(self, event: Input.Submitted) -> None:
+            """Handle Enter in search input."""
+            if event.input.id == "popup-search":
+                # Select first matching command
+                if self._filtered_commands:
+                    self._select_command(self._filtered_commands[0].name)
+        
+        def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+            """Handle command selection from list."""
+            if event.option.id:
+                self._select_command(str(event.option.id))
+        
+        def on_key(self, event: events.Key) -> None:
+            """Handle key events."""
+            if event.key == "escape":
+                self.post_message(self.Dismissed())
+                event.stop()
+            elif event.key == "down":
+                # Move focus to list if in search
+                try:
+                    option_list = self.query_one("#popup-list", OptionList)
+                    option_list.focus()
+                except Exception:
+                    pass
+            elif event.key == "up":
+                # Move focus to search if at top of list
+                try:
+                    search = self.query_one("#popup-search", Input)
+                    search.focus()
+                except Exception:
+                    pass
+        
+        def _select_command(self, command_name: str) -> None:
+            """Select a command and emit event."""
+            self.post_message(self.CommandSelected(command_name))
+        
+        def focus_search(self) -> None:
+            """Focus the search input."""
+            try:
+                search = self.query_one("#popup-search", Input)
+                search.focus()
+            except Exception:
+                pass
+
+
+else:
+    class CommandPopupWidget:
+        """Placeholder when Textual is not available."""
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "Textual is required for TUI. Install with: pip install praisonai[tui]"
+            )
+
+
+# Default commands list (matches slash_commands.py registry)
+DEFAULT_COMMANDS = [
+    CommandInfo("help", "Show help for commands", ["h", "?"]),
+    CommandInfo("clear", "Clear conversation history", ["reset"]),
+    CommandInfo("model", "Show or change the current model", ["m"]),
+    CommandInfo("cost", "Show session cost and token usage", ["usage", "stats"]),
+    CommandInfo("tokens", "Show token usage breakdown", []),
+    CommandInfo("queue", "Show queue status", ["q"]),
+    CommandInfo("cancel", "Cancel current operation", ["c"]),
+    CommandInfo("settings", "Show current settings", ["set"]),
+    CommandInfo("sessions", "Browse saved sessions", ["sess"]),
+    CommandInfo("tools", "Toggle tools panel", ["t"]),
+    CommandInfo("exit", "Exit the TUI", ["quit", "q"]),
+]
+
+
+def get_default_commands() -> List[CommandInfo]:
+    """Get the default command list."""
+    return DEFAULT_COMMANDS.copy()