pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/ui/shell/tool_renderers/_render_utils.py

@@ -0,0 +1,168 @@
+"""Shared helpers for Pythinker tool renderers."""
+
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+from typing import Any
+
+from rich.console import Group, RenderableType
+from rich.style import Style as RichStyle
+from rich.table import Table
+from rich.text import Text
+
+from pythinker_code.ui.shell.components import sanitize_ansi
+from pythinker_code.ui.theme import tui_rich_style
+
+__all__ = [
+    "as_str",
+    "fg",
+    "format_lines_block",
+    "invalid_arg",
+    "loading_marker",
+    "running_spinner",
+    "shorten_path",
+    "tab_to_spaces",
+    "tool_title",
+]
+
+
+def as_str(value: Any) -> str | None:
+    """the ``str(...)`` helper: keep strings, return ``None`` for anything else.
+
+    The renderer treats ``None`` as "missing" (placeholder) and a non-string
+    value as "invalid".
+    """
+    if value is None:
+        return None
+    if isinstance(value, str):
+        return value
+    return None
+
+
+def fg(token: str, content: str | Text) -> Text:
+    """Wrap *content* in a Rich Text styled by a TUI theme *token*.
+
+    Mirrors the ``theme.fg(token, text)``. ``content`` may already be a
+    ``Text`` (style is applied non-destructively).
+    """
+    style = tui_rich_style(token)
+    if isinstance(content, Text):
+        out = content.copy()
+        out.stylize(style)
+        return out
+    return Text(content, style=style)
+
+
+def tool_title(label: str) -> Text:
+    """Bold tool-name title ."""
+    base = tui_rich_style("tool_title")
+    return Text(label, style=base + RichStyle(bold=True))
+
+
+def loading_marker(*, done: bool = False, pulse: bool = True, now: float | None = None) -> Text:
+    """Return the app-wide solid-circle task marker.
+
+    Running tasks pulse by disappearing/reappearing; completed tasks use green.
+    The animated braille spinner is reserved for the bottom thinking-word status.
+    """
+    style = tui_rich_style("success" if done else "muted")
+    if done or not pulse:
+        return Text("● ", style=style)
+    t = time.monotonic() if now is None else now
+    glyph = "●" if int(t / 0.8) % 2 == 0 else " "
+    return Text(f"{glyph} ", style=style)
+
+
+def running_spinner(
+    renderable: RenderableType,
+    *,
+    execution_started: bool,
+    has_result: bool,
+) -> RenderableType:
+    """Wrap *renderable* in the solid loading marker while the tool is executing.
+
+    Returns *renderable* unchanged once a result has arrived (or if execution
+    has not yet been dispatched), so callers need no guard of their own.
+    """
+    if not (execution_started and not has_result):
+        return renderable
+
+    marker = loading_marker()
+    if isinstance(renderable, Text):
+        out = marker.copy()
+        out.append_text(renderable)
+        return out
+
+    table = Table.grid(padding=0)
+    table.add_column(width=2, no_wrap=True)
+    table.add_column(ratio=1)
+    table.add_row(marker, renderable)
+    return Group(table)
+
+
+def invalid_arg() -> Text:
+    """Placeholder rendered when an arg is not a valid string."""
+    return fg("error", "<invalid>")
+
+
+def shorten_path(path: str, *, cwd: str | None = None) -> str:
+    """Display-shorten an absolute path in the standard way.
+
+    * paths inside ``cwd`` are made relative;
+    * paths inside ``$HOME`` are prefixed with ``~``;
+    * other absolute paths stay absolute.
+    """
+    if not path:
+        return path
+    cwd = cwd or os.getcwd()
+    try:
+        p = Path(path)
+        if p.is_absolute():
+            try:
+                rel = p.relative_to(cwd)
+                s = str(rel)
+                return s if s != "." else path
+            except ValueError:
+                home = Path.home()
+                try:
+                    rel = p.relative_to(home)
+                    return f"~/{rel}" if str(rel) != "." else "~"
+                except ValueError:
+                    return path
+        return path
+    except (TypeError, ValueError):
+        return path
+
+
+def tab_to_spaces(text: str, *, tab_size: int = 4) -> str:
+    """Replace tabs with spaces; preserves newlines."""
+    if "\t" not in text:
+        return text
+    return text.expandtabs(tab_size)
+
+
+def format_lines_block(
+    text: str,
+    *,
+    expanded: bool,
+    collapsed_max_lines: int,
+    style_token: str = "tool_output",
+) -> tuple[Text, int]:
+    """Render *text* as a block of styled lines, capped at *collapsed_max_lines*.
+
+    Returns a ``(rendered, remaining)`` tuple where *remaining* is the number
+    of lines hidden by the collapsed view (``0`` when expanded or short).
+    Always strips ANSI from input to keep layout safe.
+    """
+    cleaned = sanitize_ansi(text or "").rstrip("\n")
+    if not cleaned:
+        return Text(""), 0
+    lines = cleaned.split("\n")
+    max_lines = len(lines) if expanded else max(0, collapsed_max_lines)
+    shown = lines[:max_lines] if max_lines else []
+    remaining = max(0, len(lines) - len(shown))
+    body = Text("\n".join(tab_to_spaces(line) for line in shown))
+    body.stylize(tui_rich_style(style_token))
+    return body, remaining

