minion-code 0.1.0__py3-none-any.whl

minion_code/components/Message.py

@@ -0,0 +1,304 @@
+"""
+Message Component - Python equivalent of React Message component
+Handles rendering of user and assistant messages with different content types
+"""
+
+from textual.containers import Container, Vertical, Horizontal
+from textual.widgets import Static, RichLog
+from textual.reactive import reactive
+from rich.text import Text
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.syntax import Syntax
+from typing import List, Dict, Any, Optional, Set
+import json
+import logging
+
+# Import shared types
+from ..types import Message as MessageType, MessageContent, InputMode
+
+logger = logging.getLogger(__name__)
+
+
+class Message(Container):
+    """
+    Main message component equivalent to React Message
+    Handles rendering of both user and assistant messages
+    """
+    
+    DEFAULT_CSS = """
+    Message {
+        width: 80%;
+        height: auto;
+        margin-bottom: 1;
+    }
+    
+    .user-message {
+        border-left: thick blue;
+        padding-left: 1;
+        height: auto;
+    }
+    
+    .assistant-message {
+        border-left: thick green;
+        padding-left: 1;
+        height: auto;
+    }
+    
+    .tool-use-message {
+        border-left: thick yellow;
+        padding-left: 1;
+        background: $surface-lighten-1;
+        height: auto;
+    }
+    
+    .error-message {
+        border-left: thick red;
+        padding-left: 1;
+        background: $error 10%;
+        height: auto;
+    }
+    
+    .message-content {
+        width: 100%;
+        height: auto;
+        padding: 1;
+    }
+    
+    .message-meta {
+        color: $text-muted;
+        text-style: dim;
+        height: 1;
+    }
+    """
+    
+    def __init__(self,
+                 message: MessageType,
+                 messages: List[MessageType] = None,
+                 add_margin: bool = True,
+                 tools: List[Any] = None,
+                 verbose: bool = False,
+                 debug: bool = False,
+                 errored_tool_use_ids: Set[str] = None,
+                 in_progress_tool_use_ids: Set[str] = None,
+                 unresolved_tool_use_ids: Set[str] = None,
+                 should_animate: bool = False,
+                 should_show_dot: bool = False,
+                 width: Optional[int] = None,
+                 **kwargs):
+        super().__init__(**kwargs)
+        
+        self.message = message
+        self.messages = messages or []
+        self.add_margin = add_margin
+        self.tools = tools or []
+        self.verbose = verbose
+        self.debug = debug
+        self.errored_tool_use_ids = errored_tool_use_ids or set()
+        self.in_progress_tool_use_ids = in_progress_tool_use_ids or set()
+        self.unresolved_tool_use_ids = unresolved_tool_use_ids or set()
+        self.should_animate = should_animate
+        self.should_show_dot = should_show_dot
+        self.width = width
+    
+    def compose(self):
+        """Compose the message interface"""
+        if self.message.type.value == "assistant":
+            yield from self._render_assistant_message()
+        else:
+            yield from self._render_user_message()
+    
+    def _render_user_message(self):
+        """Render user message - equivalent to UserMessage component"""
+        with Vertical(classes="user-message"):
+            # Message metadata
+            if self.verbose or self.debug:
+                yield Static(
+                    f"User • {self._format_timestamp()}",
+                    classes="message-meta"
+                )
+            
+            # Message content
+            content = self.message.message.content
+            if isinstance(content, str):
+                yield from self._render_text_content(content)
+            elif isinstance(content, list):
+                for item in content:
+                    yield from self._render_content_block(item)
+    
+    def _render_assistant_message(self):
+        """Render assistant message - equivalent to AssistantMessage component"""
+        with Vertical(classes="assistant-message"):
+            # Message metadata
+            if self.verbose or self.debug:
+                meta_text = f"Assistant • {self._format_timestamp()}"
+                if hasattr(self.message, 'cost_usd') and self.message.cost_usd:
+                    meta_text += f" • ${self.message.cost_usd:.4f}"
+                if hasattr(self.message, 'duration_ms') and self.message.duration_ms:
+                    meta_text += f" • {self.message.duration_ms}ms"
+                
+                yield Static(meta_text, classes="message-meta")
+            
+            # Message content
+            content = self.message.message.content
+            if isinstance(content, str):
+                yield from self._render_text_content(content)
+            elif isinstance(content, list):
+                for item in content:
+                    yield from self._render_content_block(item)
+    
+    def _render_content_block(self, block: Dict[str, Any]):
+        """Render individual content blocks based on type"""
+        block_type = block.get('type', 'text')
+        
+        if block_type == 'text':
+            yield from self._render_text_content(block.get('text', ''))
+        elif block_type == 'tool_use':
+            yield from self._render_tool_use_block(block)
+        elif block_type == 'tool_result':
+            yield from self._render_tool_result_block(block)
+        elif block_type == 'thinking':
+            yield from self._render_thinking_block(block)
+        elif block_type == 'redacted_thinking':
+            yield from self._render_redacted_thinking_block()
+        else:
+            # Unknown block type
+            yield Static(f"[Unknown content type: {block_type}]", classes="error-message")
+    
+    def _render_text_content(self, text: str):
+        """Render text content with markdown support"""
+        if not text.strip():
+            return
+        
+        try:
+            # For now, just render as plain text to avoid compose-time issues
+            # TODO: Implement proper markdown rendering with RichLog after mount
+            yield Static(text, classes="message-content")
+        except Exception as e:
+            logger.warning(f"Error rendering text: {e}")
+            yield Static(text, classes="message-content")
+    
+    def _render_tool_use_block(self, block: Dict[str, Any]):
+        """Render tool use block - equivalent to AssistantToolUseMessage"""
+        tool_name = block.get('name', 'unknown')
+        tool_id = block.get('id', '')
+        parameters = block.get('input', {})
+        
+        # Determine status
+        status = "completed"
+        if tool_id in self.in_progress_tool_use_ids:
+            status = "in_progress"
+        elif tool_id in self.errored_tool_use_ids:
+            status = "error"
+        elif tool_id in self.unresolved_tool_use_ids:
+            status = "unresolved"
+        
+        with Vertical(classes="tool-use-message"):
+            # Tool header
+            status_icon = {
+                "completed": "✅",
+                "in_progress": "⏳",
+                "error": "❌",
+                "unresolved": "⏸️"
+            }.get(status, "🔧")
+            
+            yield Static(
+                f"{status_icon} Tool: {tool_name}",
+                classes="message-meta"
+            )
+            
+            # Tool parameters (if verbose)
+            if self.verbose and parameters:
+                try:
+                    params_json = json.dumps(parameters, indent=2)
+                    # For now, render as plain text to avoid compose-time issues
+                    yield Static(params_json, classes="message-content")
+                except Exception:
+                    yield Static(str(parameters), classes="message-content")
+    
+    def _render_tool_result_block(self, block: Dict[str, Any]):
+        """Render tool result block - equivalent to UserToolResultMessage"""
+        tool_use_id = block.get('tool_use_id', '')
+        content = block.get('content', '')
+        is_error = block.get('is_error', False)
+        
+        classes = "error-message" if is_error else "message-content"
+        
+        with Vertical():
+            # Result header
+            icon = "❌" if is_error else "📤"
+            yield Static(
+                f"{icon} Tool Result",
+                classes="message-meta"
+            )
+            
+            # Result content
+            if isinstance(content, str):
+                yield Static(content, classes=classes)
+            elif isinstance(content, list):
+                for item in content:
+                    if isinstance(item, dict) and item.get('type') == 'text':
+                        yield Static(item.get('text', ''), classes=classes)
+                    else:
+                        yield Static(str(item), classes=classes)
+    
+    def _render_thinking_block(self, block: Dict[str, Any]):
+        """Render thinking block - equivalent to AssistantThinkingMessage"""
+        if not self.debug:
+            return  # Only show in debug mode
+        
+        thinking_content = block.get('content', '')
+        
+        with Vertical():
+            yield Static("🤔 Thinking...", classes="message-meta")
+            yield Static(thinking_content, classes="message-content")
+    
+    def _render_redacted_thinking_block(self):
+        """Render redacted thinking block"""
+        if not self.debug:
+            return
+        
+        yield Static("🤔 [Thinking content redacted]", classes="message-meta")
+    
+    def _format_timestamp(self) -> str:
+        """Format message timestamp"""
+        import datetime
+        dt = datetime.datetime.fromtimestamp(self.message.timestamp)
+        return dt.strftime("%H:%M:%S")
+
+
+class UserMessage(Message):
+    """Specialized component for user messages"""
+    
+    def __init__(self, message: MessageType, **kwargs):
+        super().__init__(message, **kwargs)
+    
+    def compose(self):
+        """Compose user message with specific styling"""
+        yield from self._render_user_message()
+
+
+class AssistantMessage(Message):
+    """Specialized component for assistant messages"""
+    
+    def __init__(self, message: MessageType, **kwargs):
+        super().__init__(message, **kwargs)
+    
+    def compose(self):
+        """Compose assistant message with specific styling"""
+        yield from self._render_assistant_message()
+
+
+class ToolUseMessage(Message):
+    """Specialized component for tool use messages"""
+    
+    def __init__(self, message: MessageType, **kwargs):
+        super().__init__(message, **kwargs)
+    
+    def compose(self):
+        """Compose tool use message with specific styling"""
+        content = self.message.message.content
+        if isinstance(content, list):
+            for item in content:
+                if item.get('type') == 'tool_use':
+                    yield from self._render_tool_use_block(item)

