code-puppy 0.0.97__py3-none-any.whl → 0.0.119__py3-none-any.whl

code_puppy/messaging/renderers.py

@@ -0,0 +1,305 @@
+"""
+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 io import StringIO
+from typing import Optional
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+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
+                print(f"Error rendering message: {e}")
+
+
+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."""
+        # 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 = None
+        else:
+            style = None
+
+        # 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
+                    self.console.print(message.content)
+            elif style:
+                self.console.print(message.content, style=style)
+            else:
+                self.console.print(message.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()
+
+
+class TUIRenderer(MessageRenderer):
+    """Renderer for TUI mode that adds messages to the chat view."""
+
+    def __init__(self, queue: MessageQueue, tui_app=None):
+        super().__init__(queue)
+        self.tui_app = tui_app
+
+    def set_tui_app(self, app):
+        """Set the TUI app reference."""
+        self.tui_app = app
+
+    async def render_message(self, message: UIMessage):
+        """Render a message in the TUI chat view."""
+        if not self.tui_app:
+            return
+
+        # Extract group_id from message metadata (fixing the key name)
+        group_id = message.metadata.get("message_group") if message.metadata else None
+
+        # For INFO messages with Rich objects (like Markdown), preserve them for proper rendering
+        if message.type == MessageType.INFO and hasattr(
+            message.content, "__rich_console__"
+        ):
+            # Pass the Rich object directly to maintain markdown formatting
+            self.tui_app.add_system_message_rich(
+                message.content, message_group=group_id
+            )
+            return
+
+        # Convert content to string for TUI display (for all other cases)
+        if hasattr(message.content, "__rich_console__"):
+            # For Rich objects, render to plain text using a 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(message.content)
+            content_str = string_io.getvalue().rstrip("\n")
+        else:
+            content_str = str(message.content)
+
+        # Map message types to TUI message types - ALL get group_id now
+        if message.type in (MessageType.ERROR,):
+            self.tui_app.add_error_message(content_str, message_group=group_id)
+        elif message.type in (
+            MessageType.SYSTEM,
+            MessageType.INFO,
+            MessageType.WARNING,
+            MessageType.SUCCESS,
+        ):
+            self.tui_app.add_system_message(content_str, message_group=group_id)
+        elif message.type == MessageType.AGENT_REASONING:
+            # Agent reasoning messages should use the dedicated method
+            self.tui_app.add_agent_reasoning_message(
+                content_str, message_group=group_id
+            )
+        elif message.type == MessageType.PLANNED_NEXT_STEPS:
+            # Agent reasoning messages should use the dedicated method
+            self.tui_app.add_planned_next_steps_message(
+                content_str, message_group=group_id
+            )
+        elif message.type in (
+            MessageType.TOOL_OUTPUT,
+            MessageType.COMMAND_OUTPUT,
+            MessageType.AGENT_RESPONSE,
+        ):
+            # These are typically agent/tool outputs
+            self.tui_app.add_agent_message(content_str, message_group=group_id)
+        else:
+            # Default to system message
+            self.tui_app.add_system_message(content_str, message_group=group_id)
+
+
+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."""
+        # 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 = None
+        else:
+            style = None
+
+        # 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
+                    self.console.print(message.content)
+            elif style:
+                self.console.print(message.content, style=style)
+            else:
+                self.console.print(message.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()

code_puppy/messaging/spinner/__init__.py

@@ -0,0 +1,55 @@
+"""
+Shared spinner implementation for both TUI and CLI modes.
+
+This module provides consistent spinner animations across different UI modes.
+"""
+
+from .console_spinner import ConsoleSpinner
+from .spinner_base import SpinnerBase
+from .textual_spinner import TextualSpinner
+
+# Keep track of all active spinners to manage them globally
+_active_spinners = []
+
+
+def register_spinner(spinner):
+    """Register an active spinner to be managed globally."""
+    if spinner not in _active_spinners:
+        _active_spinners.append(spinner)
+
+
+def unregister_spinner(spinner):
+    """Remove a spinner from global management."""
+    if spinner in _active_spinners:
+        _active_spinners.remove(spinner)
+
+
+def pause_all_spinners():
+    """Pause all active spinners."""
+    for spinner in _active_spinners:
+        try:
+            spinner.pause()
+        except Exception:
+            # Ignore errors if a spinner can't be paused
+            pass
+
+
+def resume_all_spinners():
+    """Resume all active spinners."""
+    for spinner in _active_spinners:
+        try:
+            spinner.resume()
+        except Exception:
+            # Ignore errors if a spinner can't be resumed
+            pass
+
+
+__all__ = [
+    "SpinnerBase",
+    "TextualSpinner",
+    "ConsoleSpinner",
+    "register_spinner",
+    "unregister_spinner",
+    "pause_all_spinners",
+    "resume_all_spinners",
+]

code_puppy/messaging/spinner/console_spinner.py

@@ -0,0 +1,200 @@
+"""
+Console spinner implementation for CLI mode using Rich's Live Display.
+"""
+
+import threading
+import time
+
+from rich.console import Console
+from rich.live import Live
+from rich.text import Text
+
+from .spinner_base import SpinnerBase
+
+
+class ConsoleSpinner(SpinnerBase):
+    """A console-based spinner implementation using Rich's Live Display."""
+
+    def __init__(self, console=None):
+        """Initialize the console spinner.
+
+        Args:
+            console: Optional Rich console instance to use for output.
+                    If not provided, a new one will be created.
+        """
+        super().__init__()
+        self.console = console or Console()
+        self._thread = None
+        self._stop_event = threading.Event()
+        self._paused = False
+        self._live = None
+
+        # Register this spinner for global management
+        from . import register_spinner
+
+        register_spinner(self)
+
+    def start(self):
+        """Start the spinner animation."""
+        super().start()
+        self._stop_event.clear()
+
+        # Don't start a new thread if one is already running
+        if self._thread and self._thread.is_alive():
+            return
+
+        # Create a Live display for the spinner
+        self._live = Live(
+            self._generate_spinner_panel(),
+            console=self.console,
+            refresh_per_second=10,
+            transient=True,
+            auto_refresh=False,  # Don't auto-refresh to avoid wiping out user input
+        )
+        self._live.start()
+
+        # Start a thread to update the spinner frames
+        self._thread = threading.Thread(target=self._update_spinner)
+        self._thread.daemon = True
+        self._thread.start()
+
+    def stop(self):
+        """Stop the spinner animation."""
+        if not self._is_spinning:
+            return
+
+        self._stop_event.set()
+        self._is_spinning = False
+
+        if self._live:
+            self._live.stop()
+            self._live = None
+
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=0.5)
+
+        self._thread = None
+
+        # Unregister this spinner from global management
+        from . import unregister_spinner
+
+        unregister_spinner(self)
+
+    def update_frame(self):
+        """Update to the next frame."""
+        super().update_frame()
+
+    def _generate_spinner_panel(self):
+        """Generate a Rich panel containing the spinner text."""
+        if self._paused:
+            return Text("")
+
+        text = Text()
+
+        # Check if we're awaiting user input to determine which message to show
+        from code_puppy.tools.command_runner import is_awaiting_user_input
+
+        if is_awaiting_user_input():
+            # Show waiting message when waiting for user input
+            text.append(SpinnerBase.WAITING_MESSAGE, style="bold cyan")
+        else:
+            # Show thinking message during normal processing
+            text.append(SpinnerBase.THINKING_MESSAGE, style="bold cyan")
+
+        text.append(self.current_frame, style="bold cyan")
+
+        # Return a simple Text object instead of a Panel for a cleaner look
+        return text
+
+    def _update_spinner(self):
+        """Update the spinner in a background thread."""
+        try:
+            while not self._stop_event.is_set():
+                # Update the frame
+                self.update_frame()
+
+                # Check if we're awaiting user input before updating the display
+                from code_puppy.tools.command_runner import is_awaiting_user_input
+
+                awaiting_input = is_awaiting_user_input()
+
+                # Update the live display only if not paused and not awaiting input
+                if self._live and not self._paused and not awaiting_input:
+                    # Manually refresh instead of auto-refresh to avoid wiping input
+                    self._live.update(self._generate_spinner_panel())
+                    self._live.refresh()
+
+                # Short sleep to control animation speed
+                time.sleep(0.1)
+        except Exception as e:
+            print(f"\nSpinner error: {e}")
+            self._is_spinning = False
+
+    def pause(self):
+        """Pause the spinner animation."""
+        if self._is_spinning:
+            self._paused = True
+            # Update the live display to hide the spinner immediately
+            if self._live:
+                try:
+                    # When pausing, first update with the waiting message
+                    # so it's visible briefly before disappearing
+                    from code_puppy.tools.command_runner import is_awaiting_user_input
+
+                    if is_awaiting_user_input():
+                        text = Text()
+                        text.append(SpinnerBase.WAITING_MESSAGE, style="bold cyan")
+                        text.append(self.current_frame, style="bold cyan")
+                        self._live.update(text)
+                        self._live.refresh()
+                        # Allow a moment for the waiting message to be visible
+                        import time
+
+                        time.sleep(0.1)
+
+                    # Then clear the display
+                    self._live.update(Text(""))
+                except Exception:
+                    # If update fails, try stopping it completely
+                    try:
+                        self._live.stop()
+                    except Exception:
+                        pass
+
+    def resume(self):
+        """Resume the spinner animation."""
+        # Check if we should show a spinner - don't resume if waiting for user input
+        from code_puppy.tools.command_runner import is_awaiting_user_input
+
+        if is_awaiting_user_input():
+            return  # Don't resume if waiting for user input
+
+        if self._is_spinning and self._paused:
+            self._paused = False
+            # Force an immediate update to show the spinner again
+            if self._live:
+                try:
+                    self._live.update(self._generate_spinner_panel())
+                except Exception:
+                    # If update fails, the live display might have been stopped
+                    # Try to restart it
+                    try:
+                        self._live = Live(
+                            self._generate_spinner_panel(),
+                            console=self.console,
+                            refresh_per_second=10,
+                            transient=True,
+                            auto_refresh=False,  # Don't auto-refresh to avoid wiping out user input
+                        )
+                        self._live.start()
+                    except Exception:
+                        pass
+
+    def __enter__(self):
+        """Support for context manager."""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Clean up when exiting context manager."""
+        self.stop()

code_puppy/messaging/spinner/spinner_base.py

@@ -0,0 +1,66 @@
+"""
+Base spinner implementation to be extended for different UI modes.
+"""
+
+from abc import ABC, abstractmethod
+
+from code_puppy.config import get_puppy_name
+
+
+class SpinnerBase(ABC):
+    """Abstract base class for spinner implementations."""
+
+    # Shared spinner frames across implementations
+    FRAMES = [
+        "(🐶    ) ",
+        "( 🐶   ) ",
+        "(  🐶  ) ",
+        "(   🐶 ) ",
+        "(    🐶) ",
+        "(   🐶 ) ",
+        "(  🐶  ) ",
+        "( 🐶   ) ",
+        "(🐶    ) ",
+    ]
+    puppy_name = get_puppy_name().title()
+
+    # Default message when processing
+    THINKING_MESSAGE = f"{puppy_name} is thinking... "
+
+    # Message when waiting for user input
+    WAITING_MESSAGE = f"{puppy_name} is waiting... "
+
+    # Current message - starts with thinking by default
+    MESSAGE = THINKING_MESSAGE
+
+    def __init__(self):
+        """Initialize the spinner."""
+        self._is_spinning = False
+        self._frame_index = 0
+
+    @abstractmethod
+    def start(self):
+        """Start the spinner animation."""
+        self._is_spinning = True
+        self._frame_index = 0
+
+    @abstractmethod
+    def stop(self):
+        """Stop the spinner animation."""
+        self._is_spinning = False
+
+    @abstractmethod
+    def update_frame(self):
+        """Update to the next frame."""
+        if self._is_spinning:
+            self._frame_index = (self._frame_index + 1) % len(self.FRAMES)
+
+    @property
+    def current_frame(self):
+        """Get the current frame."""
+        return self.FRAMES[self._frame_index]
+
+    @property
+    def is_spinning(self):
+        """Check if the spinner is currently spinning."""
+        return self._is_spinning