PraisonAI 3.0.0__py3-none-any.whl

praisonai/cli/features/tui/widgets/__init__.py

@@ -0,0 +1,56 @@
+"""
+TUI Widgets for PraisonAI.
+
+Reusable UI components for the TUI application.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .chat import ChatWidget
+    from .composer import ComposerWidget
+    from .status import StatusWidget
+    from .queue_panel import QueuePanelWidget
+    from .tool_panel import ToolPanelWidget
+
+_lazy_cache = {}
+
+
+def __getattr__(name: str):
+    """Lazy load widgets."""
+    global _lazy_cache
+    
+    if name in _lazy_cache:
+        return _lazy_cache[name]
+    
+    if name == "ChatWidget":
+        from .chat import ChatWidget
+        _lazy_cache[name] = ChatWidget
+        return ChatWidget
+    elif name == "ComposerWidget":
+        from .composer import ComposerWidget
+        _lazy_cache[name] = ComposerWidget
+        return ComposerWidget
+    elif name == "StatusWidget":
+        from .status import StatusWidget
+        _lazy_cache[name] = StatusWidget
+        return StatusWidget
+    elif name == "QueuePanelWidget":
+        from .queue_panel import QueuePanelWidget
+        _lazy_cache[name] = QueuePanelWidget
+        return QueuePanelWidget
+    elif name == "ToolPanelWidget":
+        from .tool_panel import ToolPanelWidget
+        _lazy_cache[name] = ToolPanelWidget
+        return ToolPanelWidget
+    
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "ChatWidget",
+    "ComposerWidget", 
+    "StatusWidget",
+    "QueuePanelWidget",
+    "ToolPanelWidget",
+]

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

@@ -0,0 +1,261 @@
+"""
+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, RichLog
+    from textual.containers import ScrollableContainer, Vertical
+    from textual.reactive import reactive
+    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(ScrollableContainer):
+        """
+        Widget for displaying chat history.
+        
+        Features:
+        - Streaming message updates
+        - Markdown rendering
+        - Auto-scroll to bottom
+        - Message history management
+        """
+        
+        DEFAULT_CSS = """
+        ChatWidget {
+            height: 100%;
+            border: solid $primary;
+            background: $surface;
+            padding: 0 1;
+        }
+        
+        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."""
+            yield Vertical(id="chat-messages")
+        
+        async def add_message(self, message: ChatMessage) -> None:
+            """Add a message to the chat."""
+            self._messages.append(message)
+            
+            # Trim old messages if needed
+            if len(self._messages) > self._max_messages:
+                self._messages = self._messages[-self._max_messages:]
+            
+            # Create message widget
+            await self._render_message(message)
+            
+            # Auto-scroll to bottom
+            self.scroll_end(animate=False)
+            
+            self.post_message(self.MessageAdded(message))
+        
+        async def _render_message(self, message: ChatMessage) -> None:
+            """Render a single message."""
+            container = self.query_one("#chat-messages", Vertical)
+            
+            # 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)
+            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,
+            )
+            
+            await container.mount(panel)
+            
+            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"))
+                
+                # Auto-scroll
+                self.scroll_end(animate=False)
+                
+            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()
+            
+            container = self.query_one("#chat-messages", Vertical)
+            await container.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/cli/features/tui/widgets/composer.py

