pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/ui/shell/components/tool_execution.py

@@ -0,0 +1,261 @@
+"""Pythinker tool execution card.
+
+Wraps a registered :class:`ToolRenderDefinition` and renders it as a card
+with a status-tinted background. Mirrors
+
+in the  codebase.
+
+The card lifecycle:
+
+* arguments stream in        → status = ``PENDING``,  bg = ``tool_pending_bg``
+* execution starts           → status = ``RUNNING``,  bg = ``tool_pending_bg``
+* result arrives, no error   → status = ``SUCCESS``,  no background tint
+* result arrives, error      → status = ``ERROR``,    bg = ``tool_error_bg``
+* user cancels / denies      → status = ``CANCELLED`` / ``DENIED``
+
+If the renderer produces no visible output for the current state, the
+component renders an empty string (the ``hidden-component`` behavior).
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+from rich.console import Group, RenderableType
+from rich.padding import Padding
+from rich.style import Style
+from rich.text import Text
+
+from pythinker_code.ui.shell.components.key_hints import key_hint
+from pythinker_code.ui.shell.components.render_utils import render_message_response
+from pythinker_code.ui.shell.tool_renderers import (
+    ToolRenderContext,
+    ToolRenderDefinition,
+    ToolResultPayload,
+)
+from pythinker_code.ui.theme import tui_rich_style
+
+
+class ToolExecutionStatus(Enum):
+    """Lifecycle states of a tool call card."""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    SUCCESS = "success"
+    ERROR = "error"
+    DENIED = "denied"
+    CANCELLED = "cancelled"
+
+
+_PENDING_LIKE = frozenset({ToolExecutionStatus.PENDING, ToolExecutionStatus.RUNNING})
+
+
+@dataclass(slots=True)
+class _CallState:
+    """Snapshot of the inputs the component needs to compose a render."""
+
+    tool_name: str
+    tool_call_id: str
+    cwd: str = ""
+    args: dict[str, Any] | None = None
+    args_complete: bool = False
+    execution_started: bool = False
+    expanded: bool = False
+    result: ToolResultPayload | None = None
+    is_partial: bool = False
+
+
+class ToolExecutionComponent:
+    """Single tool invocation rendered as a Pythinker card."""
+
+    def __init__(
+        self,
+        tool_name: str,
+        tool_call_id: str,
+        *,
+        definition: ToolRenderDefinition,
+        cwd: str = "",
+    ) -> None:
+        self._definition = definition
+        self._state = _CallState(tool_name=tool_name, tool_call_id=tool_call_id, cwd=cwd)
+        self._started_at = time.monotonic()
+        self._finished_elapsed_s: float | None = None
+        self._renderer_state: dict[str, Any] = {"__tool_name__": tool_name}
+        self._status = ToolExecutionStatus.PENDING
+
+    # -- Mutators ------------------------------------------------------------
+
+    def update_args(self, args: dict[str, Any]) -> None:
+        self._state.args = args
+
+    def set_args_complete(self) -> None:
+        self._state.args_complete = True
+
+    def mark_execution_started(self) -> None:
+        self._state.execution_started = True
+        if self._status == ToolExecutionStatus.PENDING:
+            self._status = ToolExecutionStatus.RUNNING
+
+    def set_result(
+        self,
+        result: ToolResultPayload,
+        *,
+        is_partial: bool = False,
+    ) -> None:
+        self._state.result = result
+        self._state.is_partial = is_partial
+        if is_partial:
+            self._status = ToolExecutionStatus.RUNNING
+        else:
+            if self._finished_elapsed_s is None:
+                self._finished_elapsed_s = max(0.0, time.monotonic() - self._started_at)
+            self._status = (
+                ToolExecutionStatus.ERROR if result.is_error else ToolExecutionStatus.SUCCESS
+            )
+
+    def set_status(self, status: ToolExecutionStatus) -> None:
+        """Force a specific status (e.g. DENIED, CANCELLED)."""
+        self._status = status
+
+    def set_expanded(self, expanded: bool) -> None:
+        self._state.expanded = expanded
+
+    @property
+    def status(self) -> ToolExecutionStatus:
+        return self._status
+
+    @property
+    def expanded(self) -> bool:
+        return self._state.expanded
+
+    @property
+    def tool_call_id(self) -> str:
+        return self._state.tool_call_id
+
+    def invalidate(self) -> None:  # pragma: no cover — protocol stub
+        """Drop cached output. Currently a no-op (no caching layer yet)."""
+
+    # -- Rendering -----------------------------------------------------------
+
+    def render(self, width: int = 0) -> RenderableType:  # noqa: ARG002 — width reserved
+        """Return the card renderable for the current state.
+
+        *width* is accepted for protocol compatibility; Rich console width
+        is the source of truth at print time.
+        """
+        if width <= 0:
+            try:
+                from pythinker_code.ui.shell.console import console
+
+                width = console.size.width
+            except Exception:  # noqa: BLE001 - rendering must not fail on width lookup
+                width = 100
+        ctx = self._build_context(width=width)
+        children: list[RenderableType] = []
+
+        if self._definition.render_call is not None:
+            try:
+                call = self._definition.render_call(ctx)
+            except Exception:  # noqa: BLE001 — renderer crash falls back to header
+                call = self._call_fallback()
+            if call is not None:
+                children.append(call)
+        else:
+            children.append(self._call_fallback())
+
+        result = self._state.result
+        if result is not None and self._definition.render_result is not None:
+            try:
+                rendered_result = self._definition.render_result(ctx, result)
+            except Exception:  # noqa: BLE001
+                rendered_result = self._result_fallback()
+            if rendered_result is not None:
+                children.append(rendered_result)
+        elif result is not None:
+            fallback = self._result_fallback()
+            if fallback is not None:
+                children.append(fallback)
+
+        if not self._state.expanded and self._is_truncatable():
+            children.append(key_hint("Ctrl+E", "expand"))
+
+        if not children:
+            return Text("")
+
+        if len(children) <= 1:
+            body: RenderableType = children[0] if children else Text("")
+        else:
+            # Reference layout: tool header first, then response/progress rows
+            # immediately below under the dim ``⎿`` gutter. No spacer — the
+            # gutter is the visual separation.
+            body = Group(
+                children[0],
+                *(render_message_response(child) for child in children[1:]),
+            )
+
+        if self._definition.render_shell == "self":
+            return body
+
+        bg_style = self._background_style()
+        if bg_style is None:
+            return body
+        # Padding with style fills the padded area with the tint, giving the
+        # "content box" feel without an extra border character.
+        return Padding(body, (1, 1), style=bg_style)
+
+    # -- Internals -----------------------------------------------------------
+
+    def _build_context(self, *, width: int = 0) -> ToolRenderContext:
+        return ToolRenderContext(
+            args=self._state.args or {},
+            tool_call_id=self._state.tool_call_id,
+            cwd=self._state.cwd,
+            execution_started=self._state.execution_started,
+            args_complete=self._state.args_complete,
+            is_partial=self._state.is_partial,
+            has_result=self._state.result is not None,
+            expanded=self._state.expanded,
+            is_error=self._state.result.is_error if self._state.result else False,
+            elapsed_s=self._elapsed_s(),
+            width=width if width > 0 else 100,
+            state=self._renderer_state,
+        )
+
+    def _elapsed_s(self) -> float | None:
+        if self._finished_elapsed_s is not None:
+            return self._finished_elapsed_s
+        if self._state.execution_started:
+            return max(0.0, time.monotonic() - self._started_at)
+        return None
+
+    def _background_style(self) -> Style | None:
+        if self._status == ToolExecutionStatus.SUCCESS:
+            return None
+        if self._status == ToolExecutionStatus.ERROR or self._status == ToolExecutionStatus.DENIED:
+            token = "tool_error_bg"
+        elif self._status in _PENDING_LIKE:
+            token = "tool_pending_bg"
+        else:
+            token = "tool_pending_bg"
+        return tui_rich_style(token)
+
+    def _call_fallback(self) -> RenderableType:
+        return Text(self._definition.label or self._state.tool_name, style="bold")
+
+    def _result_fallback(self) -> RenderableType | None:
+        result = self._state.result
+        if result is None or not result.text:
+            return None
+        style = "red" if result.is_error else "grey70"
+        return Text(result.text, style=style)
+
+    def _is_truncatable(self) -> bool:
+        """Heuristic: only show the expand hint when there's likely more to see."""
+        result = self._state.result
+        if result is None or not result.text:
+            return False
+        text = result.text
+        return len(text) > 240 or text.count("\n") > 4