pythinker_code/ui/shell/tool_renderers/agent.py

@@ -0,0 +1,140 @@
+"""Pythinker renderer for the ``Agent`` (subagent) tool.
+
+The Agent tool is single-spawn; this renderer covers the single variant
+only (spawn, run, surface the final result).
+"""
+
+from __future__ import annotations
+
+from rich.console import Group, RenderableType
+from rich.style import Style as RichStyle
+from rich.text import Text
+
+from pythinker_code.ui.shell.tool_renderers import (
+    ToolRenderContext,
+    ToolRenderDefinition,
+    ToolResultPayload,
+)
+from pythinker_code.ui.shell.tool_renderers._render_utils import (
+    as_str,
+    fg,
+    format_lines_block,
+    invalid_arg,
+    loading_marker,
+    running_spinner,
+    tool_title,
+)
+from pythinker_code.ui.theme import tui_rich_style
+from pythinker_code.utils.datetime import format_elapsed
+
+_TOOL_NAME = "Agent"
+_DEFAULT_COLLAPSED_LINES = 6
+_PROMPT_PREVIEW_CHARS = 80
+_BACKGROUND_ACTIVE_STATUSES = frozenset({"created", "starting", "running", "awaiting_approval"})
+
+
+def _truncate(text: str, max_chars: int) -> str:
+    if len(text) <= max_chars:
+        return text
+    return text[: max_chars - 1].rstrip() + "…"
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    subagent_type = as_str(args.get("subagent_type")) or "coder"
+    description = as_str(args.get("description"))
+    prompt = as_str(args.get("prompt"))
+    resume = as_str(args.get("resume"))
+    run_bg = bool(args.get("run_in_background"))
+    model = as_str(args.get("model"))
+
+    header = Text()
+    header.append_text(tool_title("subagent"))
+    header.append(" ")
+    header.append_text(fg("accent", subagent_type))
+    if description:
+        header.append_text(fg("muted", f" [{description}]"))
+    if model:
+        header.append_text(fg("dim", f" ({model})"))
+    if run_bg:
+        header.append_text(fg("muted", " (background)"))
+    if resume:
+        header.append_text(fg("muted", f" (resume {resume[:8]})"))
+
+    # Active subagent affordance: a running subagent gets the shared solid
+    # loading marker. Animated dots are reserved for the bottom thinking words.
+    head = running_spinner(
+        header,
+        execution_started=ctx.execution_started,
+        has_result=ctx.has_result,
+    )
+
+    if prompt is None:
+        if "prompt" in args:
+            return Group(head, invalid_arg())
+        return head
+    preview_line = _truncate(prompt.split("\n", 1)[0], _PROMPT_PREVIEW_CHARS)
+    body = fg("dim", f"  {preview_line}")
+    return Group(head, body)
+
+
+def _line_value(text: str, key: str) -> str | None:
+    prefix = f"{key}:"
+    for line in text.splitlines():
+        if line.startswith(prefix):
+            return line[len(prefix) :].strip()
+    return None
+
+
+def _background_status(text: str) -> str | None:
+    kind = _line_value(text, "kind")
+    status = _line_value(text, "status")
+    if kind == "agent" and status in _BACKGROUND_ACTIVE_STATUSES:
+        return status
+    return None
+
+
+def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> RenderableType | None:
+    if not result.text:
+        return None
+    background_status = None if result.is_error else _background_status(result.text)
+    if background_status is not None:
+        description = as_str(ctx.args.get("description"))
+        label = "background subagent working"
+        if description:
+            label = f"{label}: {description}"
+        line = loading_marker()
+        line.append(label, style=tui_rich_style("muted"))
+        return Group(line, fg("dim", f"  status: {background_status}"))
+    # Distinct success symbol so the eye doesn't mistake a finished subagent
+    # for a generic tool tick — heavy check on success, heavy ballot on error.
+    icon = fg("error", "✘") if result.is_error else fg("success", "✔")
+    body, remaining = format_lines_block(
+        result.text,
+        expanded=ctx.expanded,
+        collapsed_max_lines=_DEFAULT_COLLAPSED_LINES,
+        style_token="error" if result.is_error else "tool_output",
+    )
+    head = Text()
+    head.append_text(icon)
+    head.append(" ")
+    head.append("subagent finished", style=tui_rich_style("muted") + RichStyle(bold=True))
+    if ctx.elapsed_s is not None:
+        head.append(
+            f" · Crunched for {format_elapsed(ctx.elapsed_s)}", style=tui_rich_style("muted")
+        )
+    if not body.plain:
+        return head
+    if remaining > 0:
+        more = fg("muted", f"... ({remaining} more lines, ctrl+e to expand)")
+        return Group(head, body, more)
+    return Group(head, body)
+
+
+AGENT_RENDERER = ToolRenderDefinition(
+    name=_TOOL_NAME,
+    label="subagent",
+    render_shell="default",
+    render_call=_render_call,
+    render_result=_render_result,
+)