@@ -0,0 +1,224 @@
+"""
+Composer Widget for PraisonAI TUI.
+
+Input area for composing messages with slash command support.
+"""
+
+from typing import Callable, List, Optional
+import asyncio
+
+try:
+    from textual.widget import Widget
+    from textual.widgets import TextArea, Input
+    from textual.containers import Horizontal, Vertical
+    from textual.message import Message
+    from textual.binding import Binding
+    from textual import events
+    from rich.text import Text
+    TEXTUAL_AVAILABLE = True
+except ImportError:
+    TEXTUAL_AVAILABLE = False
+    Widget = object
+    Message = object
+
+
+if TEXTUAL_AVAILABLE:
+    class ComposerWidget(Vertical):
+        """
+        Input composer for chat messages.
+        
+        Features:
+        - Multi-line input
+        - Slash command detection
+        - @ mention support
+        - History navigation
+        - Send on Enter or Ctrl+Enter
+        """
+        
+        BINDINGS = [
+            Binding("ctrl+enter", "submit", "Send", show=True),
+            Binding("escape", "cancel", "Cancel", show=False),
+            Binding("up", "history_prev", "Previous", show=False),
+            Binding("down", "history_next", "Next", show=False),
+        ]
+        
+        DEFAULT_CSS = """
+        ComposerWidget {
+            height: auto;
+            max-height: 10;
+            border: solid $primary;
+            background: $surface;
+            padding: 0 1;
+        }
+        
+        ComposerWidget TextArea {
+            height: auto;
+            min-height: 3;
+            max-height: 8;
+        }
+        
+        ComposerWidget .hint {
+            color: $text-muted;
+            text-style: italic;
+        }
+        """
+        
+        class Submitted(Message):
+            """Event when message is submitted."""
+            def __init__(self, content: str, is_command: bool = False):
+                self.content = content
+                self.is_command = is_command
+                super().__init__()
+        
+        class CommandDetected(Message):
+            """Event when a slash command is detected."""
+            def __init__(self, command: str, args: str):
+                self.command = command
+                self.args = args
+                super().__init__()
+        
+        def __init__(
+            self,
+            placeholder: str = "Type your message... (Ctrl+Enter to send, /help for commands)",
+            multiline: bool = True,
+            name: Optional[str] = None,
+            id: Optional[str] = None,
+            classes: Optional[str] = None,
+        ):
+            super().__init__(name=name, id=id, classes=classes)
+            self._placeholder = placeholder
+            self._multiline = multiline
+            self._history: List[str] = []
+            self._history_index = -1
+            self._current_input = ""
+            self._is_processing = False
+        
+        def compose(self):
+            """Compose the widget."""
+            yield TextArea(
+                "",
+                id="composer-input",
+                language=None,
+            )
+        
+        def on_mount(self) -> None:
+            """Handle mount event."""
+            text_area = self.query_one("#composer-input", TextArea)
+            text_area.focus()
+        
+        async def on_text_area_changed(self, event: TextArea.Changed) -> None:
+            """Handle text changes."""
+            content = event.text_area.text
+            
+            # Detect slash commands
+            if content.startswith("/"):
+                parts = content[1:].split(maxsplit=1)
+                if parts:
+                    command = parts[0]
+                    args = parts[1] if len(parts) > 1 else ""
+                    self.post_message(self.CommandDetected(command, args))
+        
+        def on_key(self, event: events.Key) -> None:
+            """Handle key events."""
+            # Submit on Enter (single line mode) or Ctrl+Enter
+            if event.key == "enter" and not self._multiline:
+                event.prevent_default()
+                self.action_submit()
+            elif event.key == "ctrl+enter":
+                event.prevent_default()
+                self.action_submit()
+        
+        def action_submit(self) -> None:
+            """Submit the current input."""
+            if self._is_processing:
+                return
+            
+            text_area = self.query_one("#composer-input", TextArea)
+            content = text_area.text.strip()
+            
+            if not content:
+                return
+            
+            # Add to history
+            if content and (not self._history or self._history[-1] != content):
+                self._history.append(content)
+            self._history_index = -1
+            
+            # Check if it's a command
+            is_command = content.startswith("/")
+            
+            # Clear input
+            text_area.clear()
+            
+            # Emit event
+            self.post_message(self.Submitted(content, is_command))
+        
+        def action_cancel(self) -> None:
+            """Cancel current input."""
+            text_area = self.query_one("#composer-input", TextArea)
+            text_area.clear()
+            self._history_index = -1
+        
+        def action_history_prev(self) -> None:
+            """Navigate to previous history item."""
+            if not self._history:
+                return
+            
+            text_area = self.query_one("#composer-input", TextArea)
+            
+            if self._history_index == -1:
+                self._current_input = text_area.text
+                self._history_index = len(self._history) - 1
+            elif self._history_index > 0:
+                self._history_index -= 1
+            
+            text_area.clear()
+            text_area.insert(self._history[self._history_index])
+        
+        def action_history_next(self) -> None:
+            """Navigate to next history item."""
+            if self._history_index == -1:
+                return
+            
+            text_area = self.query_one("#composer-input", TextArea)
+            
+            if self._history_index < len(self._history) - 1:
+                self._history_index += 1
+                text_area.clear()
+                text_area.insert(self._history[self._history_index])
+            else:
+                self._history_index = -1
+                text_area.clear()
+                text_area.insert(self._current_input)
+        
+        def set_processing(self, processing: bool) -> None:
+            """Set processing state."""
+            self._is_processing = processing
+            text_area = self.query_one("#composer-input", TextArea)
+            text_area.disabled = processing
+        
+        @property
+        def text(self) -> str:
+            """Get current text."""
+            text_area = self.query_one("#composer-input", TextArea)
+            return text_area.text
+        
+        @text.setter
+        def text(self, value: str) -> None:
+            """Set current text."""
+            text_area = self.query_one("#composer-input", TextArea)
+            text_area.clear()
+            text_area.insert(value)
+        
+        def focus_input(self) -> None:
+            """Focus the input area."""
+            text_area = self.query_one("#composer-input", TextArea)
+            text_area.focus()
+
+else:
+    class ComposerWidget:
+        """Placeholder when Textual is not available."""
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "Textual is required for TUI. Install with: pip install praisonai[tui]"
+            )