soothe-cli 0.1.0__py3-none-any.whl

soothe_cli/tui/widgets/tool_renderers.py

@@ -0,0 +1,148 @@
+"""Tool renderers for approval widgets - registry pattern."""
+
+from __future__ import annotations
+
+import difflib
+from typing import TYPE_CHECKING, Any
+
+from soothe_cli.tui.widgets.tool_widgets import (
+    EditFileApprovalWidget,
+    GenericApprovalWidget,
+    WriteFileApprovalWidget,
+)
+
+if TYPE_CHECKING:
+    from soothe_cli.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],
+    ) -> 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
+
+        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],
+    ) -> tuple[type[ToolApprovalWidget], dict[str, Any]]:
+        # Extract file extension for syntax highlighting
+        file_path = tool_args.get("file_path", "")
+        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
+    ) -> tuple[type[ToolApprovalWidget], dict[str, Any]]:
+        return GenericApprovalWidget, {}
+
+
+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],
+    ) -> tuple[type[ToolApprovalWidget], dict[str, Any]]:
+        file_path = tool_args.get("file_path", "")
+        old_string = tool_args.get("old_string", "")
+        new_string = 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,
+}
+"""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()

soothe_cli/tui/widgets/tool_widgets.py

@@ -0,0 +1,254 @@
+"""Tool-specific approval widgets for HITL display."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from textual.containers import Vertical
+from textual.content import Content
+from textual.widgets import Markdown, Static
+
+from soothe_cli.tui import theme
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+# Constants for display limits
+_MAX_VALUE_LEN = 200
+_MAX_LINES = 30
+_MAX_DIFF_LINES = 50
+_MAX_PREVIEW_LINES = 20
+
+
+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 = self.data.get("content", "")
+        file_extension = self.data.get("file_extension", "text")
+
+        # 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 = self.data.get("old_string", "")
+        new_string = self.data.get("new_string", "")
+
+        additions, deletions = _count_diff_stats(diff_lines, old_string, new_string)
+        yield from _file_header(file_path, additions, deletions)
+
+        if 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"))

soothe_cli/tui/widgets/tools.py

@@ -0,0 +1,165 @@
+"""Custom tools for the CLI agent."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    from tavily import TavilyClient
+
+_UNSET = object()
+_tavily_client: TavilyClient | object | None = _UNSET
+
+
+def _get_tavily_client() -> TavilyClient | None:
+    """Get or initialize the lazy Tavily client singleton.
+
+    Returns:
+        TavilyClient instance, or None if API key is not configured.
+    """
+    global _tavily_client  # noqa: PLW0603  # Module-level cache requires global statement
+    if _tavily_client is not _UNSET:
+        return _tavily_client  # type: ignore[return-value]  # narrowed by sentinel check
+
+    from soothe_cli.tui.config import settings
+
+    if settings.has_tavily:
+        from tavily import TavilyClient as _TavilyClient
+
+        _tavily_client = _TavilyClient(api_key=settings.tavily_api_key)
+    else:
+        _tavily_client = None
+    return _tavily_client
+
+
+def web_search(  # noqa: ANN201  # Return type depends on dynamic tool configuration
+    query: str,
+    max_results: int = 5,
+    topic: Literal["general", "news", "finance"] = "general",
+    include_raw_content: bool = False,
+):
+    """Search the web using Tavily for current information and documentation.
+
+    This tool searches the web and returns relevant results. After receiving results,
+    you MUST synthesize the information into a natural, helpful response for the user.
+
+    Args:
+        query: The search query (be specific and detailed)
+        max_results: Number of results to return (default: 5)
+        topic: Search topic type - "general" for most queries, "news" for current events
+        include_raw_content: Include full page content (warning: uses more tokens)
+
+    Returns:
+        Dictionary containing:
+        - results: List of search results, each with:
+            - title: Page title
+            - url: Page URL
+            - content: Relevant excerpt from the page
+            - score: Relevance score (0-1)
+        - query: The original search query
+
+    IMPORTANT: After using this tool:
+    1. Read through the 'content' field of each result
+    2. Extract relevant information that answers the user's question
+    3. Synthesize this into a clear, natural language response
+    4. Cite sources by mentioning the page titles or URLs
+    5. NEVER show the raw JSON to the user - always provide a formatted response
+    """
+    try:
+        import requests
+        from tavily import (
+            BadRequestError,
+            InvalidAPIKeyError,
+            MissingAPIKeyError,
+            UsageLimitExceededError,
+        )
+        from tavily.errors import ForbiddenError
+        from tavily.errors import TimeoutError as TavilyTimeoutError
+    except ImportError as exc:
+        return {
+            "error": f"Required package not installed: {exc.name}. Install with: pip install 'Soothe[cli]'",
+            "query": query,
+        }
+
+    client = _get_tavily_client()
+    if client is None:
+        return {
+            "error": "Tavily API key not configured. Please set TAVILY_API_KEY environment variable.",
+            "query": query,
+        }
+
+    try:
+        return client.search(
+            query,
+            max_results=max_results,
+            include_raw_content=include_raw_content,
+            topic=topic,
+        )
+    except (
+        requests.exceptions.RequestException,
+        ValueError,
+        TypeError,
+        # Tavily-specific exceptions
+        BadRequestError,
+        ForbiddenError,
+        InvalidAPIKeyError,
+        MissingAPIKeyError,
+        TavilyTimeoutError,
+        UsageLimitExceededError,
+    ) as e:
+        return {"error": f"Web search error: {e!s}", "query": query}
+
+
+def fetch_url(url: str, timeout: int = 30) -> dict[str, Any]:
+    """Fetch content from a URL and convert HTML to markdown format.
+
+    This tool fetches web page content and converts it to clean markdown text,
+    making it easy to read and process HTML content. After receiving the markdown,
+    you MUST synthesize the information into a natural, helpful response for the user.
+
+    Args:
+        url: The URL to fetch (must be a valid HTTP/HTTPS URL)
+        timeout: Request timeout in seconds (default: 30)
+
+    Returns:
+        Dictionary containing:
+        - success: Whether the request succeeded
+        - url: The final URL after redirects
+        - markdown_content: The page content converted to markdown
+        - status_code: HTTP status code
+        - content_length: Length of the markdown content in characters
+
+    IMPORTANT: After using this tool:
+    1. Read through the markdown content
+    2. Extract relevant information that answers the user's question
+    3. Synthesize this into a clear, natural language response
+    4. NEVER show the raw markdown to the user unless specifically requested
+    """
+    try:
+        import requests
+        from markdownify import markdownify
+    except ImportError as exc:
+        return {
+            "error": f"Required package not installed: {exc.name}. Install with: pip install 'Soothe[cli]'",
+            "url": url,
+        }
+
+    try:
+        response = requests.get(
+            url,
+            timeout=timeout,
+            headers={"User-Agent": "Mozilla/5.0 (compatible; Soothe/1.0)"},
+        )
+        response.raise_for_status()
+
+        # Convert HTML content to markdown
+        markdown_content = markdownify(response.text)
+
+        return {
+            "url": str(response.url),
+            "markdown_content": markdown_content,
+            "status_code": response.status_code,
+            "content_length": len(markdown_content),
+        }
+    except requests.exceptions.RequestException as e:
+        return {"error": f"Fetch URL error: {e!s}", "url": url}