zjcode 0.0.1__py3-none-any.whl

deepagents_code/tui/widgets/tool_renderers.py

@@ -0,0 +1,190 @@
+"""Tool renderers for approval widgets - registry pattern."""
+
+from __future__ import annotations
+
+import difflib
+from typing import TYPE_CHECKING, Any
+
+from deepagents_code.file_ops import build_approval_preview, format_display_path
+from deepagents_code.tui.widgets.tool_widgets import (
+    EditFileApprovalWidget,
+    GenericApprovalWidget,
+    WriteFileApprovalWidget,
+    format_display_content,
+)
+
+if TYPE_CHECKING:
+    from deepagents_code.tui.widgets.tool_widgets import ToolApprovalWidget
+
+
+class ToolRenderer:
+    """Strategy for building a tool's HITL approval widget.
+
+    Each renderer maps a tool name to a `(widget_class, data)` pair that
+    controls what the user sees in the approval box. Tools not registered
+    in `_RENDERER_REGISTRY` fall through to the default, which dumps all
+    args as `key: value` lines via `GenericApprovalWidget`.
+    """
+
+    @staticmethod
+    def get_approval_widget(
+        tool_args: dict[str, Any],
+        assistant_id: str | None = None,  # noqa: ARG004
+    ) -> tuple[type[ToolApprovalWidget], dict[str, Any]]:
+        """Get the approval widget class and data for this tool.
+
+        Args:
+            tool_args: The tool arguments from action_request.
+            assistant_id: Optional assistant identifier for resolving virtual paths.
+
+        Returns:
+            Tuple of (widget_class, data_dict)
+        """
+        return GenericApprovalWidget, tool_args
+
+
+class WriteFileRenderer(ToolRenderer):
+    """Renderer for write_file tool - shows full file content."""
+
+    @staticmethod
+    def get_approval_widget(  # noqa: D102  # Protocol method — docstring on base class
+        tool_args: dict[str, Any],
+        assistant_id: str | None = None,  # noqa: ARG004
+    ) -> tuple[type[ToolApprovalWidget], dict[str, Any]]:
+        # Extract file extension for syntax highlighting
+        file_path = tool_args.get("file_path", "")
+        content = format_display_content(tool_args.get("content", ""))
+
+        # Get file extension
+        file_extension = "text"
+        if "." in file_path:
+            file_extension = file_path.rsplit(".", 1)[-1]
+
+        data = {
+            "file_path": file_path,
+            "content": content,
+            "file_extension": file_extension,
+        }
+        return WriteFileApprovalWidget, data
+
+
+class TaskRenderer(ToolRenderer):
+    """Renderer for task tool — interrupt description provides full context."""
+
+    @staticmethod
+    def get_approval_widget(  # noqa: D102  # Protocol method — docstring on base class
+        tool_args: dict[str, Any],  # noqa: ARG004  # Unused; interrupt description already formats task args
+        assistant_id: str | None = None,  # noqa: ARG004
+    ) -> tuple[type[ToolApprovalWidget], dict[str, Any]]:
+        return GenericApprovalWidget, {}
+
+
+class DeleteFileRenderer(ToolRenderer):
+    """Renderer for delete tool - shows removed file content when available."""
+
+    @staticmethod
+    def get_approval_widget(  # noqa: D102  # Protocol method — docstring on base class
+        tool_args: dict[str, Any],
+        assistant_id: str | None = None,
+    ) -> tuple[type[ToolApprovalWidget], dict[str, Any]]:
+        path = str(tool_args.get("file_path") or tool_args.get("path") or "")
+        preview = build_approval_preview(
+            "delete", {"file_path": path}, assistant_id=assistant_id
+        )
+        if preview is None:
+            # `build_approval_preview` always returns a preview for "delete";
+            # this guards its `ApprovalPreview | None` contract defensively.
+            return GenericApprovalWidget, tool_args
+        if preview.diff:
+            return EditFileApprovalWidget, {
+                "file_path": format_display_path(path),
+                "diff_lines": preview.diff.splitlines(),
+                "old_string": "",
+                "new_string": "",
+            }
+        data: dict[str, Any] = {"file_path": format_display_path(path)}
+        details = [
+            detail for detail in preview.details if not detail.startswith("File:")
+        ]
+        if details:
+            data["details"] = "\n".join(details)
+        if preview.error:
+            data["error"] = preview.error
+        return GenericApprovalWidget, data
+
+
+class EditFileRenderer(ToolRenderer):
+    """Renderer for edit_file tool - shows unified diff."""
+
+    @staticmethod
+    def get_approval_widget(  # noqa: D102  # Protocol method — docstring on base class
+        tool_args: dict[str, Any],
+        assistant_id: str | None = None,  # noqa: ARG004
+    ) -> tuple[type[ToolApprovalWidget], dict[str, Any]]:
+        file_path = tool_args.get("file_path", "")
+        old_string = format_display_content(tool_args.get("old_string", ""))
+        new_string = format_display_content(tool_args.get("new_string", ""))
+
+        # Generate unified diff
+        diff_lines = EditFileRenderer._generate_diff(old_string, new_string)
+
+        data = {
+            "file_path": file_path,
+            "diff_lines": diff_lines,
+            "old_string": old_string,
+            "new_string": new_string,
+        }
+        return EditFileApprovalWidget, data
+
+    @staticmethod
+    def _generate_diff(old_string: str, new_string: str) -> list[str]:
+        """Generate unified diff lines from old and new strings.
+
+        Returns:
+            List of diff lines without the file headers.
+        """
+        if not old_string and not new_string:
+            return []
+
+        old_lines = old_string.split("\n") if old_string else []
+        new_lines = new_string.split("\n") if new_string else []
+
+        # Generate unified diff
+        diff = difflib.unified_diff(
+            old_lines,
+            new_lines,
+            fromfile="before",
+            tofile="after",
+            lineterm="",
+            n=3,  # Context lines
+        )
+
+        # Skip the first two header lines (--- and +++)
+        diff_list = list(diff)
+        return diff_list[2:] if len(diff_list) > 2 else diff_list  # noqa: PLR2004  # Column count threshold
+
+
+_RENDERER_REGISTRY: dict[str, type[ToolRenderer]] = {
+    "task": TaskRenderer,
+    "write_file": WriteFileRenderer,
+    "edit_file": EditFileRenderer,
+    "delete": DeleteFileRenderer,
+}
+"""Registry mapping tool names to renderers
+
+Note: bash/shell/execute use minimal approval (no renderer) — see
+ApprovalMenu._MINIMAL_TOOLS
+"""
+
+
+def get_renderer(tool_name: str) -> ToolRenderer:
+    """Get the renderer for a tool by name.
+
+    Args:
+        tool_name: The name of the tool
+
+    Returns:
+        The appropriate ToolRenderer instance
+    """
+    renderer_class = _RENDERER_REGISTRY.get(tool_name, ToolRenderer)
+    return renderer_class()