pythinker_code/ui/shell/console.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import os
+import pydoc
+import re
+
+from rich.console import Console, PagerContext, RenderableType
+from rich.pager import Pager
+from rich.theme import Theme
+
+NEUTRAL_MARKDOWN_THEME = Theme(
+    {
+        "markdown.paragraph": "none",
+        "markdown.block_quote": "none",
+        "markdown.hr": "none",
+        "markdown.list": "none",
+        "markdown.item": "none",
+        "markdown.item.bullet": "none",
+        "markdown.item.number": "none",
+        "markdown.link": "none",
+        "markdown.link_url": "none",
+        "markdown.h1": "none",
+        "markdown.h1.border": "none",
+        "markdown.h2": "none",
+        "markdown.h3": "none",
+        "markdown.h4": "none",
+        "markdown.h5": "none",
+        "markdown.h6": "none",
+        "markdown.h7": "none",
+        "markdown.em": "none",
+        "markdown.emph": "none",
+        "markdown.strong": "none",
+        "markdown.s": "none",
+        "markdown.code": "none",
+        "markdown.code_block": "none",
+        "status.spinner": "none",
+    },
+    inherit=True,
+)
+
+_NEUTRAL_MARKDOWN_THEME = NEUTRAL_MARKDOWN_THEME
+
+
+class _PythinkerPager(Pager):
+    """Pager that ignores MANPAGER to avoid garbled output.
+
+    ``pydoc.getpager()`` reads ``MANPAGER`` before ``PAGER``.  When the user
+    sets ``MANPAGER`` to a man-specific pipeline (e.g.
+    ``sh -c 'col -bx | bat -l man -p'``), that pipeline mangles the ANSI
+    rich-text we emit.  This pager strips ``MANPAGER`` from the subprocess
+    environment so only ``PAGER`` (or the default ``less``) is used.
+    """
+
+    def show(self, content: str) -> None:
+        saved = os.environ.pop("MANPAGER", None)
+        try:
+            pydoc.pager(content)
+        finally:
+            if saved is not None:
+                os.environ["MANPAGER"] = saved
+
+
+class _PythinkerConsole(Console):
+    """Console subclass that defaults to :class:`_PythinkerPager`."""
+
+    def pager(
+        self,
+        pager: Pager | None = None,
+        styles: bool = False,
+        links: bool = False,
+    ) -> PagerContext:
+        if pager is None:
+            pager = _PythinkerPager()
+        return super().pager(pager=pager, styles=styles, links=links)
+
+
+console = _PythinkerConsole(highlight=False, theme=NEUTRAL_MARKDOWN_THEME)
+
+
+# Matches OSC 8 hyperlink open/close markers emitted by Rich's Style(link=...).
+# Format: ESC ] 8 ; <params> ; <uri> ST   where ST is ESC \ or BEL (\x07).
+# prompt_toolkit's ANSI parser does not understand OSC 8 and renders the raw
+# escape bytes as visible garbage (e.g. "8;id=391551;https://…").  We wrap each
+# marker in \001…\002 so prompt_toolkit treats it as a ZeroWidthEscape and
+# passes it through to the terminal via write_raw, preserving clickable links.
+_OSC8_RE = re.compile(r"\x1b\]8;[^\x07\x1b]*(?:\x1b\\|\x07)")
+
+
+def _wrap_osc8_as_zero_width(m: re.Match[str]) -> str:
+    """Wrap an OSC 8 marker in \\001…\\002 for prompt_toolkit ZeroWidthEscape."""
+    return f"\x01{m.group(0)}\x02"
+
+
+def render_to_ansi(renderable: RenderableType, *, columns: int) -> str:
+    """Render a Rich renderable to an ANSI string for prompt_toolkit integration."""
+    from io import StringIO
+
+    width = max(20, columns)
+    buf = StringIO()
+    temp = Console(
+        file=buf,
+        force_terminal=True,
+        width=width,
+        theme=NEUTRAL_MARKDOWN_THEME,
+        highlight=False,
+    )
+    temp.print(renderable, end="")
+    result = buf.getvalue()
+    return _OSC8_RE.sub(_wrap_osc8_as_zero_width, result)

