tsugite-cli 0.3.3__py3-none-any.whl

tsugite/ui/textual_handler.py

@@ -0,0 +1,225 @@
+"""Textual UI handler for chat interface."""
+
+from typing import Any, Callable, Dict, Optional
+
+from tsugite.events import (
+    BaseEvent,
+    CodeExecutionEvent,
+    ErrorEvent,
+    ExecutionResultEvent,
+    FinalAnswerEvent,
+    LLMMessageEvent,
+    ObservationEvent,
+    StepStartEvent,
+    StreamChunkEvent,
+    StreamCompleteEvent,
+    TaskStartEvent,
+    ToolCallEvent,
+)
+from tsugite.ui.base import CustomUIHandler
+
+
+class TextualUIHandler(CustomUIHandler):
+    """UI handler that updates Textual reactive variables via callbacks."""
+
+    def __init__(
+        self,
+        on_status_change: Optional[Callable[[str], None]] = None,
+        on_tool_call: Optional[Callable[[str], None]] = None,
+        on_stream_chunk: Optional[Callable[[str], None]] = None,
+        on_stream_complete: Optional[Callable[[], None]] = None,
+        on_intermediate_message: Optional[Callable[[str], None]] = None,
+        on_thought_log: Optional[Callable[[str, str], None]] = None,
+    ):
+        """Initialize Textual UI handler.
+
+        Args:
+            on_status_change: Callback for status updates
+            on_tool_call: Callback when tool is called
+            on_stream_chunk: Callback for streaming chunks
+            on_stream_complete: Callback when streaming completes
+            on_intermediate_message: Callback for intermediate agent messages
+            on_thought_log: Callback for thought log entries (type, content)
+        """
+        # Initialize with a no-op console (we won't use it)
+        from io import StringIO
+
+        from rich.console import Console
+
+        # Use a StringIO console to capture any output we don't want
+        super().__init__(
+            console=Console(file=StringIO(), force_terminal=False),
+            show_panels=False,  # Don't render panels
+        )
+
+        self.on_status_change = on_status_change
+        self.on_tool_call = on_tool_call
+        self.on_stream_chunk = on_stream_chunk
+        self.on_stream_complete = on_stream_complete
+        self.on_intermediate_message = on_intermediate_message
+        self.on_thought_log = on_thought_log
+
+        # Track tools used in current turn
+        self.current_tools = []
+        self._last_status = ""
+
+    def handle_event(self, event: BaseEvent) -> None:
+        """Handle UI event by calling appropriate callbacks."""
+        with self._lock:
+            if isinstance(event, TaskStartEvent):
+                self._handle_task_start(event)
+            elif isinstance(event, StepStartEvent):
+                self._handle_step_start(event)
+            elif isinstance(event, CodeExecutionEvent):
+                self._handle_code_execution(event)
+            elif isinstance(event, ToolCallEvent):
+                self._handle_tool_call(event)
+            elif isinstance(event, ObservationEvent):
+                self._handle_observation(event)
+            elif isinstance(event, FinalAnswerEvent):
+                self._handle_final_answer(event)
+            elif isinstance(event, ErrorEvent):
+                self._handle_error(event)
+            elif isinstance(event, LLMMessageEvent):
+                self._handle_llm_message(event)
+            elif isinstance(event, StreamChunkEvent):
+                self._handle_stream_chunk(event)
+            elif isinstance(event, StreamCompleteEvent):
+                self._handle_stream_complete(event)
+            elif isinstance(event, ExecutionResultEvent):
+                self._handle_execution_result(event)
+
+    def _update_status(self, new_status: str) -> None:
+        """Update status with thread safety.
+
+        Args:
+            new_status: New status message
+        """
+        if new_status != self._last_status:
+            self._last_status = new_status
+            if self.on_status_change:
+                self.on_status_change(new_status)
+
+    def _handle_task_start(self, event: TaskStartEvent) -> None:
+        """Handle task start - reset tools list."""
+        self.current_tools = []
+        self._update_status("Starting task...")
+
+    def _handle_step_start(self, event: StepStartEvent) -> None:
+        """Handle step start."""
+        step = event.step
+        status_msg = f"Step {step}: Waiting for LLM response..."
+        self._update_status(status_msg)
+
+        # Log to thought log
+        if self.on_thought_log:
+            self.on_thought_log("step", f"Step {step}")
+
+    def _handle_code_execution(self, event: CodeExecutionEvent) -> None:
+        """Handle code execution."""
+        code = event.code
+        # Show preview of code being executed
+        preview = code[:50] if code else "code"
+        if len(code) > 50:
+            preview += "..."
+        self._update_status(f"Executing: {preview}")
+
+        # Log to thought log instead of chat
+        if self.on_thought_log:
+            self.on_thought_log("code_execution", code)
+
+    def _handle_tool_call(self, event: ToolCallEvent) -> None:
+        """Handle tool call."""
+        tool_name = event.tool
+        self.current_tools.append(tool_name)
+
+        self._update_status(f"Using tool: {tool_name}")
+        if self.on_tool_call:
+            self.on_tool_call(tool_name)
+
+        # Log to thought log instead of chat
+        if self.on_thought_log:
+            self.on_thought_log("tool_call", tool_name)
+
+    def _handle_observation(self, event: ObservationEvent) -> None:
+        """Handle observation."""
+        observation = event.observation
+        self._update_status("Processing results...")
+
+        # Log to thought log if meaningful
+        if self.on_thought_log and observation.strip():
+            # Clean up observation and truncate if too long
+            clean_obs = observation.replace("|", "[").strip()
+            if len(clean_obs) > 150:
+                clean_obs = clean_obs[:150] + "..."
+            self.on_thought_log("observation", clean_obs)
+
+    def _handle_final_answer(self, event: FinalAnswerEvent) -> None:
+        """Handle final answer."""
+        self._update_status("Finalizing answer...")
+
+    def _handle_error(self, event: ErrorEvent) -> None:
+        """Handle error."""
+        error = event.error
+        self._update_status(f"Error: {error}")
+
+    def _handle_llm_message(self, event: LLMMessageEvent) -> None:
+        """Handle intermediate LLM message (thoughts from agent)."""
+        content = event.content
+        if content:
+            # Route thoughts to thought log instead of chat
+            if self.on_thought_log:
+                # Clean up the content - remove any leading/trailing whitespace
+                clean_content = content.strip()
+                if clean_content:
+                    self.on_thought_log("step", f"💭 {clean_content}")
+
+    def _handle_stream_chunk(self, event: StreamChunkEvent) -> None:
+        """Handle streaming chunk."""
+        chunk = event.chunk
+        self.streaming_content += chunk
+        self.is_streaming = True
+
+        self._update_status("Streaming response...")
+        if self.on_stream_chunk:
+            self.on_stream_chunk(chunk)
+
+    def _handle_stream_complete(self, data: Dict[str, Any]) -> None:
+        """Handle streaming complete."""
+        self.is_streaming = False
+        self.streaming_content = ""
+
+        self._update_status("Ready")
+        if self.on_stream_complete:
+            self.on_stream_complete()
+
+    def get_tools_used(self):
+        """Get list of tools used in current turn."""
+        return self.current_tools.copy()
+
+    def clear_tools(self):
+        """Clear tools list for new turn."""
+        self.current_tools = []
+
+    def _handle_execution_result(self, event: ExecutionResultEvent) -> None:
+        """Handle execution result."""
+        content = event.result
+
+        if self.on_thought_log and content.strip():
+            # Parse execution result content
+            lines = content.split("\n")
+            output_lines = []
+
+            # Extract meaningful output
+            for line in lines:
+                if line.startswith("Out:"):
+                    output_lines.append(line[4:].strip())
+                elif not line.startswith("Execution logs:") and line.strip():
+                    output_lines.append(line.strip())
+
+            if output_lines:
+                result_text = "\n".join(output_lines)
+                # Truncate if too long
+                if len(result_text) > 200:
+                    result_text = result_text[:200] + "..."
+                self.on_thought_log("execution_result", result_text)