minion_code/components/MessageResponse.py

@@ -0,0 +1,188 @@
+"""
+MessageResponse Component - Python equivalent of React MessageResponse component
+Provides visual indentation for tool execution progress messages
+"""
+
+from textual.containers import Container, Horizontal
+from textual.widgets import Static
+from textual.widget import Widget
+from rich.text import Text
+from typing import Any, Optional, List, Union
+
+
+class MessageResponse(Container):
+    """
+    MessageResponse component equivalent to React MessageResponse
+    Provides visual indentation with "⎿" indicator for children widgets
+    
+    Usage:
+        # With direct content
+        response = MessageResponse(content="Operation completed")
+        
+        # With child widgets (like React children)
+        response = MessageResponse()
+        response.mount(Message(...))  # Mount child widgets
+        
+        # Or pass children during initialization
+        response = MessageResponse(children=[message_widget, status_widget])
+    """
+    
+    DEFAULT_CSS = """
+    MessageResponse {
+        height: auto;
+        width: 100%;
+    }
+    
+    .message-response-container {
+        height: auto;
+        width: 100%;
+        margin: 0;
+        padding: 0;
+        layers: first second;
+    }
+    
+    .response-indicator {
+        height: 1;
+        width: auto;
+        color: $text-muted;
+        text-style: dim;
+        margin: 0;
+        padding: 0;
+    }
+    
+    .response-content {
+        width: 100%;
+        height: auto;
+        margin-left: 4;
+        margin-top: 0;
+        margin-bottom: 0;
+        padding: 0;
+    }
+    
+    .response-content > * {
+        margin: 0;
+        padding: 0;
+        height: auto;
+    }
+    
+    /* 移除Vertical容器的默认间距 */
+    .response-content Vertical {
+        margin: 0;
+        padding: 0;
+    }
+    """
+    
+    def __init__(self, 
+                 children: Optional[Union[Widget, List[Widget]]] = None,
+                 content: Optional[str] = None,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.children_widgets = []
+        self.content = content
+        
+        # Handle children parameter
+        if children:
+            if isinstance(children, list):
+                self.children_widgets = children
+            else:
+                self.children_widgets = [children]
+    
+    def compose(self):
+        """Compose the MessageResponse interface"""
+        from textual.containers import Vertical
+        
+        # 使用Vertical多层布局
+        with Horizontal(classes="message-response-container"):
+            #yield (Static("  ⎿", classes="response-indicator"))
+            if self.children_widgets:
+
+                for child in self.children_widgets:
+                    yield child
+
+
+    # def on_mount(self):
+    #     print("mounting")
+    #     pass
+    def mount_child(self, widget: Widget):
+        """
+        Mount a child widget to the content area
+        Equivalent to React's children mounting
+        """
+        content_area = self.query_one("#content-area", Container)
+        content_area.mount(widget)
+    
+    def mount_children(self, widgets: List[Widget]):
+        """Mount multiple child widgets"""
+        for widget in widgets:
+            self.mount_child(widget)
+    
+    def clear_children(self):
+        """Clear all child widgets from content area"""
+        content_area = self.query_one("#content-area", Container)
+        for child in list(content_area.children):
+            child.remove()
+
+
+class MessageResponseText(MessageResponse):
+    """Specialized MessageResponse for text content"""
+    
+    def __init__(self, text: str, **kwargs):
+        super().__init__(content=text, **kwargs)
+
+
+class MessageResponseStatus(MessageResponse):
+    """Specialized MessageResponse for status messages"""
+    
+    def __init__(self, status: str, message: str = "", **kwargs):
+        status_icons = {
+            "loading": "⏳",
+            "success": "✅", 
+            "error": "❌",
+            "warning": "⚠️",
+            "info": "ℹ️",
+            "thinking": "🤔"
+        }
+        
+        icon = status_icons.get(status, "•")
+        content = f"{icon} {message}" if message else icon
+        
+        super().__init__(content=content, **kwargs)
+
+
+class MessageResponseProgress(MessageResponse):
+    """Specialized MessageResponse for progress indicators"""
+    
+    def __init__(self, current: int, total: int, message: str = "", **kwargs):
+        progress_text = f"[{current}/{total}]"
+        if message:
+            progress_text += f" {message}"
+        
+        super().__init__(content=progress_text, **kwargs)
+
+
+class MessageResponseTyping(MessageResponse):
+    """Specialized MessageResponse for typing indicators"""
+    
+    def __init__(self, **kwargs):
+        super().__init__(content="typing...", **kwargs)
+        
+    def on_mount(self):
+        """Start typing animation when mounted"""
+        self._animate_typing()
+    
+    def _animate_typing(self):
+        """Simple typing animation"""
+        # This could be enhanced with actual animation
+        # For now, just show static typing indicator
+        pass
+
+
+class MessageResponseWithChildren(MessageResponse):
+    """
+    Specialized MessageResponse that demonstrates children usage
+    Equivalent to React's <MessageResponse><Message /></MessageResponse>
+    """
+    
+    def __init__(self, message_widget: Widget, **kwargs):
+        # Pass the message widget as a child
+        super().__init__(children=[message_widget], **kwargs)