pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/ui/shell/tool_renderers/edit.py

@@ -0,0 +1,163 @@
+"""Pythinker renderer for Pythinker's ``StrReplaceFile`` tool.
+
+ .
+
+Source tool name → Pythinker tool name: ``edit`` → ``StrReplaceFile``.
+Param shape: Pythinker uses ``edit: Edit | list[Edit]`` where each ``Edit``
+has ``{old, new, replace_all}``.
+
+Pythinker's tool produces the diff out-of-band (via display
+blocks), so the renderer reconstructs it from the call args at render time.
+That means the diff appears as soon as the streaming args are complete and
+remains visible after execution.
+"""
+
+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.components import (
+    compute_edit_diff_string,
+    render_diff,
+)
+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,
+    shorten_path,
+    tool_title,
+)
+
+_TOOL_NAME = "StrReplaceFile"
+
+
+def _normalize_edits(edit_arg: Any) -> list[dict[str, Any]]:
+    """Coerce ``args["edit"]`` into a list of dicts, ignoring junk."""
+    if edit_arg is None:
+        return []
+    items: list[Any] = cast("list[Any]", edit_arg) if isinstance(edit_arg, list) else [edit_arg]
+    out: list[dict[str, Any]] = []
+    for item in items:
+        if isinstance(item, dict):
+            out.append(cast("dict[str, Any]", item))
+    return out
+
+
+def _build_combined_diff(edits: list[dict[str, Any]]) -> str:
+    """Render each edit's (old → new) as a Pythinker-format diff block, joined.
+
+    For multi-edit calls we render them sequentially with a blank separator.
+    Each block is line-numbered relative to its own ``old`` text — we don't
+    have the file content here, so absolute line numbers aren't possible.
+    """
+    blocks: list[str] = []
+    for edit in edits:
+        old = edit.get("old")
+        new = edit.get("new")
+        if not isinstance(old, str) or not isinstance(new, str):
+            continue
+        result = compute_edit_diff_string(old, new)
+        if result.diff:
+            blocks.append(result.diff)
+    return "\n\n".join(blocks)
+
+
+def _diff_counts(diff_text: str) -> tuple[int, int]:
+    """Return ``(added, removed)`` line counts from rendered diff text."""
+    added = removed = 0
+    for line in diff_text.splitlines():
+        if line.startswith("+++") or line.startswith("---"):
+            continue
+        if line.startswith("+"):
+            added += 1
+        elif line.startswith("-"):
+            removed += 1
+    return added, removed
+
+
+def _change_summary(added: int, removed: int) -> Text:
+    parts: list[str] = []
+    if added:
+        parts.append(f"Added {added} line{'s' if added != 1 else ''}")
+    if removed:
+        parts.append(f"Removed {removed} line{'s' if removed != 1 else ''}")
+    if not parts:
+        parts.append("No line changes")
+    summary = Text("└  ", style="dim")
+    summary.append(" · ".join(parts), style="bold")
+    return fg("tool_output", summary)
+
+
+def _diff_frame(diff_renderable: RenderableType, *, width: int) -> Group:
+    """Blackbox-style diff frame: dashed horizontal rails, no side border."""
+    rule_width = max(8, min(width, 100))
+    rule = Text("-" * rule_width, style="dim")
+    return Group(rule, diff_renderable, rule)
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    raw_path = as_str(args.get("path"))
+
+    header = Text()
+    header.append_text(fg("success", "● "))
+    header.append_text(tool_title("Update"))
+    header.append("(")
+
+    if raw_path is None:
+        header.append_text(invalid_arg() if "path" in args else fg("tool_output", "..."))
+    else:
+        header.append_text(fg("accent", shorten_path(raw_path, cwd=ctx.cwd)))
+    header.append(")")
+
+    edits = _normalize_edits(args.get("edit"))
+    if not edits:
+        return running_spinner(
+            header,
+            execution_started=ctx.execution_started,
+            has_result=ctx.has_result,
+        )
+
+    if len(edits) > 1:
+        header.append_text(fg("tool_output", f" ({len(edits)} edits)"))
+
+    head = running_spinner(
+        header,
+        execution_started=ctx.execution_started,
+        has_result=ctx.has_result,
+    )
+
+    diff_text = _build_combined_diff(edits)
+    if not diff_text:
+        return head
+    added, removed = _diff_counts(diff_text)
+    diff_renderable = _diff_frame(render_diff(diff_text), width=ctx.width or 80)
+    return Group(head, _change_summary(added, removed), Text(""), diff_renderable)
+
+
+def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> RenderableType | None:
+    # Errors: surface the message; success: nothing — the call preview
+    # already shows the diff and the card background turns green.
+    if not result.is_error:
+        return None
+    if not result.text:
+        return None
+    return fg("error", result.text.rstrip("\n"))
+
+
+EDIT_RENDERER = ToolRenderDefinition(
+    name=_TOOL_NAME,
+    label="edit",
+    render_shell="default",
+    render_call=_render_call,
+    render_result=_render_result,
+)