pythinker_code/ui/shell/debug.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from pythinker_core.message import Message
+from rich.console import Group, RenderableType
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.syntax import Syntax
+from rich.text import Text
+
+from pythinker_code.soul.pythinkersoul import PythinkerSoul
+from pythinker_code.ui.shell.console import console
+from pythinker_code.ui.shell.slash import registry
+from pythinker_code.wire.types import (
+    AudioURLPart,
+    ContentPart,
+    ImageURLPart,
+    TextPart,
+    ThinkPart,
+    ToolCall,
+    VideoURLPart,
+)
+
+if TYPE_CHECKING:
+    from pythinker_code.ui.shell import Shell
+
+
+def _format_content_part(part: ContentPart) -> Text | Panel | Group:
+    """Format a single content part."""
+    match part:
+        case TextPart(text=text):
+            # Check if it looks like a system tag
+            if text.strip().startswith("<system>") and text.strip().endswith("</system>"):
+                return Panel(
+                    text.strip()[8:-9].strip(),
+                    title="[dim]system[/dim]",
+                    border_style="dim yellow",
+                    padding=(0, 1),
+                )
+            return Text(text, style="white")
+
+        case ThinkPart(think=think):
+            return Panel(
+                think,
+                title="[dim]thinking[/dim]",
+                border_style="dim cyan",
+                padding=(0, 1),
+            )
+
+        case ImageURLPart(image_url=img):
+            url_display = img.url[:80] + "..." if len(img.url) > 80 else img.url
+            return Text(f"[Image] {url_display}", style="blue")
+
+        case AudioURLPart(audio_url=audio):
+            url_display = audio.url[:80] + "..." if len(audio.url) > 80 else audio.url
+            id_text = f" (id: {audio.id})" if audio.id else ""
+            return Text(f"[Audio{id_text}] {url_display}", style="blue")
+
+        case VideoURLPart(video_url=video):
+            url_display = video.url[:80] + "..." if len(video.url) > 80 else video.url
+            return Text(f"[Video] {url_display}", style="blue")
+
+        case _:
+            return Text(f"[Unknown content type: {type(part).__name__}]", style="red")
+
+
+def _format_tool_call(tool_call: ToolCall) -> Panel:
+    """Format a tool call."""
+    args = tool_call.function.arguments or "{}"
+    try:
+        args_formatted = json.dumps(json.loads(args, strict=False), indent=2)
+        args_syntax = Syntax(args_formatted, "json", theme="monokai", padding=(0, 1))
+    except json.JSONDecodeError:
+        args_syntax = Text(args, style="red")
+
+    content = Group(
+        Text(f"Function: {tool_call.function.name}", style="bold cyan"),
+        Text(f"Call ID: {tool_call.id}", style="dim"),
+        Text("Arguments:", style="bold"),
+        args_syntax,
+    )
+
+    return Panel(
+        content,
+        title="[bold yellow]Tool Call[/bold yellow]",
+        border_style="yellow",
+        padding=(0, 1),
+    )
+
+
+def _format_message(msg: Message, index: int) -> Panel:
+    """Format a single message."""
+    # Role styling
+    role_colors = {
+        "system": "magenta",
+        "developer": "magenta",
+        "user": "green",
+        "assistant": "blue",
+        "tool": "yellow",
+    }
+    role_color = role_colors.get(msg.role, "white")
+    role_text = f"[bold {role_color}]{msg.role.upper()}[/bold {role_color}]"
+
+    # Add name if present
+    if msg.name:
+        role_text += f" [dim]({msg.name})[/dim]"
+
+    # Add tool call ID for tool messages
+    if msg.tool_call_id:
+        role_text += f" [dim]→ {msg.tool_call_id}[/dim]"
+
+    # Format content
+    content_items: list[RenderableType] = []
+
+    for part in msg.content:
+        formatted = _format_content_part(part)
+        content_items.append(formatted)
+
+    # Add tool calls if present
+    if msg.tool_calls:
+        if content_items:
+            content_items.append(Text())  # Empty line
+        for tool_call in msg.tool_calls:
+            content_items.append(_format_tool_call(tool_call))
+
+    # Combine all content
+    if not content_items:
+        content_items.append(Text("[empty message]", style="dim italic"))
+
+    group = Group(*content_items)
+
+    # Create panel
+    title = f"#{index + 1} {role_text}"
+    if msg.partial:
+        title += " [dim italic](partial)[/dim italic]"
+
+    return Panel(
+        group,
+        title=title,
+        border_style=role_color,
+        padding=(0, 1),
+    )
+
+
+@registry.command
+def debug(app: Shell, args: str):
+    """Debug the context"""
+    assert isinstance(app.soul, PythinkerSoul)
+
+    context = app.soul.context
+    history = context.history
+
+    if not history:
+        console.print(
+            Panel(
+                "Context is empty - no messages yet",
+                border_style="yellow",
+                padding=(1, 2),
+            )
+        )
+        return
+
+    # Build the debug output
+    output_items = [
+        Panel(
+            Group(
+                Text(f"Total messages: {len(history)}", style="bold"),
+                Text(f"Token count: {context.token_count:,}", style="bold"),
+                Text(f"Checkpoints: {context.n_checkpoints}", style="bold"),
+                Text(f"Trajectory: {context.file_backend}", style="dim"),
+            ),
+            title="[bold]Context Info[/bold]",
+            border_style="cyan",
+            padding=(0, 1),
+        ),
+        Rule(style="dim"),
+    ]
+
+    # Add all messages
+    for idx, msg in enumerate(history):
+        output_items.append(_format_message(msg, idx))
+
+    # Display using rich pager
+    display_group = Group(*output_items)
+
+    # Use pager to display
+    with console.pager(styles=True):
+        console.print(display_group)

pythinker_code/ui/shell/echo.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from pythinker_core.message import Message
+from rich.console import RenderableType
+from rich.text import Text
+
+from pythinker_code.ui.shell.components import render_user_message
+from pythinker_code.ui.shell.prompt import PROMPT_SYMBOL
+from pythinker_code.ui.tui_config import is_card_style
+from pythinker_code.utils.message import message_stringify
+
+
+def render_user_echo(message: Message) -> RenderableType:
+    """Render a user message as transcript output.
+
+    Legacy style keeps the compact sparkle-prefixed echo. Card style renders
+    the text in a tinted full-width block without the prompt sparkle, as if
+    the submitted buffer became a message.
+    """
+    text = message_stringify(message)
+    if is_card_style():
+        return render_user_message(text)
+    return Text(f"{PROMPT_SYMBOL} {text}")
+
+
+def render_user_echo_text(text: str) -> RenderableType:
+    """Render the local prompt text exactly as the user saw it in the buffer."""
+    if is_card_style():
+        return render_user_message(text)
+    return Text(f"{PROMPT_SYMBOL} {text}")