codepp 0.0.437__py3-none-any.whl

code_puppy/messaging/queue_console.py

@@ -0,0 +1,271 @@
+"""
+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=True to properly process rich styling
+                    # Use a reasonable width to prevent wrapping issues
+                    temp_console = Console(
+                        file=string_io, width=80, legacy_windows=False, markup=True
+                    )
+                    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)
+
+        # 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.INFO, 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)
+
+    # 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())

code_puppy/messaging/renderers.py

@@ -0,0 +1,311 @@
+"""
+Renderer implementations for different UI modes.
+
+These renderers consume messages from the queue and display them
+appropriately for their respective interfaces.
+"""
+
+import asyncio
+import threading
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.markup import escape as escape_rich_markup
+
+from .message_queue import MessageQueue, MessageType, UIMessage
+
+
+class MessageRenderer(ABC):
+    """Base class for message renderers."""
+
+    def __init__(self, queue: MessageQueue):
+        self.queue = queue
+        self._running = False
+        self._task = None
+
+    @abstractmethod
+    async def render_message(self, message: UIMessage):
+        """Render a single message."""
+        pass
+
+    async def start(self):
+        """Start the renderer."""
+        if self._running:
+            return
+
+        self._running = True
+        # Mark the queue as having an active renderer
+        self.queue.mark_renderer_active()
+        self._task = asyncio.create_task(self._consume_messages())
+
+    async def stop(self):
+        """Stop the renderer."""
+        self._running = False
+        # Mark the queue as having no active renderer
+        self.queue.mark_renderer_inactive()
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+
+    async def _consume_messages(self):
+        """Consume messages from the queue."""
+        while self._running:
+            try:
+                message = await asyncio.wait_for(self.queue.get_async(), timeout=0.1)
+                await self.render_message(message)
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                # Log error but continue processing
+                # Note: Using sys.stderr - can't use messaging in renderer
+                import sys
+
+                sys.stderr.write(f"Error rendering message: {e}\n")
+
+
+class InteractiveRenderer(MessageRenderer):
+    """Renderer for interactive CLI mode using Rich console.
+
+    Note: This async-based renderer is not currently used in the codebase.
+    Interactive mode currently uses SynchronousInteractiveRenderer instead.
+    A future refactoring might consolidate these renderers.
+    """
+
+    def __init__(self, queue: MessageQueue, console: Optional[Console] = None):
+        super().__init__(queue)
+        self.console = console or Console()
+
+    async def render_message(self, message: UIMessage):
+        """Render a message using Rich console."""
+        # Handle human input requests
+        if message.type == MessageType.HUMAN_INPUT_REQUEST:
+            await self._handle_human_input_request(message)
+            return
+
+        # Convert message type to appropriate Rich styling
+        if message.type == MessageType.ERROR:
+            style = "bold red"
+        elif message.type == MessageType.WARNING:
+            style = "yellow"
+        elif message.type == MessageType.SUCCESS:
+            style = "green"
+        elif message.type == MessageType.TOOL_OUTPUT:
+            style = "blue"
+        elif message.type == MessageType.AGENT_REASONING:
+            style = None
+        elif message.type == MessageType.PLANNED_NEXT_STEPS:
+            style = None
+        elif message.type == MessageType.AGENT_RESPONSE:
+            # Special handling for agent responses - they'll be rendered as markdown
+            style = None
+        elif message.type == MessageType.SYSTEM:
+            style = "dim"
+        else:
+            style = None
+
+        # Make version messages dim regardless of message type
+        if isinstance(message.content, str):
+            if (
+                "Current version:" in message.content
+                or "Latest version:" in message.content
+            ):
+                style = "dim"
+
+        # Render the content
+        if isinstance(message.content, str):
+            if message.type == MessageType.AGENT_RESPONSE:
+                # Render agent responses as markdown
+                try:
+                    markdown = Markdown(message.content)
+                    self.console.print(markdown)
+                except Exception:
+                    # Fallback to plain text if markdown parsing fails
+                    safe_content = escape_rich_markup(message.content)
+                    self.console.print(safe_content)
+            elif style:
+                # Escape Rich markup to prevent crashes from malformed tags
+                safe_content = escape_rich_markup(message.content)
+                self.console.print(safe_content, style=style)
+            else:
+                safe_content = escape_rich_markup(message.content)
+                self.console.print(safe_content)
+        else:
+            # For complex Rich objects (Tables, Markdown, Text, etc.)
+            self.console.print(message.content)
+
+        # Ensure output is immediately flushed to the terminal
+        # This fixes the issue where messages don't appear until user input
+        if hasattr(self.console.file, "flush"):
+            self.console.file.flush()
+
+    async def _handle_human_input_request(self, message: UIMessage):
+        """Handle a human input request in async mode."""
+        # This renderer is not currently used in practice, but if it were:
+        # We would need async input handling here
+        # For now, just render as a system message
+        safe_content = escape_rich_markup(str(message.content))
+        self.console.print(f"[bold cyan]INPUT REQUESTED:[/bold cyan] {safe_content}")
+        if hasattr(self.console.file, "flush"):
+            self.console.file.flush()
+
+
+class SynchronousInteractiveRenderer:
+    """
+    Synchronous renderer for interactive mode that doesn't require async.
+
+    This is useful for cases where we want immediate rendering without
+    the overhead of async message processing.
+
+    Note: As part of the messaging system refactoring, we're keeping this class for now
+    as it's essential for the interactive mode to function properly. Future refactoring
+    could replace this with a simpler implementation that leverages the unified message
+    queue system more effectively, or potentially convert interactive mode to use
+    async/await consistently and use InteractiveRenderer instead.
+
+    Current responsibilities:
+    - Consumes messages from the queue in a background thread
+    - Renders messages to the console in real-time without requiring async code
+    - Registers as a direct listener to the message queue for immediate processing
+    """
+
+    def __init__(self, queue: MessageQueue, console: Optional[Console] = None):
+        self.queue = queue
+        self.console = console or Console()
+        self._running = False
+        self._thread = None
+
+    def start(self):
+        """Start the synchronous renderer in a background thread."""
+        if self._running:
+            return
+
+        self._running = True
+        # Mark the queue as having an active renderer
+        self.queue.mark_renderer_active()
+        # Add ourselves as a listener for immediate processing
+        self.queue.add_listener(self._render_message)
+        self._thread = threading.Thread(target=self._consume_messages, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        """Stop the synchronous renderer."""
+        self._running = False
+        # Mark the queue as having no active renderer
+        self.queue.mark_renderer_inactive()
+        # Remove ourselves as a listener
+        self.queue.remove_listener(self._render_message)
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=1.0)
+
+    def _consume_messages(self):
+        """Consume messages synchronously."""
+        while self._running:
+            message = self.queue.get_nowait()
+            if message:
+                self._render_message(message)
+            else:
+                # No messages, sleep briefly
+                import time
+
+                time.sleep(0.01)
+
+    def _render_message(self, message: UIMessage):
+        """Render a message using Rich console."""
+        # Handle human input requests
+        if message.type == MessageType.HUMAN_INPUT_REQUEST:
+            self._handle_human_input_request(message)
+            return
+
+        # Convert message type to appropriate Rich styling
+        if message.type == MessageType.ERROR:
+            style = "bold red"
+        elif message.type == MessageType.WARNING:
+            style = "yellow"
+        elif message.type == MessageType.SUCCESS:
+            style = "green"
+        elif message.type == MessageType.TOOL_OUTPUT:
+            style = "blue"
+        elif message.type == MessageType.AGENT_REASONING:
+            style = None
+        elif message.type == MessageType.AGENT_RESPONSE:
+            # Special handling for agent responses - they'll be rendered as markdown
+            style = None
+        elif message.type == MessageType.SYSTEM:
+            style = "dim"
+        else:
+            style = None
+
+        # Make version messages dim regardless of message type
+        if isinstance(message.content, str):
+            if (
+                "Current version:" in message.content
+                or "Latest version:" in message.content
+            ):
+                style = "dim"
+
+        # Render the content
+        if isinstance(message.content, str):
+            if message.type == MessageType.AGENT_RESPONSE:
+                # Render agent responses as markdown
+                try:
+                    markdown = Markdown(message.content)
+                    self.console.print(markdown)
+                except Exception:
+                    # Fallback to plain text if markdown parsing fails
+                    safe_content = escape_rich_markup(message.content)
+                    self.console.print(safe_content)
+            elif style:
+                # Escape Rich markup to prevent crashes from malformed tags
+                # in shell output or other user-provided content
+                safe_content = escape_rich_markup(message.content)
+                self.console.print(safe_content, style=style)
+            else:
+                safe_content = escape_rich_markup(message.content)
+                self.console.print(safe_content)
+        else:
+            # For complex Rich objects (Tables, Markdown, Text, etc.)
+            self.console.print(message.content)
+
+        # Ensure output is immediately flushed to the terminal
+        # This fixes the issue where messages don't appear until user input
+        if hasattr(self.console.file, "flush"):
+            self.console.file.flush()
+
+    def _handle_human_input_request(self, message: UIMessage):
+        """Handle a human input request in interactive mode."""
+        prompt_id = message.metadata.get("prompt_id") if message.metadata else None
+        if not prompt_id:
+            self.console.print(
+                "[bold red]Error: Invalid human input request[/bold red]"
+            )
+            return
+
+        # Display the prompt - escape to prevent markup injection
+        safe_content = escape_rich_markup(str(message.content))
+        self.console.print(f"[bold cyan]{safe_content}[/bold cyan]")
+        if hasattr(self.console.file, "flush"):
+            self.console.file.flush()
+
+        # Get user input
+        try:
+            # Use basic input for now - could be enhanced with prompt_toolkit later
+            response = input(">>> ")
+
+            # Provide the response back to the queue
+            from .message_queue import provide_prompt_response
+
+            provide_prompt_response(prompt_id, response)
+
+        except (EOFError, KeyboardInterrupt):
+            # Handle Ctrl+C or Ctrl+D
+            provide_prompt_response(prompt_id, "")
+        except Exception as e:
+            self.console.print(f"[bold red]Error getting input: {e}[/bold red]")
+            provide_prompt_response(prompt_id, "")