pythinker_code/ui/shell/tool_renderers/find.py

@@ -0,0 +1,81 @@
+"""Pythinker renderer for Pythinker's ``Glob`` tool.
+
+ .
+
+Source tool name → Pythinker tool name: ``find`` → ``Glob``.
+Param mapping: ``path`` → ``directory``; ``limit`` is not exposed in Pythinker.
+"""
+
+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 = "Glob"
+_DEFAULT_COLLAPSED_LINES = 20
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    pattern = as_str(args.get("pattern"))
+    raw_dir = as_str(args.get("directory"))
+
+    line = Text()
+    line.append_text(tool_title("find"))
+    line.append(" ")
+
+    if pattern is None:
+        line.append_text(invalid_arg() if "pattern" in args else fg("tool_output", "..."))
+    else:
+        line.append_text(fg("accent", pattern))
+
+    line.append_text(fg("tool_output", " in "))
+    if "directory" in args and raw_dir is None:
+        line.append_text(invalid_arg())
+    else:
+        line.append_text(fg("tool_output", shorten_path(raw_dir or ".", cwd=ctx.cwd)))
+
+    if args.get("include_dirs") is False:
+        line.append_text(fg("tool_output", " (files only)"))
+    return running_spinner(line, execution_started=ctx.execution_started, has_result=ctx.has_result)
+
+
+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
+
+
+FIND_RENDERER = ToolRenderDefinition(
+    name=_TOOL_NAME,
+    label="find",
+    render_shell="default",
+    render_call=_render_call,
+    render_result=_render_result,
+)

pythinker_code/ui/shell/tool_renderers/generic.py

@@ -0,0 +1,60 @@
+"""Generic fallback renderer used when no tool-specific renderer is registered.
+
+Mirrors the ``formatToolExecution`` shape: tool name in the header, args
+as a JSON blob, and the textual result below.
+"""
+
+from __future__ import annotations
+
+import json
+
+from rich.console import Group, RenderableType
+from rich.text import Text
+
+from pythinker_code.ui.shell.components import sanitize_ansi
+from pythinker_code.ui.shell.tool_renderers import (
+    ToolRenderContext,
+    ToolRenderDefinition,
+    ToolResultPayload,
+)
+
+_GENERIC_TOOL_NAME = "__generic__"
+"""Sentinel name used to register the fallback. Tools without their own
+entry can be looked up via ``get_tool_renderer(name) or _generic()``."""
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType | None:
+    header = Text()
+    label = ctx.state.get("__tool_name__", _GENERIC_TOOL_NAME)
+    header.append(str(label), style="bold")
+
+    if not ctx.args:
+        return header
+
+    try:
+        body = json.dumps(ctx.args, indent=2, ensure_ascii=False, sort_keys=True)
+    except (TypeError, ValueError):
+        body = repr(ctx.args)
+    return Group(header, Text(body, style="grey50"))
+
+
+def _render_result(ctx: ToolRenderContext, result: ToolResultPayload) -> RenderableType | None:
+    text = sanitize_ansi(result.text or "").rstrip("\n")
+    if not text:
+        return None
+    style = "red" if result.is_error else "grey70"
+    return Text(text, style=style)
+
+
+GENERIC_RENDERER = ToolRenderDefinition(
+    name=_GENERIC_TOOL_NAME,
+    label="Tool",
+    render_shell="default",
+    render_call=_render_call,
+    render_result=_render_result,
+)
+
+
+def generic_renderer() -> ToolRenderDefinition:
+    """Return the generic fallback renderer instance."""
+    return GENERIC_RENDERER