pythinker_code/ui/shell/tool_renderers/ask_user.py

@@ -0,0 +1,93 @@
+"""Pythinker renderer for Pythinker's ``AskUserQuestion`` tool.
+
+Shows the first question + its option labels in the call preview, plus
+a count badge when there are multiple questions. The result preview is
+the user's selection summary (or auto-dismiss note).
+"""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from rich.console import Group, RenderableType
+from rich.text import Text
+
+from pythinker_code.ui.shell.tool_renderers import (
+    ToolRenderContext,
+    ToolRenderDefinition,
+    ToolResultPayload,
+)
+from pythinker_code.ui.shell.tool_renderers._render_utils import (
+    as_str,
+    fg,
+    format_lines_block,
+    invalid_arg,
+    tool_title,
+)
+
+_TOOL_NAME = "AskUserQuestion"
+_DEFAULT_COLLAPSED_LINES = 8
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    questions = args.get("questions")
+
+    header = Text()
+    header.append_text(tool_title("ask user"))
+    if not isinstance(questions, list) or not questions:
+        if "questions" in args:
+            return Group(header, invalid_arg())
+        header.append_text(fg("muted", " ..."))
+        return header
+
+    questions_list = cast("list[Any]", questions)
+    qs: list[dict[str, Any]] = [
+        cast("dict[str, Any]", q) for q in questions_list if isinstance(q, dict)
+    ]
+    if len(qs) > 1:
+        header.append_text(fg("muted", f" ({len(qs)} questions)"))
+
+    children: list[RenderableType] = [header]
+    for q in qs[:2]:
+        question_text = as_str(q.get("question")) or ""
+        if question_text:
+            children.append(fg("accent", f"  ? {question_text}"))
+        opts = q.get("options")
+        if isinstance(opts, list):
+            opts_list = cast("list[Any]", opts)
+            for opt in opts_list[:4]:
+                if not isinstance(opt, dict):
+                    continue
+                opt_dict = cast("dict[str, Any]", opt)
+                label = as_str(opt_dict.get("label")) or "?"
+                children.append(fg("dim", f"    • {label}"))
+    if len(qs) > 2:
+        children.append(fg("muted", f"  ... +{len(qs) - 2} more"))
+    return Group(*children)
+
+
+def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> RenderableType | None:
+    if not result.text:
+        return None
+    body, remaining = format_lines_block(
+        result.text,
+        expanded=ctx.expanded,
+        collapsed_max_lines=_DEFAULT_COLLAPSED_LINES,
+        style_token="error" if result.is_error else "tool_output",
+    )
+    if not body.plain:
+        return None
+    if remaining > 0:
+        more = fg("muted", f"... ({remaining} more lines, ctrl+e to expand)")
+        return Group(body, more)
+    return body
+
+
+ASK_USER_RENDERER = ToolRenderDefinition(
+    name=_TOOL_NAME,
+    label="ask user",
+    render_shell="default",
+    render_call=_render_call,
+    render_result=_render_result,
+)

