"""Renderers for the ``todo`` tool — the plan tracker.
The default ``ToolStartedRenderer`` dumps the call args as raw JSON, which is
unreadable for a tool as central as todo (and for ``set`` produces a wall of
quoted strings). These renderers turn the call into a compact, op-aware card
and collapse the result into a single status line — the full live plan already
lives in the side panel (``TodoList``), so the chat card only needs to convey
*what changed*, not the whole state.
Pattern mirrors ``subagent.py``: registered before the generic tool renderers.
"""
from __future__ import annotations
import json
from rich.box import ROUNDED
from rich.console import RenderableType
from rich.json import JSON as RichJSON
from rich.panel import Panel
from rich.text import Text
from clients.terminal.tui.themes import get_active_theme
from .base import ContentRenderer
_TODO_TOOL = "todo"
# Same markers as the side panel (todo_list.py) so the chat card and the panel
# read as one vocabulary.
_ICON = {"pending": "○", "in_progress": "◎", "done": "✓", "failed": "✗", "skipped": "—"}
# Validation status text colour by the new status (used in update cards).
_VAL_COLOR = {
"done": "success",
"failed": "error",
"in_progress": "accent",
"skipped": "text_dim",
"pending": "text_dim",
}
def _truncate(text: str, limit: int) -> str:
text = (text or "").strip()
if len(text) <= limit:
return text
return text[:limit].rstrip() + " …"
class TodoStartedRenderer(ContentRenderer):
"""Render a ``todo`` call start as a compact, op-aware card."""
def accepts(self, msg: dict) -> bool:
return msg.get("type") == "tool_started" and msg.get("tool") == _TODO_TOOL
def render(self, msg: dict) -> RenderableType:
theme = get_active_theme()
args = msg.get("args") or {}
op = args.get("op")
accent = theme.accent.hex
body = self._body(msg, theme)
title = self._title(op, args, accent)
panel = Panel(
body,
title=title,
title_align="left",
border_style=theme.tool_border.hex,
box=ROUNDED,
)
if bool(msg.get("is_subagent", False)):
from rich.padding import Padding
return Padding(panel, (0, 0, 0, 2))
return panel
def _title(self, op: str | None, args: dict, accent: str) -> str:
if op == "set":
n = len(args.get("tasks") or [])
return f"→ todo · set plan ({n})"
if op == "update":
idx = args.get("index")
status = args.get("status", "")
arrow = f" → {status}" if status else ""
return f"→ todo · #{idx}{arrow}"
if op == "view":
return "→ todo · view"
if op == "clear":
return "→ todo · clear"
return f"→ todo · {op or '?'}"
def _body(self, msg: dict, theme) -> RenderableType:
args = msg.get("args") or {}
op = args.get("op")
dim = theme.text_dim.hex
muted = theme.text_muted.hex
if op == "set":
tasks = args.get("tasks") or []
if not tasks:
return Text("(empty plan)", style=dim)
lines = Text()
for i, t in enumerate(tasks, 1):
if i > 1:
lines.append("\n")
lines.append(f" {_ICON['pending']} ", style=dim)
lines.append(f"{i}. {_truncate(str(t), 80)}", style=muted)
return lines
if op == "update":
status = args.get("status", "")
validation = (args.get("validation") or "").strip()
# The step text comes from ToolStarted.metadata (enriched on the
# backend by loading the plan before the tool runs — the LLM's
# update args carry only the index). Absent on history replay.
step_text = ""
meta = msg.get("metadata")
if isinstance(meta, dict):
step_text = (meta.get("step_text") or "").strip()
body = Text()
has_content = False
if step_text:
body.append(_truncate(step_text, 100), style=theme.text.hex)
has_content = True
if validation:
color_attr = _VAL_COLOR.get(status, "text_dim")
color = getattr(theme, color_attr, theme.text_dim).hex
if has_content:
body.append("\n")
body.append("verified: ", style=dim)
body.append(_truncate(validation, 160), style=color)
has_content = True
if not has_content:
# No step text (history replay) and no validation — keep the
# placeholder so the card isn't empty.
body.append("no validation", style=dim)
return body
if op in ("view", "clear"):
return Text("")
# Unknown op — fall back to readable JSON so the call is still legible.
try:
return RichJSON(json.dumps(args))
except Exception:
return Text(str(args), style=dim)
class TodoResultRenderer(ContentRenderer):
"""Render a ``todo`` result as a single compact status line.
The full plan is in the side panel; the chat card only needs the summary.
The result text from ``todo._render`` starts with ``Plan — X/N done:``;
we parse that. Other result strings (``Plan is empty.``, ``Plan cleared.``,
``No plan set for this session.``) map to short labels.
"""
def accepts(self, msg: dict) -> bool:
return msg.get("type") == "tool_call" and msg.get("tool") == _TODO_TOOL
def render(self, msg: dict) -> RenderableType:
theme = get_active_theme()
success = msg.get("success", True)
result = msg.get("result")
text = str(result) if result is not None else ""
if bool(msg.get("is_subagent", False)):
from rich.padding import Padding
return Padding(self._card(success, text, theme), (0, 0, 0, 2))
return self._card(success, text, theme)
def _card(self, success: bool, text: str, theme) -> Panel:
if not success:
# e.g. validation_required — surface the first line compactly.
first = text.splitlines()[0].strip() if text else "error"
color = theme.tool_error
return Panel(
Text(_truncate(first, 120), style=color.hex),
title="← todo ✗",
title_align="left",
border_style=color.hex,
box=ROUNDED,
)
# The step text lives in the *call* card (started, via metadata); the
# result card only carries the new overall state — one compact line.
label = self._status_label(text)
return Panel(
self._status_line(label, theme),
title="← todo ✓",
title_align="left",
border_style=theme.tool_success.hex,
box=ROUNDED,
)
def _status_label(self, text: str) -> str:
first = text.splitlines()[0].strip() if text else ""
# "Plan — 2/5 done:"
if first.startswith("Plan —") and "done" in first:
tail = first[len("Plan —"):].rstrip(":").strip() # "2/5 done"
return f"plan · {tail}"
if first == "Plan is empty.":
return "plan · empty"
if first == "Plan cleared.":
return "plan · cleared"
if first == "No plan set for this session.":
return "plan · no plan"
return _truncate(first, 80) or "plan · ok"
def _status_line(self, label: str, theme) -> Text:
dim = theme.text_dim.hex
if label.startswith("plan · ") and "/" in label:
# "plan · 2/5 done" → prefix dim, "2" success, "/5 done" dim.
body = Text("plan · ", style=dim)
rest = label[len("plan · "):] # "2/5 done"
slash = rest.find("/")
done_n = rest[:slash]
after = rest[slash:] # "/5 done"
body.append(done_n, style=theme.success.hex)
body.append(after, style=dim)
return body
return Text(label, style=dim)