pythinker_code/ui/shell/tool_renderers/grep.py

@@ -0,0 +1,98 @@
+"""Pythinker renderer for Pythinker's ``Grep`` tool.
+
+ .
+
+Param differences:
+
+* ``limit`` → ``head_limit`` (Pythinker default 250 vs Pythinker's 100).
+* Pythinker has ``output_mode`` (files_with_matches | content | count_matches).
+* Pythinker uses ``-i`` alias for ``ignore_case``.
+"""
+
+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 = "Grep"
+_DEFAULT_COLLAPSED_LINES = 15
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    pattern = as_str(args.get("pattern"))
+    raw_path = as_str(args.get("path"))
+    glob = as_str(args.get("glob"))
+    head_limit = args.get("head_limit")
+    output_mode = as_str(args.get("output_mode"))
+
+    line = Text()
+    line.append_text(tool_title("grep"))
+    line.append(" ")
+
+    if pattern is None:
+        if "pattern" in args:
+            line.append_text(invalid_arg())
+        else:
+            line.append_text(fg("tool_output", "..."))
+    else:
+        line.append_text(fg("accent", f"/{pattern}/"))
+
+    path_display = shorten_path(raw_path or ".", cwd=ctx.cwd) if raw_path is not None else None
+    line.append_text(fg("tool_output", " in "))
+    if "path" in args and raw_path is None:
+        line.append_text(invalid_arg())
+    else:
+        line.append_text(fg("tool_output", path_display or "."))
+
+    extras: list[str] = []
+    if glob:
+        extras.append(f"({glob})")
+    if output_mode and output_mode != "files_with_matches":
+        extras.append(output_mode)
+    if isinstance(head_limit, int) and head_limit not in (0, 250):
+        extras.append(f"limit {head_limit}")
+    for extra in extras:
+        line.append_text(fg("tool_output", f" {extra}"))
+    return running_spinner(line, execution_started=ctx.execution_started, has_result=ctx.has_result)
+
+
+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
+
+
+GREP_RENDERER = ToolRenderDefinition(
+    name=_TOOL_NAME,
+    label="grep",
+    render_shell="default",
+    render_call=_render_call,
+    render_result=_render_result,
+)

pythinker_code/ui/shell/tool_renderers/plan.py

@@ -0,0 +1,98 @@
+"""Pythinker renderers for Pythinker's plan-mode tools.
+
+Covers ``EnterPlanMode`` (no args) and ``ExitPlanMode`` (optional alternatives
+list). Both produce single-line headers; ExitPlanMode also lists the options
+inline since they're short.
+"""
+
+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,
+    tool_title,
+)
+
+# ---------------------------------------------------------------------------
+# EnterPlanMode
+# ---------------------------------------------------------------------------
+
+
+def _render_enter_call(_ctx: ToolRenderContext) -> RenderableType:
+    line = Text()
+    line.append_text(tool_title("plan mode"))
+    line.append_text(fg("muted", " (entering)"))
+    return line
+
+
+def _render_plan_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=8,
+        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
+
+
+ENTER_PLAN_RENDERER = ToolRenderDefinition(
+    name="EnterPlanMode",
+    label="plan mode",
+    render_shell="default",
+    render_call=_render_enter_call,
+    render_result=_render_plan_result,
+)
+
+
+# ---------------------------------------------------------------------------
+# ExitPlanMode
+# ---------------------------------------------------------------------------
+
+
+def _render_exit_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    options = args.get("options")
+    line = Text()
+    line.append_text(tool_title("plan mode"))
+    line.append_text(fg("muted", " (exiting)"))
+
+    if not isinstance(options, list) or not options:
+        return line
+    options_list = cast("list[Any]", options)
+    opts: list[dict[str, Any]] = [
+        cast("dict[str, Any]", o) for o in options_list if isinstance(o, dict)
+    ]
+    if not opts:
+        return line
+
+    children: list[RenderableType] = [line]
+    for opt in opts[:3]:
+        label = as_str(opt.get("label")) or "?"
+        children.append(fg("accent", f"  • {label}"))
+    return Group(*children)
+
+
+EXIT_PLAN_RENDERER = ToolRenderDefinition(
+    name="ExitPlanMode",
+    label="plan mode",
+    render_shell="default",
+    render_call=_render_exit_call,
+    render_result=_render_plan_result,
+)