pythinker_code/ui/shell/tool_renderers/background.py

@@ -0,0 +1,144 @@
+"""Pythinker renderers for Pythinker's background-task tools.
+
+Covers ``TaskList``, ``TaskOutput``, and ``TaskStop``.
+"""
+
+from __future__ import annotations
+
+from rich.console import Group, RenderableType
+from rich.text import Text
+
+from pythinker_code.ui.shell.tool_renderers import (
+    ToolRenderContext,
+    ToolRenderDefinition,
+    ToolResultPayload,
+)
+from pythinker_code.ui.shell.tool_renderers._render_utils import (
+    as_str,
+    fg,
+    format_lines_block,
+    invalid_arg,
+    running_spinner,
+    tool_title,
+)
+
+
+def _render_call_with_id(
+    label: str, ctx: ToolRenderContext, *, extras: list[str]
+) -> RenderableType:
+    args = ctx.args or {}
+    task_id = as_str(args.get("task_id"))
+    line = Text()
+    line.append_text(tool_title(label))
+    line.append(" ")
+    if task_id is None:
+        if "task_id" in args:
+            line.append_text(invalid_arg())
+        else:
+            line.append_text(fg("muted", "..."))
+    else:
+        line.append_text(fg("accent", task_id))
+    for extra in extras:
+        line.append_text(fg("muted", f" {extra}"))
+    return running_spinner(
+        line,
+        execution_started=ctx.execution_started,
+        has_result=ctx.has_result,
+    )
+
+
+def _render_block_result(
+    ctx: ToolRenderContext,
+    result: ToolResultPayload,
+    *,
+    collapsed_lines: int = 12,
+) -> RenderableType | None:
+    if not result.text:
+        return None
+    body, remaining = format_lines_block(
+        result.text,
+        expanded=ctx.expanded,
+        collapsed_max_lines=collapsed_lines,
+        style_token="error" if result.is_error else "tool_output",
+    )
+    if not body.plain:
+        return None
+    if remaining > 0:
+        return Group(body, fg("muted", f"... ({remaining} more lines, ctrl+e to expand)"))
+    return body
+
+
+# ---------------------------------------------------------------------------
+# TaskList
+# ---------------------------------------------------------------------------
+
+
+def _render_task_list_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    active_only = bool(args.get("active_only", True))
+    limit = args.get("limit")
+    line = Text()
+    line.append_text(tool_title("tasks"))
+    line.append_text(fg("muted", " (active)" if active_only else " (all)"))
+    if isinstance(limit, int) and limit != 20:
+        line.append_text(fg("muted", f" limit {limit}"))
+    return line
+
+
+TASK_LIST_RENDERER = ToolRenderDefinition(
+    name="TaskList",
+    label="tasks",
+    render_shell="default",
+    render_call=_render_task_list_call,
+    render_result=_render_block_result,
+)
+
+
+# ---------------------------------------------------------------------------
+# TaskOutput
+# ---------------------------------------------------------------------------
+
+
+def _render_task_output_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    extras: list[str] = []
+    if args.get("block"):
+        timeout = args.get("timeout")
+        extras.append(
+            f"(block, timeout {timeout}s)"
+            if isinstance(timeout, int) and timeout != 30
+            else "(block)"
+        )
+    return _render_call_with_id("task output", ctx, extras=extras)
+
+
+TASK_OUTPUT_RENDERER = ToolRenderDefinition(
+    name="TaskOutput",
+    label="task output",
+    render_shell="default",
+    render_call=_render_task_output_call,
+    render_result=lambda ctx, r: _render_block_result(ctx, r, collapsed_lines=20),
+)
+
+
+# ---------------------------------------------------------------------------
+# TaskStop
+# ---------------------------------------------------------------------------
+
+
+def _render_task_stop_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    extras: list[str] = []
+    reason = as_str(args.get("reason"))
+    if reason and reason != "Stopped by TaskStop":
+        extras.append(f"({reason})")
+    return _render_call_with_id("task stop", ctx, extras=extras)
+
+
+TASK_STOP_RENDERER = ToolRenderDefinition(
+    name="TaskStop",
+    label="task stop",
+    render_shell="default",
+    render_call=_render_task_stop_call,
+    render_result=_render_block_result,
+)