tsugite/ui/widgets/__init__.py

@@ -0,0 +1,6 @@
+"""Textual widgets for Tsugite chat UI."""
+
+from .message_list import MessageList
+from .thought_log import ThoughtLog
+
+__all__ = ["MessageList", "ThoughtLog"]

tsugite/ui/widgets/base_scroll_log.py

@@ -0,0 +1,27 @@
+"""Base class for scrollable reactive log widgets."""
+
+from textual.containers import VerticalScroll
+from textual.reactive import reactive
+
+
+class BaseScrollLog(VerticalScroll):
+    """Base class for scrollable log widgets with reactive entry lists."""
+
+    entries = reactive([], recompose=True)
+
+    def __init__(self):
+        """Initialize base scroll log."""
+        super().__init__()
+        self.can_focus = True
+
+    def watch_entries(self):
+        """Called when entries change - auto-scroll to bottom."""
+        self.call_after_refresh(self.scroll_end)
+
+    def on_mount(self):
+        """Called when widget is mounted - initial scroll."""
+        self.scroll_end(animate=False)
+
+    def clear_log(self):
+        """Clear all entries from the log."""
+        self.entries = []

tsugite/ui/widgets/message_list.py

@@ -0,0 +1,121 @@
+"""Scrollable message history widget for chat UI."""
+
+from rich.console import Group, RenderableType
+from rich.markdown import Markdown
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widgets import Static
+
+from .base_scroll_log import BaseScrollLog
+
+
+class Message(Static):
+    """Individual message display widget."""
+
+    def __init__(
+        self,
+        sender: str,
+        content: str,
+        sender_style: str = "bold",
+        content_style: str = "",
+        render_markdown: bool = False,
+    ):
+        """Initialize message widget.
+
+        Args:
+            sender: Sender label (e.g., "You", "Agent")
+            content: Message content
+            sender_style: Rich style for sender label
+            content_style: Rich style for content
+            render_markdown: Whether to render content as markdown
+        """
+        super().__init__(markup=False)
+        self.sender = sender
+        self._message_content = content
+        self.sender_style = sender_style
+        self.content_style = content_style
+        self.render_markdown = render_markdown
+
+    def render(self) -> RenderableType:
+        """Render the message with styling."""
+        # Create sender label
+        sender_text = Text()
+        sender_text.append(f"{self.sender}: ", style=self.sender_style)
+
+        # Render content based on mode
+        if self.render_markdown:
+            # Use markdown rendering
+            content_rendered = Markdown(str(self._message_content), code_theme="monokai", inline_code_theme="monokai")
+            # Group sender and markdown content together
+            return Group(sender_text, content_rendered)
+        else:
+            # Use plain text rendering
+            sender_text.append(str(self._message_content), style=self.content_style)
+            return sender_text
+
+
+class MessageList(BaseScrollLog):
+    """Scrollable container for chat messages."""
+
+    messages = reactive([], recompose=True)
+    markdown_mode = reactive(True, recompose=True)
+
+    def __init__(self):
+        """Initialize message list."""
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose the message list from reactive messages."""
+        for msg in self.messages:
+            if msg["type"] == "user":
+                yield Message("You", msg["content"], sender_style="bold #b8bb26", content_style="#b8bb26")
+            elif msg["type"] == "agent":
+                # Render agent messages with markdown if enabled
+                yield Message(
+                    "Agent",
+                    msg["content"],
+                    sender_style="bold #83a598",
+                    content_style="#83a598",
+                    render_markdown=self.markdown_mode,
+                )
+            elif msg["type"] == "tool_call":
+                yield Message("🔧 Tool", msg["content"], sender_style="#fabd2f", content_style="dim #fabd2f")
+            elif msg["type"] == "code_execution":
+                yield Message("⚡ Code", msg["content"], sender_style="#d3869b", content_style="dim")
+            elif msg["type"] == "execution_result":
+                yield Message("📤 Result", msg["content"], sender_style="#8ec07c", content_style="dim #8ec07c")
+            elif msg["type"] == "observation":
+                yield Message("💡 Info", msg["content"], sender_style="#83a598", content_style="dim #83a598")
+            elif msg["type"] == "separator":
+                yield Static("─" * 40, classes="separator", markup=False)
+            elif msg["type"] == "status":
+                yield Static(msg["content"], classes="status", markup=False)
+
+    def add_message(self, sender_type: str, content: str):
+        """Add a new message to the list.
+
+        Args:
+            sender_type: Type of sender ("user", "agent", "status", "separator")
+            content: Message content
+        """
+        new_messages = self.messages.copy()
+        new_messages.append({"type": sender_type, "content": content})
+        self.messages = new_messages
+
+    def add_separator(self):
+        """Add a visual separator between exchanges."""
+        self.add_message("separator", "")
+
+    def toggle_markdown(self) -> bool:
+        """Toggle markdown rendering mode.
+
+        Returns:
+            New markdown mode state
+        """
+        self.markdown_mode = not self.markdown_mode
+        return self.markdown_mode
+
+    def watch_messages(self):
+        """Called when messages change - auto-scroll to bottom."""
+        self.call_after_refresh(self.scroll_end)

tsugite/ui/widgets/thought_log.py

@@ -0,0 +1,80 @@
+"""Thought log widget showing execution summaries and LLM thinking."""
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import Static
+
+from .base_scroll_log import BaseScrollLog
+
+
+class ThoughtEntry(Static):
+    """Individual thought/execution entry."""
+
+    def __init__(self, icon: str, content: str, style: str = "dim"):
+        """Initialize thought entry.
+
+        Args:
+            icon: Emoji or symbol for entry type
+            content: Brief description of what's happening
+            style: Rich style for content
+        """
+        # Store values before calling super().__init__
+        self.icon = icon
+        self.entry_content = content  # Use different name to avoid conflict with Static.content
+        self.entry_style = style
+        super().__init__()
+
+    def render(self) -> Text:
+        """Render the thought entry."""
+        text = Text()
+        text.append(f"{self.icon} ", style=self.entry_style)
+        text.append(str(self.entry_content), style=self.entry_style)
+        return text
+
+
+class ThoughtLog(BaseScrollLog):
+    """Scrollable log of agent thoughts and execution summaries."""
+
+    def __init__(self):
+        """Initialize thought log."""
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        """Compose the thought log from reactive entries."""
+        for entry in self.entries:
+            entry_type = entry["type"]
+            content = entry["content"]
+
+            if entry_type == "step":
+                yield ThoughtEntry("🧠", content, style="bold #83a598")  # gruvbox blue
+            elif entry_type == "tool_call":
+                yield ThoughtEntry("🔧", f"Using tool: {content}", style="#fabd2f")  # gruvbox yellow
+            elif entry_type == "code_execution":
+                # Summarize code execution
+                code = content
+                lines = code.count("\n") + 1
+                preview = code[:40].replace("\n", " ") if code else "code"
+                if len(code) > 40:
+                    preview += "..."
+                yield ThoughtEntry(
+                    "⚡", f"Executing {lines} line(s) of code: {preview}", style="#d3869b"
+                )  # gruvbox purple
+            elif entry_type == "observation":
+                yield ThoughtEntry("💡", f"Result: {content}", style="#8ec07c")  # gruvbox aqua
+            elif entry_type == "execution_result":
+                yield ThoughtEntry("📤", f"Output: {content}", style="#8ec07c")  # gruvbox aqua
+            elif entry_type == "status":
+                yield ThoughtEntry("ℹ️", content, style="dim #a89984")  # gruvbox gray
+            elif entry_type == "error":
+                yield ThoughtEntry("❌", content, style="bold #fb4934")  # gruvbox red
+
+    def add_entry(self, entry_type: str, content: str):
+        """Add a new entry to the thought log.
+
+        Args:
+            entry_type: Type of entry (step, tool_call, code_execution, etc.)
+            content: Entry content/description
+        """
+        new_entries = self.entries.copy()
+        new_entries.append({"type": entry_type, "content": content})
+        self.entries = new_entries

tsugite/ui_context.py

@@ -0,0 +1,90 @@
+"""Context for UI state access from tools using contextvars."""
+
+import contextvars
+from contextlib import contextmanager
+from typing import Any, Generator, Optional
+
+from rich.console import Console
+from rich.progress import Progress
+
+# Context variables for UI context (can be propagated to threads)
+_console_var: contextvars.ContextVar[Optional[Console]] = contextvars.ContextVar("console", default=None)
+_progress_var: contextvars.ContextVar[Optional[Progress]] = contextvars.ContextVar("progress", default=None)
+_ui_handler_var: contextvars.ContextVar[Optional[Any]] = contextvars.ContextVar("ui_handler", default=None)
+
+
+def set_ui_context(
+    console: Optional[Console] = None,
+    progress: Optional[Progress] = None,
+    ui_handler: Optional[Any] = None,
+) -> None:
+    """Store UI context in context variables.
+
+    Args:
+        console: Rich console instance
+        progress: Rich progress instance (spinner)
+        ui_handler: UI handler instance (e.g., TextualUIHandler or CustomUIHandler)
+    """
+    _console_var.set(console)
+    _progress_var.set(progress)
+    _ui_handler_var.set(ui_handler)
+
+
+def get_console() -> Optional[Console]:
+    """Get the console from context variables."""
+    return _console_var.get()
+
+
+def get_progress() -> Optional[Progress]:
+    """Get the progress spinner from context variables."""
+    return _progress_var.get()
+
+
+def get_ui_handler() -> Optional[Any]:
+    """Get the UI handler from context variables.
+
+    Returns:
+        UI handler instance if available (e.g., TextualUIHandler), None otherwise
+    """
+    return _ui_handler_var.get()
+
+
+def clear_ui_context() -> None:
+    """Clear UI context from context variables."""
+    _console_var.set(None)
+    _progress_var.set(None)
+    _ui_handler_var.set(None)
+
+
+@contextmanager
+def paused_progress() -> Generator[None, None, None]:
+    """Context manager to temporarily pause UI elements for user input.
+
+    This pauses either:
+    - Live Display (if a UI handler with pause_for_input exists)
+    - Progress spinner (fallback for older UI modes)
+
+    This is useful for interactive operations that need user input
+    without UI elements interfering with the display.
+
+    Yields:
+        None
+    """
+    ui_handler = get_ui_handler()
+    progress = get_progress()
+
+    # Check if UI handler has a pause_for_input method (Live Display)
+    if ui_handler is not None and hasattr(ui_handler, "pause_for_input"):
+        # Use the UI handler's pause mechanism (for Live Display)
+        with ui_handler.pause_for_input():
+            yield
+    else:
+        # Fallback: pause old-style progress spinner
+        if progress is not None:
+            progress.stop()
+
+        try:
+            yield
+        finally:
+            if progress is not None:
+                progress.start()