pythinker_code/ui/shell/tool_renderers/read.py

@@ -0,0 +1,103 @@
+"""Pythinker renderer for Pythinker's ``ReadFile`` tool.
+
+ .
+
+Source tool name → Pythinker tool name: ``read`` → ``ReadFile``.
+Param mapping: ``offset/limit`` → ``line_offset/n_lines``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+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 = "ReadFile"
+_DEFAULT_COLLAPSED_LINES = 10
+
+
+def _format_line_range(args: dict[str, Any]) -> Text | None:
+    offset = args.get("line_offset")
+    limit = args.get("n_lines")
+    if offset in (None, 1) and limit is None:
+        return None
+    try:
+        start = int(offset) if offset is not None else 1  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return None
+    if limit is None:
+        return fg("warning", f":{start}")
+    try:
+        end = start + int(limit) - 1  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return fg("warning", f":{start}")
+    return fg("warning", f":{start}-{end}")
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    raw_path = as_str(args.get("path"))
+    title = tool_title("read")
+    line = Text()
+    line.append_text(title)
+    line.append(" ")
+
+    if raw_path is None:
+        # Either missing (still streaming) or wrong type.
+        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)))
+
+    range_text = _format_line_range(args)
+    if range_text is not None:
+        line.append_text(range_text)
+    return running_spinner(line, execution_started=ctx.execution_started, has_result=ctx.has_result)
+
+
+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
+
+    line_count = result.text.count("\n") + (0 if result.text.endswith("\n") else 1)
+    noun = "line" if line_count == 1 else "lines"
+    summary = fg("muted", f"Read {line_count} {noun}")
+    if remaining > 0:
+        more = fg("muted", f"... ({remaining} more lines, ctrl+e to expand)")
+        return Group(summary, body, more)
+    return Group(summary, body)
+
+
+READ_RENDERER = ToolRenderDefinition(
+    name=_TOOL_NAME,
+    label="read",
+    render_shell="default",
+    render_call=_render_call,
+    render_result=_render_result,
+)

pythinker_code/ui/shell/tool_renderers/think.py

@@ -0,0 +1,66 @@
+"""Pythinker renderer for Pythinker's ``Think`` tool.
+
+Pythinker has no direct ``think`` core tool; we model the call preview after
+the ``hidden-thinking-label`` extension — a muted custom-message style
+that shows the thought without making the output box loud.
+"""
+
+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,
+    tool_title,
+)
+
+_TOOL_NAME = "Think"
+_DEFAULT_COLLAPSED_LINES = 6
+
+
+def _render_call(ctx: ToolRenderContext) -> RenderableType:
+    args = ctx.args or {}
+    thought = as_str(args.get("thought"))
+
+    header = Text()
+    header.append_text(tool_title("think"))
+    if thought is None:
+        if "thought" in args:
+            return Group(header, invalid_arg())
+        header.append_text(fg("muted", " ..."))
+        return header
+
+    if not thought:
+        return header
+    body, remaining = format_lines_block(
+        thought,
+        expanded=ctx.expanded,
+        collapsed_max_lines=_DEFAULT_COLLAPSED_LINES,
+        style_token="muted",
+    )
+    children: list[RenderableType] = [header, body]
+    if remaining > 0:
+        children.append(fg("muted", f"... ({remaining} more lines, ctrl+e to expand)"))
+    return Group(*children)
+
+
+def _render_result(_ctx: ToolRenderContext, _result: ToolResultPayload) -> RenderableType | None:
+    return None
+
+
+THINK_RENDERER = ToolRenderDefinition(
+    name=_TOOL_NAME,
+    label="think",
+    render_shell="default",
+    render_call=_render_call,
+    render_result=_render_result,
+)