code-puppy 0.0.96__py3-none-any.whl → 0.0.118__py3-none-any.whl

code_puppy/messaging/message_queue.py

@@ -0,0 +1,288 @@
+"""
+Message queue system for decoupling Rich console output from renderers.
+
+This allows both TUI and interactive modes to consume the same messages
+but render them differently based on their capabilities.
+"""
+
+import asyncio
+import queue
+import threading
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Dict, Optional, Union
+
+from rich.text import Text
+
+
+class MessageType(Enum):
+    """Types of messages that can be sent through the queue."""
+
+    # Basic content types
+    INFO = "info"
+    SUCCESS = "success"
+    WARNING = "warning"
+    ERROR = "error"
+    DIVIDER = "divider"
+
+    # Tool-specific types
+    TOOL_OUTPUT = "tool_output"
+    COMMAND_OUTPUT = "command_output"
+    FILE_OPERATION = "file_operation"
+
+    # Agent-specific types
+    AGENT_REASONING = "agent_reasoning"
+    PLANNED_NEXT_STEPS = "planned_next_steps"
+    AGENT_RESPONSE = "agent_response"
+    AGENT_STATUS = "agent_status"
+
+    # System types
+    SYSTEM = "system"
+    DEBUG = "debug"
+
+
+@dataclass
+class UIMessage:
+    """A message to be displayed in the UI."""
+
+    type: MessageType
+    content: Union[str, Text, Any]  # Can be Rich Text, Table, Markdown, etc.
+    timestamp: datetime = None
+    metadata: Dict[str, Any] = None
+
+    def __post_init__(self):
+        if self.timestamp is None:
+            self.timestamp = datetime.now(timezone.utc)
+        if self.metadata is None:
+            self.metadata = {}
+
+
+class MessageQueue:
+    """Thread-safe message queue for UI messages."""
+
+    def __init__(self, maxsize: int = 1000):
+        self._queue = queue.Queue(maxsize=maxsize)
+        self._async_queue = None  # Will be created when needed
+        self._async_queue_maxsize = maxsize
+        self._listeners = []
+        self._running = False
+        self._thread = None
+        self._startup_buffer = []  # Buffer messages before any renderer starts
+        self._has_active_renderer = False
+        self._event_loop = None  # Store reference to the event loop
+
+    def start(self):
+        """Start the queue processing."""
+        if self._running:
+            return
+
+        self._running = True
+        self._thread = threading.Thread(target=self._process_messages, daemon=True)
+        self._thread.start()
+
+    def get_buffered_messages(self):
+        """Get all currently buffered messages without waiting."""
+        # First get any startup buffered messages
+        messages = list(self._startup_buffer)
+
+        # Then get any queued messages
+        while True:
+            try:
+                message = self._queue.get_nowait()
+                messages.append(message)
+            except queue.Empty:
+                break
+        return messages
+
+    def clear_startup_buffer(self):
+        """Clear the startup buffer after processing."""
+        self._startup_buffer.clear()
+
+    def stop(self):
+        """Stop the queue processing."""
+        self._running = False
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=1.0)
+
+    def emit(self, message: UIMessage):
+        """Emit a message to the queue."""
+        # If no renderer is active yet, buffer the message for startup
+        if not self._has_active_renderer:
+            self._startup_buffer.append(message)
+            return
+
+        try:
+            self._queue.put_nowait(message)
+        except queue.Full:
+            # Drop oldest message to make room
+            try:
+                self._queue.get_nowait()
+                self._queue.put_nowait(message)
+            except queue.Empty:
+                pass
+
+    def emit_simple(self, message_type: MessageType, content: Any, **metadata):
+        """Emit a simple message with just type and content."""
+        msg = UIMessage(type=message_type, content=content, metadata=metadata)
+        self.emit(msg)
+
+    def get_nowait(self) -> Optional[UIMessage]:
+        """Get a message without blocking."""
+        try:
+            return self._queue.get_nowait()
+        except queue.Empty:
+            return None
+
+    async def get_async(self) -> UIMessage:
+        """Get a message asynchronously."""
+        # Lazy initialization of async queue and store event loop reference
+        if self._async_queue is None:
+            self._async_queue = asyncio.Queue(maxsize=self._async_queue_maxsize)
+            self._event_loop = asyncio.get_running_loop()
+        return await self._async_queue.get()
+
+    def _process_messages(self):
+        """Process messages from sync to async queue."""
+        while self._running:
+            try:
+                message = self._queue.get(timeout=0.1)
+
+                # Try to put in async queue if we have an event loop reference
+                if self._event_loop is not None and self._async_queue is not None:
+                    # Use thread-safe call to put message in async queue
+                    # Create a bound method to avoid closure issues
+                    try:
+                        self._event_loop.call_soon_threadsafe(
+                            self._async_queue.put_nowait, message
+                        )
+                    except Exception:
+                        # Handle any errors with the async queue operation
+                        pass
+
+                # Notify listeners immediately for sync processing
+                for listener in self._listeners:
+                    try:
+                        listener(message)
+                    except Exception:
+                        pass  # Don't let listener errors break processing
+
+            except queue.Empty:
+                continue
+
+    def add_listener(self, callback):
+        """Add a listener for messages (for direct sync consumption)."""
+        self._listeners.append(callback)
+        # Mark that we have an active renderer
+        self._has_active_renderer = True
+
+    def remove_listener(self, callback):
+        """Remove a listener."""
+        if callback in self._listeners:
+            self._listeners.remove(callback)
+        # If no more listeners, mark as no active renderer
+        if not self._listeners:
+            self._has_active_renderer = False
+
+    def mark_renderer_active(self):
+        """Mark that a renderer is now active and consuming messages."""
+        self._has_active_renderer = True
+
+    def mark_renderer_inactive(self):
+        """Mark that no renderer is currently active."""
+        self._has_active_renderer = False
+
+
+# Global message queue instance
+_global_queue: Optional[MessageQueue] = None
+_queue_lock = threading.Lock()
+
+
+def get_global_queue() -> MessageQueue:
+    """Get or create the global message queue."""
+    global _global_queue
+
+    with _queue_lock:
+        if _global_queue is None:
+            _global_queue = MessageQueue()
+            _global_queue.start()
+
+    return _global_queue
+
+
+def get_buffered_startup_messages():
+    """Get any messages that were buffered before renderers started."""
+    queue = get_global_queue()
+    # Only return startup buffer messages, don't clear them yet
+    messages = list(queue._startup_buffer)
+    return messages
+
+
+def emit_message(message_type: MessageType, content: Any, **metadata):
+    """Convenience function to emit a message to the global queue."""
+    queue = get_global_queue()
+    queue.emit_simple(message_type, content, **metadata)
+
+
+def emit_info(content: Any, **metadata):
+    """Emit an info message."""
+    emit_message(MessageType.INFO, content, **metadata)
+
+
+def emit_success(content: Any, **metadata):
+    """Emit a success message."""
+    emit_message(MessageType.SUCCESS, content, **metadata)
+
+
+def emit_warning(content: Any, **metadata):
+    """Emit a warning message."""
+    emit_message(MessageType.WARNING, content, **metadata)
+
+
+def emit_error(content: Any, **metadata):
+    """Emit an error message."""
+    emit_message(MessageType.ERROR, content, **metadata)
+
+
+def emit_tool_output(content: Any, tool_name: str = None, **metadata):
+    """Emit tool output."""
+    if tool_name:
+        metadata["tool_name"] = tool_name
+    emit_message(MessageType.TOOL_OUTPUT, content, **metadata)
+
+
+def emit_command_output(content: Any, command: str = None, **metadata):
+    """Emit command output."""
+    if command:
+        metadata["command"] = command
+    emit_message(MessageType.COMMAND_OUTPUT, content, **metadata)
+
+
+def emit_agent_reasoning(content: Any, **metadata):
+    """Emit agent reasoning."""
+    emit_message(MessageType.AGENT_REASONING, content, **metadata)
+
+
+def emit_planned_next_steps(content: Any, **metadata):
+    """Emit planned_next_steps"""
+    emit_message(MessageType.PLANNED_NEXT_STEPS, content, **metadata)
+
+
+def emit_agent_response(content: Any, **metadata):
+    """Emit agent_response"""
+    emit_message(MessageType.AGENT_RESPONSE, content, **metadata)
+
+
+def emit_system_message(content: Any, **metadata):
+    """Emit a system message."""
+    emit_message(MessageType.SYSTEM, content, **metadata)
+
+
+def emit_divider(content: str = "[dim]" + "─" * 100 + "\n" + "[/dim]", **metadata):
+    """Emit a divider line"""
+    from code_puppy.state_management import is_tui_mode
+
+    if not is_tui_mode():
+        emit_message(MessageType.DIVIDER, content, **metadata)
+    else:
+        pass

