pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/ui/shell/tool_renderers/todo.py

@@ -0,0 +1,164 @@
+"""Pythinker renderer for Pythinker's ``SetTodoList`` tool.
+
+Renders the todo list with aligned status icons:
+
+* ``○`` pending
+* ``◐`` in_progress (highlighted)
+* ``●`` done (success)
+"""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from rich.console import Group, RenderableType
+from rich.padding import Padding
+from rich.table import Table
+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,
+    tool_title,
+)
+
+_TOOL_NAME = "SetTodoList"
+_DEFAULT_COLLAPSED_LINES = 12
+
+_ICONS = {
+    "pending": "○",
+    "in_progress": "◐",
+    "done": "●",
+}
+
+_TREE_BRANCH = "├─"
+_TREE_LAST = "└─"
+_LEFT_INSET = 2
+
+
+def _icon_token(status: str) -> str:
+    if status == "done":
+        return "success"
+    if status == "in_progress":
+        return "accent"
+    return "muted"
+
+
+def _todo_level_and_title(item: dict[str, Any]) -> tuple[int, str]:
+    """Return display nesting level and a cleaned title.
+
+    The public todo schema is intentionally tiny, but tool-call payloads and
+    persisted older sessions can still carry presentation hints. Prefer an
+    explicit ``level``/``depth``/``indent`` when present; otherwise infer one
+    from leading spaces in the title so pasted markdown-ish plans render as a
+    real tree instead of a flat wall of text.
+    """
+    raw_title = as_str(item.get("title")) or ""
+    explicit = item.get("level", item.get("depth", item.get("indent")))
+    if isinstance(explicit, int):
+        return max(0, min(explicit, 6)), raw_title.strip()
+
+    leading_spaces = len(raw_title) - len(raw_title.lstrip(" "))
+    level = max(0, min(leading_spaces // 2, 6))
+    return level, raw_title.strip()
+
+
+def _status_title(status: str, title: str) -> Text:
+    if status == "done":
+        return fg("muted", title)
+    if status == "in_progress":
+        out = fg("accent", title)
+        out.stylize("bold")
+        return out
+    return fg("tool_output", title)
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    todos = args.get("todos")
+
+    header = Text()
+    header.append_text(tool_title("todos"))
+
+    if todos is None:
+        header.append_text(fg("muted", " (read)"))
+        return Padding(header, (0, 0, 0, _LEFT_INSET))
+
+    if not isinstance(todos, list):
+        header.append_text(fg("muted", " ..."))
+        return Padding(header, (0, 0, 0, _LEFT_INSET))
+
+    todos_list = cast("list[Any]", todos)
+    items: list[dict[str, Any]] = [
+        cast("dict[str, Any]", t) for t in todos_list if isinstance(t, dict)
+    ]
+    counts = {"pending": 0, "in_progress": 0, "done": 0}
+    for item in items:
+        status = as_str(item.get("status")) or "pending"
+        if status in counts:
+            counts[status] += 1
+
+    if not items:
+        header.append_text(fg("muted", " (empty)"))
+        return Padding(header, (0, 0, 0, _LEFT_INSET))
+
+    total = len(items)
+    badge = f" {counts['done']}/{total} done"
+    if counts["in_progress"]:
+        badge += f" · {counts['in_progress']} active"
+    if counts["pending"]:
+        badge += f" · {counts['pending']} pending"
+    header.append_text(fg("muted", badge))
+
+    visible = items if ctx.expanded else items[:_DEFAULT_COLLAPSED_LINES]
+    table = Table.grid(padding=(0, 1))
+    table.add_column(no_wrap=True)
+    table.add_column(width=2, no_wrap=True)
+    table.add_column(ratio=1)
+    for index, item in enumerate(visible):
+        status = as_str(item.get("status")) or "pending"
+        level, title = _todo_level_and_title(item)
+        icon = _ICONS.get(status, "○")
+        has_continuation_row = not ctx.expanded and len(items) > len(visible)
+        branch = (
+            _TREE_LAST if index == len(visible) - 1 and not has_continuation_row else _TREE_BRANCH
+        )
+        gutter = ("  " * level) + branch
+        table.add_row(
+            fg("dim", gutter),
+            fg(_icon_token(status), icon),
+            _status_title(status, title),
+        )
+
+    rows: list[RenderableType] = [header, table]
+    if not ctx.expanded and len(items) > len(visible):
+        remaining = len(items) - len(visible)
+        rows.append(fg("muted", f"{_TREE_LAST} ... +{remaining} more (ctrl+e to expand)"))
+    return Padding(Group(*rows), (0, 0, 0, _LEFT_INSET))
+
+
+def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> RenderableType | None:
+    if not result.text or not result.is_error:
+        return None
+    body, _ = format_lines_block(
+        result.text,
+        expanded=True,
+        collapsed_max_lines=0,
+        style_token="error",
+    )
+    return body if body.plain else None
+
+
+TODO_RENDERER = ToolRenderDefinition(
+    name=_TOOL_NAME,
+    label="todos",
+    render_shell="default",
+    render_call=_render_call,
+    render_result=_render_result,
+)

pythinker_code/ui/shell/tool_renderers/web.py

@@ -0,0 +1,128 @@
+"""Pythinker renderers for Pythinker's ``FetchURL`` and ``SearchWeb`` tools."""
+
+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 _shorten_url(url: str, *, max_chars: int = 60) -> str:
+    if len(url) <= max_chars:
+        return url
+    return url[: max_chars - 1].rstrip() + "…"
+
+
+# ---------------------------------------------------------------------------
+# FetchURL
+# ---------------------------------------------------------------------------
+
+
+def _render_fetch_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    url = as_str(args.get("url"))
+    line = Text()
+    line.append_text(tool_title("fetch"))
+    line.append(" ")
+    if url is None:
+        line.append_text(invalid_arg() if "url" in args else fg("muted", "..."))
+    else:
+        line.append_text(fg("accent", _shorten_url(url)))
+    return running_spinner(line, execution_started=ctx.execution_started, has_result=ctx.has_result)
+
+
+def _render_fetch_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=15,
+        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
+
+
+FETCH_RENDERER = ToolRenderDefinition(
+    name="FetchURL",
+    label="fetch",
+    render_shell="default",
+    render_call=_render_fetch_call,
+    render_result=_render_fetch_result,
+)
+
+
+# ---------------------------------------------------------------------------
+# SearchWeb
+# ---------------------------------------------------------------------------
+
+
+def _render_search_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    query = as_str(args.get("query"))
+    limit = args.get("limit")
+    include_content = bool(args.get("include_content"))
+
+    line = Text()
+    line.append_text(tool_title("search"))
+    line.append(" ")
+    if query is None:
+        line.append_text(invalid_arg() if "query" in args else fg("muted", "..."))
+    else:
+        line.append_text(fg("accent", f'"{query}"'))
+    extras: list[str] = []
+    if isinstance(limit, int) and limit != 5:
+        extras.append(f"limit {limit}")
+    if include_content:
+        extras.append("with content")
+    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_search_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=15,
+        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
+
+
+SEARCH_RENDERER = ToolRenderDefinition(
+    name="SearchWeb",
+    label="search",
+    render_shell="default",
+    render_call=_render_search_call,
+    render_result=_render_search_result,
+)

pythinker_code/ui/shell/tool_renderers/write.py

@@ -0,0 +1,102 @@
+"""Pythinker renderer for Pythinker's ``WriteFile`` tool.
+
+ .
+
+This renderer could incrementally syntax-highlights streaming content via a
+lookahead cache. We skip the cache for now and rely on plain text plus a
+trailing truncation hint — highlighting can be layered on later via
+``rich.syntax.Syntax``.
+"""
+
+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,
+    shorten_path,
+    tool_title,
+)
+
+_TOOL_NAME = "WriteFile"
+_DEFAULT_PREVIEW_LINES = 10
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    raw_path = as_str(args.get("path"))
+    raw_content = as_str(args.get("content"))
+    mode = args.get("mode")
+
+    title = tool_title("write" if mode != "append" else "append")
+    line = Text()
+    line.append_text(title)
+    line.append(" ")
+
+    if raw_path is None:
+        if "path" in args:
+            line.append_text(invalid_arg())
+        else:
+            line.append_text(fg("tool_output", "..."))
+    else:
+        line.append_text(fg("accent", shorten_path(raw_path, cwd=ctx.cwd)))
+
+    head = running_spinner(line, execution_started=ctx.execution_started, has_result=ctx.has_result)
+
+    if raw_content is None:
+        if "content" in args:
+            return Group(
+                head,
+                fg("error", "[invalid content arg - expected string]"),
+            )
+        return head
+
+    if not raw_content:
+        return head
+
+    body, remaining = format_lines_block(
+        raw_content,
+        expanded=ctx.expanded,
+        collapsed_max_lines=_DEFAULT_PREVIEW_LINES,
+        style_token="tool_output",
+    )
+    if not body.plain:
+        return head
+    if remaining > 0:
+        total = raw_content.count("\n") + 1
+        more = fg("muted", f"... ({remaining} more lines, {total} total, ctrl+e to expand)")
+        return Group(head, Text(""), body, more)
+    return Group(head, Text(""), body)
+
+
+def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> RenderableType | None:
+    # Render the result when it's an error. On success, the call
+    # preview already shows the full payload.
+    if not result.is_error or not result.text:
+        return None
+    body, _ = format_lines_block(
+        result.text,
+        expanded=True,
+        collapsed_max_lines=0,
+        style_token="error",
+    )
+    return body if body.plain else None
+
+
+WRITE_RENDERER = ToolRenderDefinition(
+    name=_TOOL_NAME,
+    label="write",
+    render_shell="default",
+    render_call=_render_call,
+    render_result=_render_result,
+)