deepagents_code/tui/widgets/tool_widgets.py

@@ -0,0 +1,304 @@
+"""Tool-specific approval widgets for HITL display."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from textual.containers import Vertical
+from textual.content import Content
+from textual.widgets import Markdown, Static
+
+from deepagents_code import theme
+from deepagents_code.file_ops import is_sensitive_file_path
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+_CREDENTIAL_NOTICE = "Contents hidden — file may contain credentials"
+
+# Constants for display limits
+_MAX_VALUE_LEN = 200
+_MAX_LINES = 30
+_MAX_DIFF_LINES = 50
+_MAX_PREVIEW_LINES = 20
+
+
+def format_display_content(content: object) -> str:
+    """Coerce arbitrary tool-arg content into a displayable string.
+
+    Strings pass through unchanged; other values are JSON-formatted for
+    readability, falling back to `str()` when serialization fails.
+
+    Returns:
+        A string safe to render in an approval widget.
+    """
+    if isinstance(content, str):
+        return content
+    try:
+        return json.dumps(content, ensure_ascii=False, indent=2)
+    except (TypeError, ValueError, RecursionError):
+        return str(content)
+
+
+def _format_stats(additions: int, deletions: int) -> Content:
+    """Format addition/deletion stats as styled Content.
+
+    Args:
+        additions: Number of added lines.
+        deletions: Number of removed lines.
+
+    Returns:
+        Styled Content showing additions and deletions.
+    """
+    colors = theme.get_theme_colors()
+    parts: list[str | tuple[str, str] | Content] = []
+    if additions:
+        parts.append((f"+{additions}", colors.success))
+    if deletions:
+        if parts:
+            parts.append(" ")
+        parts.append((f"-{deletions}", colors.error))
+    return Content.assemble(*parts) if parts else Content("")
+
+
+def _file_header(
+    file_path: str, additions: int = 0, deletions: int = 0
+) -> ComposeResult:
+    """Yield the `File:` path header with optional `+N -M` stats.
+
+    Args:
+        file_path: Path to the file being modified.
+        additions: Number of added lines.
+        deletions: Number of removed lines.
+
+    Yields:
+        Static widgets for the file path header and a spacer line.
+    """
+    stats = _format_stats(additions, deletions)
+    yield Static(
+        Content.assemble(
+            Content.from_markup("[bold cyan]File:[/bold cyan] $path  ", path=file_path),
+            stats,
+        )
+    )
+    yield Static("")
+
+
+def _count_diff_stats(
+    diff_lines: list[str], old_string: str, new_string: str
+) -> tuple[int, int]:
+    """Count additions and deletions from diff data.
+
+    Args:
+        diff_lines: Unified diff output lines.
+        old_string: Original text being replaced (fallback when no diff).
+        new_string: Replacement text (fallback when no diff).
+
+    Returns:
+        Tuple of (additions count, deletions count).
+    """
+    if diff_lines:
+        additions = sum(
+            1
+            for line in diff_lines
+            if line.startswith("+") and not line.startswith("+++")
+        )
+        deletions = sum(
+            1
+            for line in diff_lines
+            if line.startswith("-") and not line.startswith("---")
+        )
+    else:
+        additions = new_string.count("\n") + 1 if new_string else 0
+        deletions = old_string.count("\n") + 1 if old_string else 0
+    return additions, deletions
+
+
+class ToolApprovalWidget(Vertical):
+    """Base class for tool approval widgets."""
+
+    def __init__(self, data: dict[str, Any]) -> None:
+        """Initialize the tool approval widget with data."""
+        super().__init__(classes="tool-approval-widget")
+        self.data = data
+
+    def compose(self) -> ComposeResult:  # noqa: PLR6301  # Textual widget method convention
+        """Default compose - override in subclasses.
+
+        Yields:
+            Static widget with placeholder message.
+        """
+        yield Static("Tool details not available", classes="approval-description")
+
+
+class GenericApprovalWidget(ToolApprovalWidget):
+    """Generic approval widget for unknown tools."""
+
+    def compose(self) -> ComposeResult:
+        """Compose the generic tool display.
+
+        Yields:
+            Static widgets displaying each key-value pair from tool data.
+        """
+        for key, value in self.data.items():
+            if value is None:
+                continue
+            value_str = str(value)
+            if len(value_str) > _MAX_VALUE_LEN:
+                hidden = len(value_str) - _MAX_VALUE_LEN
+                value_str = value_str[:_MAX_VALUE_LEN] + f"... ({hidden} more chars)"
+            yield Static(
+                f"{key}: {value_str}", markup=False, classes="approval-description"
+            )
+
+
+class WriteFileApprovalWidget(ToolApprovalWidget):
+    """Approval widget for write_file - shows file content with syntax highlighting."""
+
+    def compose(self) -> ComposeResult:
+        """Compose the file content display with syntax highlighting.
+
+        Yields:
+            Widgets displaying file path header and syntax-highlighted content.
+        """
+        file_path = self.data.get("file_path", "")
+        content = format_display_content(self.data.get("content", ""))
+        file_extension = self.data.get("file_extension", "text")
+
+        # Never render the contents of credential files (e.g. `.env`).
+        if is_sensitive_file_path(file_path):
+            yield from _file_header(file_path)
+            yield Static(Content.styled(_CREDENTIAL_NOTICE, "dim"))
+        else:
+            # Content with syntax highlighting via Markdown code block
+            lines = content.split("\n")
+            total_lines = len(lines)
+
+            # File header with line count
+            yield from _file_header(file_path, additions=total_lines if content else 0)
+
+            if total_lines > _MAX_LINES:
+                # Truncate for display
+                shown_lines = lines[:_MAX_LINES]
+                remaining = total_lines - _MAX_LINES
+                truncated_content = (
+                    "\n".join(shown_lines) + f"\n... ({remaining} more lines)"
+                )
+                yield Markdown(f"```{file_extension}\n{truncated_content}\n```")
+            else:
+                yield Markdown(f"```{file_extension}\n{content}\n```")
+
+
+class EditFileApprovalWidget(ToolApprovalWidget):
+    """Approval widget for edit_file - shows clean diff with colors."""
+
+    def compose(self) -> ComposeResult:
+        """Compose the diff display with colored additions and deletions.
+
+        Yields:
+            Widgets displaying file path, stats, and colored diff lines.
+        """
+        file_path = self.data.get("file_path", "")
+        diff_lines = self.data.get("diff_lines", [])
+        old_string = format_display_content(self.data.get("old_string", ""))
+        new_string = format_display_content(self.data.get("new_string", ""))
+
+        additions, deletions = _count_diff_stats(diff_lines, old_string, new_string)
+        yield from _file_header(file_path, additions, deletions)
+
+        # Never render the diff of credential files (e.g. `.env`); the stats
+        # above still convey that a change happened without exposing content.
+        if is_sensitive_file_path(file_path):
+            yield Static(Content.styled(_CREDENTIAL_NOTICE, "dim"))
+        elif not diff_lines and not old_string and not new_string:
+            yield Static("No changes to display", classes="approval-description")
+        elif diff_lines:
+            # Render content
+            yield from self._render_diff_lines_only(diff_lines)
+        else:
+            yield from self._render_strings_only(old_string, new_string)
+
+    def _render_diff_lines_only(self, diff_lines: list[str]) -> ComposeResult:
+        """Render unified diff lines without returning stats.
+
+        Yields:
+            Static widgets for each diff line with appropriate styling.
+        """
+        lines_shown = 0
+
+        for line in diff_lines:
+            if lines_shown >= _MAX_DIFF_LINES:
+                yield Static(
+                    Content.styled(
+                        f"... ({len(diff_lines) - lines_shown} more lines)", "dim"
+                    )
+                )
+                break
+
+            if line.startswith(("@@", "---", "+++")):
+                continue
+
+            widget = self._render_diff_line(line)
+            if widget:
+                yield widget
+                lines_shown += 1
+
+    def _render_strings_only(self, old_string: str, new_string: str) -> ComposeResult:
+        """Render old/new strings without returning stats.
+
+        Yields:
+            Static widgets showing removed and added content with styling.
+        """
+        colors = theme.get_theme_colors()
+        if old_string:
+            yield Static(Content.styled("Removing:", f"bold {colors.error}"))
+            yield from self._render_string_lines(old_string, is_addition=False)
+            yield Static("")
+
+        if new_string:
+            yield Static(Content.styled("Adding:", f"bold {colors.success}"))
+            yield from self._render_string_lines(new_string, is_addition=True)
+
+    @staticmethod
+    def _render_diff_line(line: str) -> Static | None:
+        """Render a single diff line with appropriate styling.
+
+        Returns:
+            Static widget with styled diff line, or None for empty/skipped lines.
+        """
+        raw = line[1:] if len(line) > 1 else ""
+
+        if line.startswith("-"):
+            return Static(
+                Content.from_markup("- $text", text=raw), classes="diff-removed"
+            )
+        if line.startswith("+"):
+            return Static(
+                Content.from_markup("+ $text", text=raw), classes="diff-added"
+            )
+        if line.startswith(" "):
+            return Static(
+                Content.from_markup("  $text", text=raw), classes="diff-context"
+            )
+        if line.strip():
+            return Static(line, markup=False)
+        return None
+
+    @staticmethod
+    def _render_string_lines(text: str, *, is_addition: bool) -> ComposeResult:
+        """Render lines from a string with appropriate styling.
+
+        Yields:
+            Static widgets for each line with addition or deletion styling.
+        """
+        lines = text.split("\n")
+        sign = "+" if is_addition else "-"
+        cls = "diff-added" if is_addition else "diff-removed"
+
+        for line in lines[:_MAX_PREVIEW_LINES]:
+            yield Static(Content.from_markup(f"{sign} $text", text=line), classes=cls)
+
+        if len(lines) > _MAX_PREVIEW_LINES:
+            remaining = len(lines) - _MAX_PREVIEW_LINES
+            yield Static(Content.styled(f"... ({remaining} more lines)", "dim"))