code_puppy/messaging/queue_console.py

@@ -0,0 +1,293 @@
+"""
+Queue-based console that mimics Rich Console but sends messages to a queue.
+
+This allows tools to use the same Rich console interface while having
+their output captured and routed through our message queue system.
+"""
+
+import traceback
+from typing import Any, Optional
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.text import Text
+
+from .message_queue import MessageQueue, MessageType, get_global_queue
+
+
+class QueueConsole:
+    """
+    Console-like interface that sends messages to a queue instead of stdout.
+
+    This is designed to be a drop-in replacement for Rich Console that
+    routes messages through our queue system.
+    """
+
+    def __init__(
+        self,
+        queue: Optional[MessageQueue] = None,
+        fallback_console: Optional[Console] = None,
+    ):
+        self.queue = queue or get_global_queue()
+        self.fallback_console = fallback_console or Console()
+
+    def print(
+        self,
+        *values: Any,
+        sep: str = " ",
+        end: str = "\n",
+        style: Optional[str] = None,
+        highlight: bool = True,
+        **kwargs,
+    ):
+        """Print values to the message queue."""
+        # Handle Rich objects properly
+        if len(values) == 1 and hasattr(values[0], "__rich_console__"):
+            # Single Rich object - pass it through directly
+            content = values[0]
+            message_type = self._infer_message_type_from_rich_object(content, style)
+        else:
+            # Convert to string, but handle Rich objects properly
+            processed_values = []
+            for v in values:
+                if hasattr(v, "__rich_console__"):
+                    # For Rich objects, try to extract their text content
+                    from io import StringIO
+
+                    from rich.console import Console
+
+                    string_io = StringIO()
+                    # Use markup=False to prevent interpretation of square brackets as markup
+                    temp_console = Console(
+                        file=string_io, width=80, legacy_windows=False, markup=False
+                    )
+                    temp_console.print(v)
+                    processed_values.append(string_io.getvalue().rstrip("\n"))
+                else:
+                    processed_values.append(str(v))
+
+            content = sep.join(processed_values) + end
+            message_type = self._infer_message_type(content, style)
+
+        # Create Rich Text object if style is provided and content is string
+        if style and isinstance(content, str):
+            content = Text(content, style=style)
+
+        # Emit to queue
+        self.queue.emit_simple(
+            message_type, content, style=style, highlight=highlight, **kwargs
+        )
+
+    def print_exception(
+        self,
+        *,
+        width: Optional[int] = None,
+        extra_lines: int = 3,
+        theme: Optional[str] = None,
+        word_wrap: bool = False,
+        show_locals: bool = False,
+        indent_guides: bool = True,
+        suppress: tuple = (),
+        max_frames: int = 100,
+    ):
+        """Print exception information to the queue."""
+        # Get the exception traceback
+        exc_text = traceback.format_exc()
+
+        # Emit as error message
+        self.queue.emit_simple(
+            MessageType.ERROR,
+            f"Exception:\n{exc_text}",
+            exception=True,
+            show_locals=show_locals,
+        )
+
+    def log(
+        self,
+        *values: Any,
+        sep: str = " ",
+        end: str = "\n",
+        style: Optional[str] = None,
+        justify: Optional[str] = None,
+        emoji: Optional[bool] = None,
+        markup: Optional[bool] = None,
+        highlight: Optional[bool] = None,
+        log_locals: bool = False,
+    ):
+        """Log a message (similar to print but with logging semantics)."""
+        content = sep.join(str(v) for v in values) + end
+
+        # Log messages are typically informational
+        message_type = MessageType.INFO
+        if style:
+            message_type = self._infer_message_type(content, style)
+
+        if style and isinstance(content, str):
+            content = Text(content, style=style)
+
+        self.queue.emit_simple(
+            message_type, content, log=True, style=style, log_locals=log_locals
+        )
+
+    def _infer_message_type_from_rich_object(
+        self, content: Any, style: Optional[str] = None
+    ) -> MessageType:
+        """Infer message type from Rich object type and style."""
+        if style:
+            style_lower = style.lower()
+            if "red" in style_lower or "error" in style_lower:
+                return MessageType.ERROR
+            elif "yellow" in style_lower or "warning" in style_lower:
+                return MessageType.WARNING
+            elif "green" in style_lower or "success" in style_lower:
+                return MessageType.SUCCESS
+            elif "blue" in style_lower:
+                return MessageType.INFO
+            elif "purple" in style_lower or "magenta" in style_lower:
+                return MessageType.AGENT_REASONING
+            elif "dim" in style_lower:
+                return MessageType.SYSTEM
+
+        # Infer from object type
+        if isinstance(content, Markdown):
+            return MessageType.AGENT_REASONING
+        elif isinstance(content, Table):
+            return MessageType.TOOL_OUTPUT
+        elif hasattr(content, "lexer_name"):  # Syntax object
+            return MessageType.TOOL_OUTPUT
+
+        return MessageType.INFO
+
+    def _infer_message_type(
+        self, content: str, style: Optional[str] = None
+    ) -> MessageType:
+        """Infer message type from content and style."""
+        if style:
+            style_lower = style.lower()
+            if "red" in style_lower or "error" in style_lower:
+                return MessageType.ERROR
+            elif "yellow" in style_lower or "warning" in style_lower:
+                return MessageType.WARNING
+            elif "green" in style_lower or "success" in style_lower:
+                return MessageType.SUCCESS
+            elif "blue" in style_lower:
+                return MessageType.INFO
+            elif "purple" in style_lower or "magenta" in style_lower:
+                return MessageType.AGENT_REASONING
+            elif "dim" in style_lower:
+                return MessageType.SYSTEM
+
+        # Infer from content patterns
+        content_lower = content.lower()
+        if any(word in content_lower for word in ["error", "failed", "exception"]):
+            return MessageType.ERROR
+        elif any(word in content_lower for word in ["warning", "warn"]):
+            return MessageType.WARNING
+        elif any(word in content_lower for word in ["success", "completed", "done"]):
+            return MessageType.SUCCESS
+        elif any(word in content_lower for word in ["tool", "command", "running"]):
+            return MessageType.TOOL_OUTPUT
+
+        return MessageType.INFO
+
+    # Additional methods to maintain Rich Console compatibility
+    def rule(self, title: str = "", *, align: str = "center", style: str = "rule.line"):
+        """Print a horizontal rule."""
+        self.queue.emit_simple(
+            MessageType.SYSTEM,
+            f"─── {title} ───" if title else "─" * 40,
+            rule=True,
+            style=style,
+        )
+
+    def status(self, status: str, *, spinner: str = "dots"):
+        """Show a status message (simplified)."""
+        self.queue.emit_simple(
+            MessageType.INFO, f"⏳ {status}", status=True, spinner=spinner
+        )
+
+    def input(self, prompt: str = "") -> str:
+        """Get user input without spinner interference.
+
+        This method coordinates with the TUI to pause any running spinners
+        and properly display the user input prompt.
+        """
+        # Set the global flag that we're awaiting user input
+        from code_puppy.tools.command_runner import set_awaiting_user_input
+
+        set_awaiting_user_input(True)
+
+        # Signal TUI to pause spinner and prepare for user input (legacy method)
+        try:
+            # Try to get the current TUI app instance and pause spinner
+            from textual.app import App
+
+            current_app = App.get_running_app()
+            if hasattr(current_app, "pause_spinner_for_input"):
+                current_app.pause_spinner_for_input()
+        except Exception:
+            # If we can't pause the spinner (not in TUI mode), continue anyway
+            pass
+
+        # Emit the prompt as a system message so it shows in the TUI chat
+        if prompt:
+            self.queue.emit_simple(MessageType.SYSTEM, prompt, requires_user_input=True)
+
+        # Create a new, isolated console instance specifically for input
+        # This bypasses any spinner or queue system interference
+        input_console = Console(file=__import__("sys").stderr, force_terminal=True)
+
+        # Clear any spinner artifacts and position cursor properly
+        if prompt:
+            input_console.print(prompt, end="", style="bold cyan")
+
+        # Use regular input() which will read from stdin
+        # Since we printed the prompt to stderr, this should work cleanly
+        try:
+            user_response = input()
+
+            # Show the user's response in the chat as well
+            if user_response:
+                self.queue.emit_simple(
+                    MessageType.USER, f"User response: {user_response}"
+                )
+
+            return user_response
+        except (KeyboardInterrupt, EOFError):
+            # Handle interruption gracefully
+            input_console.print("\n[yellow]Input cancelled[/yellow]")
+            self.queue.emit_simple(MessageType.WARNING, "User input cancelled")
+            return ""
+        finally:
+            # Clear the global flag for awaiting user input
+            from code_puppy.tools.command_runner import set_awaiting_user_input
+
+            set_awaiting_user_input(False)
+
+            # Signal TUI to resume spinner if needed (legacy method)
+            try:
+                from textual.app import App
+
+                current_app = App.get_running_app()
+                if hasattr(current_app, "resume_spinner_after_input"):
+                    current_app.resume_spinner_after_input()
+            except Exception:
+                # If we can't resume the spinner, continue anyway
+                pass
+
+    # File-like interface for compatibility
+    @property
+    def file(self):
+        """Get the current file (for compatibility)."""
+        return self.fallback_console.file
+
+    @file.setter
+    def file(self, value):
+        """Set the current file (for compatibility)."""
+        self.fallback_console.file = value
+
+
+def get_queue_console(queue: Optional[MessageQueue] = None) -> QueueConsole:
+    """Get a QueueConsole instance."""
+    return QueueConsole(queue or get_global_queue())