EvoScientist 0.0.1.dev2__py3-none-any.whl → 0.0.1.dev4__py3-none-any.whl

EvoScientist/stream/display.py

@@ -0,0 +1,604 @@
+"""Rich display functions for streaming CLI output.
+
+Contains all rendering logic: tool call lines, sub-agent sections,
+todo panels, streaming display layout, and final results display.
+Also provides the shared console and formatter globals.
+"""
+
+import asyncio
+import os
+import sys
+from typing import Any
+
+from rich.console import Console, Group  # type: ignore[import-untyped]
+from rich.live import Live  # type: ignore[import-untyped]
+from rich.markdown import Markdown  # type: ignore[import-untyped]
+from rich.panel import Panel  # type: ignore[import-untyped]
+from rich.spinner import Spinner  # type: ignore[import-untyped]
+from rich.text import Text  # type: ignore[import-untyped]
+
+from .formatter import ToolResultFormatter
+from .state import StreamState, SubAgentState, _build_todo_stats, _parse_todo_items
+from .utils import DisplayLimits, ToolStatus, format_tool_compact, is_success
+from .events import stream_agent_events
+
+# ---------------------------------------------------------------------------
+# Shared globals
+# ---------------------------------------------------------------------------
+
+console = Console(
+    legacy_windows=(sys.platform == 'win32'),
+    no_color=os.getenv('NO_COLOR') is not None,
+)
+
+formatter = ToolResultFormatter()
+
+
+# ---------------------------------------------------------------------------
+# Todo formatting
+# ---------------------------------------------------------------------------
+
+def _format_single_todo(item: dict) -> Text:
+    """Format a single todo item with status symbol."""
+    status = str(item.get("status", "todo")).lower()
+    content_text = str(item.get("content", item.get("task", item.get("title", ""))))
+
+    if status in ("done", "completed", "complete"):
+        symbol = "\u2713"
+        label = "done  "
+        style = "green dim"
+    elif status in ("active", "in_progress", "in-progress", "working"):
+        symbol = "\u25cf"
+        label = "active"
+        style = "yellow"
+    else:
+        symbol = "\u25cb"
+        label = "todo  "
+        style = "dim"
+
+    line = Text()
+    line.append(f"    {symbol} ", style=style)
+    line.append(label, style=style)
+    line.append(" ", style="dim")
+    # Truncate long content
+    if len(content_text) > 60:
+        content_text = content_text[:57] + "\u2026"
+    line.append(content_text, style=style)
+    return line
+
+
+# ---------------------------------------------------------------------------
+# Tool result formatting
+# ---------------------------------------------------------------------------
+
+def format_tool_result_compact(_name: str, content: str, max_lines: int = 5) -> list:
+    """Format tool result as tree output.
+
+    Special handling for write_todos: shows formatted checklist with status symbols.
+    """
+    elements = []
+
+    if not content.strip():
+        elements.append(Text("  \u2514 (empty)", style="dim"))
+        return elements
+
+    # Special handling for write_todos
+    if _name == "write_todos":
+        items = _parse_todo_items(content)
+        if items:
+            stats = _build_todo_stats(items)
+            stats_line = Text()
+            stats_line.append("  \u2514 ", style="dim")
+            stats_line.append(stats, style="dim")
+            elements.append(stats_line)
+            elements.append(Text("", style="dim"))  # blank line
+
+            max_preview = 4
+            for item in items[:max_preview]:
+                elements.append(_format_single_todo(item))
+
+            remaining = len(items) - max_preview
+            if remaining > 0:
+                elements.append(Text(f"    ... {remaining} more", style="dim italic"))
+
+            return elements
+
+    lines = content.strip().split("\n")
+    total_lines = len(lines)
+
+    display_lines = lines[:max_lines]
+    for i, line in enumerate(display_lines):
+        prefix = "\u2514" if i == 0 else " "
+        if len(line) > 80:
+            line = line[:77] + "\u2026"
+        style = "dim" if is_success(content) else "red dim"
+        elements.append(Text(f"  {prefix} {line}", style=style))
+
+    remaining = total_lines - max_lines
+    if remaining > 0:
+        elements.append(Text(f"    ... +{remaining} lines", style="dim italic"))
+
+    return elements
+
+
+# ---------------------------------------------------------------------------
+# Tool call line rendering
+# ---------------------------------------------------------------------------
+
+def _render_tool_call_line(tc: dict, tr: dict | None) -> Text:
+    """Render a single tool call line with status indicator."""
+    is_task = tc.get('name', '').lower() == 'task'
+
+    if tr is not None:
+        content = tr.get('content', '')
+        if is_success(content):
+            style = "bold green"
+            indicator = "\u2713" if is_task else ToolStatus.SUCCESS.value
+        else:
+            style = "bold red"
+            indicator = "\u2717" if is_task else ToolStatus.ERROR.value
+    else:
+        style = "bold yellow" if not is_task else "bold cyan"
+        indicator = "\u25b6" if is_task else ToolStatus.RUNNING.value
+
+    # Try to get display name from args first
+    tool_compact = format_tool_compact(tc['name'], tc.get('args'))
+
+    # If args were empty and we have a result, try to infer memory operations from result
+    tool_name = tc.get('name', '').lower()
+    if tool_name in ('write_file', 'edit_file') and tr is not None:
+        result_content = tr.get('content', '')
+        if '/MEMORY.md' in result_content or 'MEMORY.md' in result_content:
+            tool_compact = "Updating memory"
+    elif tool_name == 'read_file' and tr is not None:
+        result_content = tr.get('content', '')
+        # read_file result doesn't contain path, check if args is empty and result looks like memory
+        args = tc.get('args') or {}
+        if not args.get('path') and '# EvoScientist Memory' in result_content:
+            tool_compact = "Reading memory"
+
+    tool_text = Text()
+    tool_text.append(f"{indicator} ", style=style)
+    tool_text.append(tool_compact, style=style)
+    return tool_text
+
+
+# ---------------------------------------------------------------------------
+# Sub-agent section rendering
+# ---------------------------------------------------------------------------
+
+def _render_subagent_section(sa: 'SubAgentState', compact: bool = False) -> list:
+    """Render a sub-agent's activity as a bordered section.
+
+    Args:
+        sa: Sub-agent state to render
+        compact: If True, render minimal 1-line summary (completed sub-agents)
+
+    Header uses "Cooking with {name}" style matching task tool format.
+    Active sub-agents show bordered tool list; completed ones collapse to 1 line.
+    """
+    elements = []
+    BORDER = "dim cyan" if sa.is_active else "dim"
+
+    # Filter out tool calls with empty names
+    valid_calls = [tc for tc in sa.tool_calls if tc.get("name")]
+
+    # Split into completed and pending
+    completed = []
+    pending = []
+    for tc in valid_calls:
+        tr = sa.get_result_for(tc)
+        if tr is not None:
+            completed.append((tc, tr))
+        else:
+            pending.append(tc)
+
+    succeeded = sum(1 for _, tr in completed if tr.get("success", True))
+    _ = len(completed) - succeeded  # failed count, unused for now
+
+    # Build display name
+    display_name = f"Cooking with {sa.name}"
+    if sa.description:
+        desc = sa.description.split("\n")[0].strip()
+        desc = desc[:50] + "\u2026" if len(desc) > 50 else desc
+        display_name += f" \u2014 {desc}"
+
+    # --- Compact mode: 1-line summary for completed sub-agents ---
+    if compact:
+        line = Text()
+        if not sa.is_active:
+            line.append("\u2713 ", style="green")
+            line.append(display_name, style="green dim")
+            total = len(valid_calls)
+            line.append(f" ({total} tools)", style="dim")
+        else:
+            line.append("\u25b6 ", style="cyan")
+            line.append(display_name, style="bold cyan")
+        elements.append(line)
+        return elements
+
+    # --- Full mode: bordered section for Live streaming ---
+
+    # Header
+    header = Text()
+    header.append("\u250c ", style=BORDER)
+    if sa.is_active:
+        header.append(f"\u25b6 {display_name}", style="bold cyan")
+    else:
+        header.append(f"\u2713 {display_name}", style="bold green")
+    elements.append(header)
+
+    # Show every tool call with its status
+    for tc, tr in completed:
+        tc_line = Text("\u2502 ", style=BORDER)
+        tc_name = format_tool_compact(tc["name"], tc.get("args"))
+        if tr.get("success", True):
+            tc_line.append(f"\u2713 {tc_name}", style="green")
+        else:
+            tc_line.append(f"\u2717 {tc_name}", style="red")
+            content = tr.get("content", "")
+            first_line = content.strip().split("\n")[0][:70]
+            if first_line:
+                err_line = Text("\u2502   ", style=BORDER)
+                err_line.append(f"\u2514 {first_line}", style="red dim")
+                elements.append(tc_line)
+                elements.append(err_line)
+                continue
+        elements.append(tc_line)
+
+    # Pending/running tools
+    for tc in pending:
+        tc_line = Text("\u2502 ", style=BORDER)
+        tc_name = format_tool_compact(tc["name"], tc.get("args"))
+        tc_line.append(f"\u25cf {tc_name}", style="bold yellow")
+        elements.append(tc_line)
+        spinner_line = Text("\u2502   ", style=BORDER)
+        spinner_line.append("\u21bb running...", style="yellow dim")
+        elements.append(spinner_line)
+
+    # Footer
+    if not sa.is_active:
+        total = len(valid_calls)
+        footer = Text(f"\u2514 done ({total} tools)", style="dim green")
+        elements.append(footer)
+    elif valid_calls:
+        footer = Text("\u2514 running...", style="dim cyan")
+        elements.append(footer)
+
+    return elements
+
+
+# ---------------------------------------------------------------------------
+# Todo panel
+# ---------------------------------------------------------------------------
+
+def _render_todo_panel(todo_items: list[dict]) -> Panel:
+    """Render a bordered Task List panel from todo items.
+
+    Matches the style: cyan border, status icons per item.
+    """
+    lines = Text()
+    for i, item in enumerate(todo_items):
+        if i > 0:
+            lines.append("\n")
+        status = str(item.get("status", "todo")).lower()
+        content_text = str(item.get("content", item.get("task", item.get("title", ""))))
+
+        if status in ("done", "completed", "complete"):
+            symbol = "\u2713"  # checkmark
+            style = "green dim"
+        elif status in ("active", "in_progress", "in-progress", "working"):
+            symbol = "\u23f3"  # hourglass
+            style = "yellow"
+        else:
+            symbol = "\u25a1"  # empty square
+            style = "dim"
+
+        lines.append(f"{symbol} ", style=style)
+        lines.append(content_text, style=style)
+
+    return Panel(
+        lines,
+        title="Task List",
+        title_align="center",
+        border_style="cyan",
+        padding=(0, 1),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Streaming display layout
+# ---------------------------------------------------------------------------
+
+def create_streaming_display(
+    thinking_text: str = "",
+    response_text: str = "",
+    latest_text: str = "",
+    tool_calls: list | None = None,
+    tool_results: list | None = None,
+    is_thinking: bool = False,
+    is_responding: bool = False,
+    is_waiting: bool = False,
+    is_processing: bool = False,
+    show_thinking: bool = True,
+    subagents: list | None = None,
+    todo_items: list | None = None,
+) -> Any:
+    """Create Rich display layout for streaming output.
+
+    Returns:
+        Rich Group for Live display
+    """
+    elements = []
+    tool_calls = tool_calls or []
+    tool_results = tool_results or []
+    subagents = subagents or []
+
+    # Initial waiting state
+    if is_waiting and not thinking_text and not response_text and not tool_calls:
+        spinner = Spinner("dots", text=" Thinking...", style="cyan")
+        elements.append(spinner)
+        return Group(*elements)
+
+    # Thinking panel
+    if show_thinking and thinking_text:
+        thinking_title = "Thinking"
+        if is_thinking:
+            thinking_title += " ..."
+        display_thinking = thinking_text
+        if len(display_thinking) > DisplayLimits.THINKING_STREAM:
+            display_thinking = "..." + display_thinking[-DisplayLimits.THINKING_STREAM:]
+        elements.append(Panel(
+            Text(display_thinking, style="dim"),
+            title=thinking_title,
+            border_style="blue",
+            padding=(0, 1),
+        ))
+
+    # Tool calls and results paired display
+    # Collapse older completed tools to prevent overflow in Live mode
+    # Task tool calls are ALWAYS visible (they represent sub-agent delegations)
+    MAX_VISIBLE_TOOLS = 4
+    MAX_VISIBLE_RUNNING = 3
+
+    if tool_calls:
+        # Split into categories
+        completed_regular = []   # completed non-task tools
+        task_tools = []          # task tools (always visible)
+        running_regular = []     # running non-task tools
+
+        for i, tc in enumerate(tool_calls):
+            has_result = i < len(tool_results)
+            tr = tool_results[i] if has_result else None
+            is_task = tc.get('name') == 'task'
+
+            if is_task:
+                # Skip task calls with empty args (still streaming)
+                if tc.get('args'):
+                    task_tools.append((tc, tr))
+            elif has_result:
+                completed_regular.append((tc, tr))
+            else:
+                running_regular.append((tc, None))
+
+        # --- Completed regular tools (collapsible) ---
+        slots = max(0, MAX_VISIBLE_TOOLS - len(running_regular))
+        hidden = completed_regular[:-slots] if slots and len(completed_regular) > slots else (completed_regular if not slots else [])
+        visible = completed_regular[-slots:] if slots else []
+
+        if hidden:
+            ok = sum(1 for _, tr in hidden if is_success(tr.get('content', '')))
+            fail = len(hidden) - ok
+            summary = Text()
+            summary.append(f"\u2713 {ok} completed", style="dim green")
+            if fail > 0:
+                summary.append(f" | {fail} failed", style="dim red")
+            elements.append(summary)
+
+        for tc, tr in visible:
+            elements.append(_render_tool_call_line(tc, tr))
+            content = tr.get('content', '') if tr else ''
+            if tr and not is_success(content):
+                result_elements = format_tool_result_compact(
+                    tr['name'], content, max_lines=5,
+                )
+                elements.extend(result_elements)
+
+        # --- Running regular tools (limit visible) ---
+        hidden_running = len(running_regular) - MAX_VISIBLE_RUNNING
+        if hidden_running > 0:
+            summary = Text()
+            summary.append(f"\u25cf {hidden_running} more running...", style="dim yellow")
+            elements.append(summary)
+            running_regular = running_regular[-MAX_VISIBLE_RUNNING:]
+
+        for tc, tr in running_regular:
+            elements.append(_render_tool_call_line(tc, tr))
+            spinner = Spinner("dots", text=" Running...", style="yellow")
+            elements.append(spinner)
+
+        # Task tool calls are rendered as part of sub-agent sections below
+
+    # Response text handling
+    has_pending_tools = len(tool_calls) > len(tool_results)
+    any_active_subagent = any(sa.is_active for sa in subagents)
+    has_used_tools = len(tool_calls) > 0
+    all_done = not has_pending_tools and not any_active_subagent and not is_processing
+
+    # Intermediate narration (tools still running) -- dim italic above Task List
+    if latest_text and has_used_tools and not all_done:
+        preview = latest_text.strip()
+        if preview:
+            last_line = preview.split("\n")[-1].strip()
+            if last_line:
+                if len(last_line) > 60:
+                    last_line = last_line[:57] + "\u2026"
+                elements.append(Text(f"    {last_line}", style="dim italic"))
+
+    # Task List panel (persistent, updates on write_todos / read_todos)
+    todo_items = todo_items or []
+    if todo_items:
+        elements.append(Text(""))  # blank separator
+        elements.append(_render_todo_panel(todo_items))
+
+    # Sub-agent activity sections
+    # Active: full bordered view; Completed: compact 1-line summary
+    for sa in subagents:
+        if sa.tool_calls or sa.is_active:
+            elements.extend(_render_subagent_section(sa, compact=not sa.is_active))
+
+    # Processing state after tool execution
+    if is_processing and not is_thinking and not is_responding and not response_text:
+        # Check if any sub-agent is active
+        any_active = any(sa.is_active for sa in subagents)
+        if not any_active:
+            spinner = Spinner("dots", text=" Analyzing results...", style="cyan")
+            elements.append(spinner)
+
+    # Final response -- render as Markdown when all work is done
+    if response_text and all_done:
+        elements.append(Text(""))  # blank separator
+        elements.append(Markdown(response_text))
+    elif is_responding and not thinking_text and not has_pending_tools:
+        elements.append(Text("Generating response...", style="dim"))
+
+    return Group(*elements) if elements else Text("Processing...", style="dim")
+
+
+# ---------------------------------------------------------------------------
+# Final results display
+# ---------------------------------------------------------------------------
+
+def display_final_results(
+    state: StreamState,
+    thinking_max_length: int = DisplayLimits.THINKING_FINAL,
+    show_thinking: bool = True,
+    show_tools: bool = True,
+) -> None:
+    """Display final results after streaming completes."""
+    if show_thinking and state.thinking_text:
+        display_thinking = state.thinking_text
+        if len(display_thinking) > thinking_max_length:
+            half = thinking_max_length // 2
+            display_thinking = display_thinking[:half] + "\n\n... (truncated) ...\n\n" + display_thinking[-half:]
+        console.print(Panel(
+            Text(display_thinking, style="dim"),
+            title="Thinking",
+            border_style="blue",
+        ))
+
+    if show_tools and state.tool_calls:
+        shown_sa_names: set[str] = set()
+
+        for i, tc in enumerate(state.tool_calls):
+            has_result = i < len(state.tool_results)
+            tr = state.tool_results[i] if has_result else None
+            content = tr.get('content', '') if tr is not None else ''
+            is_task = tc.get('name', '').lower() == 'task'
+
+            # Task tools: show delegation line + compact sub-agent summary
+            if is_task:
+                console.print(_render_tool_call_line(tc, tr))
+                sa_name = tc.get('args', {}).get('subagent_type', '')
+                task_desc = tc.get('args', {}).get('description', '')
+                matched_sa = None
+                for sa in state.subagents:
+                    if sa.name == sa_name or (task_desc and task_desc in (sa.description or '')):
+                        matched_sa = sa
+                        break
+                if matched_sa:
+                    shown_sa_names.add(matched_sa.name)
+                    for elem in _render_subagent_section(matched_sa, compact=True):
+                        console.print(elem)
+                continue
+
+            # Regular tools: show tool call line + result
+            console.print(_render_tool_call_line(tc, tr))
+            if has_result and tr is not None:
+                result_elements = format_tool_result_compact(
+                    tr['name'],
+                    content,
+                    max_lines=10,
+                )
+                for elem in result_elements:
+                    console.print(elem)
+
+        # Render any sub-agents not already shown via task tool calls
+        for sa in state.subagents:
+            if sa.name not in shown_sa_names and (sa.tool_calls or sa.is_active):
+                for elem in _render_subagent_section(sa, compact=True):
+                    console.print(elem)
+
+        console.print()
+
+    # Task List panel in final output
+    if state.todo_items:
+        console.print(_render_todo_panel(state.todo_items))
+        console.print()
+
+    if state.response_text:
+        # Strip trailing standalone "..." lines
+        clean_response = state.response_text.rstrip()
+        while clean_response.endswith("\n...") or clean_response.rstrip() == "...":
+            clean_response = clean_response.rstrip().removesuffix("...").rstrip()
+        console.print()
+        console.print(Markdown(clean_response or state.response_text))
+        console.print()
+
+
+# ---------------------------------------------------------------------------
+# Async-to-sync bridge
+# ---------------------------------------------------------------------------
+
+def _run_streaming(
+    agent: Any,
+    message: str,
+    thread_id: str,
+    show_thinking: bool,
+    interactive: bool,
+) -> None:
+    """Run async streaming and render with Rich Live display.
+
+    Bridges the async stream_agent_events() into synchronous Rich Live rendering
+    using asyncio.run().
+
+    Args:
+        agent: Compiled agent graph
+        message: User message
+        thread_id: Thread ID
+        show_thinking: Whether to show thinking panel
+        interactive: If True, use simplified final display (no panel)
+    """
+    state = StreamState()
+
+    async def _consume() -> None:
+        async for event in stream_agent_events(agent, message, thread_id):
+            event_type = state.handle_event(event)
+            live.update(create_streaming_display(
+                **state.get_display_args(),
+                show_thinking=show_thinking,
+            ))
+            if event_type in (
+                "tool_call", "tool_result",
+                "subagent_start", "subagent_tool_call",
+                "subagent_tool_result", "subagent_end",
+            ):
+                live.refresh()
+
+    with Live(console=console, refresh_per_second=10, transient=True) as live:
+        live.update(create_streaming_display(is_waiting=True))
+        asyncio.run(_consume())
+
+    if interactive:
+        display_final_results(
+            state,
+            thinking_max_length=500,
+            show_thinking=False,
+            show_tools=True,
+        )
+    else:
+        console.print()
+        display_final_results(
+            state,
+            show_tools=True,
+        )