pythinker_code/ui/shell/tool_renderers/bash.py

@@ -0,0 +1,103 @@
+"""Pythinker renderer for Pythinker's ``Shell`` tool.
+
+  but
+delegates the actual visual treatment to the bordered
+:func:`render_bash_execution` component for completed results, giving the
+shell tool the same look as Pythinker's interactive shell mode.
+
+Source tool name → Pythinker tool name: ``bash`` → ``Shell``.
+Param mapping: Pythinker has ``command``, ``timeout``, ``run_in_background``,
+``description``; Pythinker has ``command``, ``timeout`` only.
+"""
+
+from __future__ import annotations
+
+from rich.console import RenderableType
+from rich.style import Style as RichStyle
+from rich.text import Text
+
+from pythinker_code.ui.shell.components.bash_execution import (
+    BashExecutionState,
+    BashStatus,
+    format_bash_command_for_header,
+    render_bash_result_output,
+)
+from pythinker_code.ui.shell.tool_renderers import (
+    ToolRenderContext,
+    ToolRenderDefinition,
+    ToolResultPayload,
+)
+from pythinker_code.ui.shell.tool_renderers._render_utils import (
+    as_str,
+    fg,
+    invalid_arg,
+    running_spinner,
+)
+from pythinker_code.ui.theme import tui_rich_style
+
+_TOOL_NAME = "Shell"
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType | None:
+    """Render the stable shell tool header before any output rows."""
+    args = ctx.args or {}
+    command = as_str(args.get("command"))
+    timeout = args.get("timeout")
+    run_in_background = bool(args.get("run_in_background"))
+
+    bash_mode = tui_rich_style("bash_mode")
+    line = Text("$ ", style=bash_mode + RichStyle(bold=True))
+    if command is None:
+        if "command" in args:
+            line.append_text(invalid_arg())
+        else:
+            line.append_text(fg("tool_output", "..."))
+    else:
+        line.append(
+            format_bash_command_for_header(command, expanded=ctx.expanded),
+            style=bash_mode + RichStyle(bold=True),
+        )
+
+    if isinstance(timeout, int) and timeout != 60:
+        line.append_text(fg("muted", f" (timeout {timeout}s)"))
+    if run_in_background:
+        description = as_str(args.get("description"))
+        suffix = f" (background: {description})" if description else " (background)"
+        line.append_text(fg("muted", suffix))
+    return running_spinner(line, execution_started=ctx.execution_started, has_result=ctx.has_result)
+
+
+def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> RenderableType | None:
+    """Render shell output/status under the shared response gutter."""
+    args = ctx.args or {}
+    command = as_str(args.get("command")) or ""
+    if not command:
+        return None
+
+    suffix_parts: list[str] = []
+    timeout = args.get("timeout")
+    if isinstance(timeout, int) and timeout != 60:
+        suffix_parts.append(f" (timeout {timeout}s)")
+    if bool(args.get("run_in_background")):
+        description = as_str(args.get("description"))
+        suffix_parts.append(f" (background: {description})" if description else " (background)")
+
+    status: BashStatus = "error" if result.is_error else "complete"
+    bash_state = BashExecutionState(
+        command=command,
+        output=result.text or "",
+        status=status,
+        exit_code=None if not result.is_error else 1,
+        expanded=ctx.expanded,
+        header_suffix="".join(suffix_parts),
+    )
+    return render_bash_result_output(bash_state, width=ctx.width)
+
+
+SHELL_RENDERER = ToolRenderDefinition(
+    name=_TOOL_NAME,
+    label="bash",
+    render_shell="self",
+    render_call=_render_call,
+    render_result=_render_result,
+)