ripperdoc 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

ripperdoc/cli/ui/tool_renderers.py

@@ -0,0 +1,298 @@
+"""Tool result renderers for CLI display.
+
+This module provides a strategy pattern implementation for rendering different
+tool results in the Rich CLI interface.
+"""
+
+from typing import Any, Callable, List, Optional
+
+from rich.console import Console
+from rich.markup import escape
+
+
+class ToolResultRenderer:
+    """Base class for rendering tool results to console."""
+
+    def __init__(self, console: Console, verbose: bool = False):
+        self.console = console
+        self.verbose = verbose
+
+    def can_handle(self, _sender: str) -> bool:
+        """Return True if this renderer handles the given tool name."""
+        raise NotImplementedError
+
+    def render(self, _content: str, _tool_data: Any) -> None:
+        """Render the tool result to console."""
+        raise NotImplementedError
+
+    def _get_field(self, data: Any, key: str, default: Any = None) -> Any:
+        """Safely fetch a field from either an object or a dict."""
+        if isinstance(data, dict):
+            return data.get(key, default)
+        return getattr(data, key, default)
+
+
+class TodoResultRenderer(ToolResultRenderer):
+    """Render Todo tool results."""
+
+    def can_handle(self, sender: str) -> bool:
+        return "Todo" in sender
+
+    def render(self, content: str, _tool_data: Any) -> None:
+        lines = content.splitlines()
+        if lines:
+            self.console.print(f"  ⎿  [dim]{escape(lines[0])}[/]")
+            for line in lines[1:]:
+                self.console.print(f"      {line}", markup=False)
+        else:
+            self.console.print("  ⎿  [dim]Todo update[/]")
+
+
+class ReadResultRenderer(ToolResultRenderer):
+    """Render Read/View tool results."""
+
+    def can_handle(self, sender: str) -> bool:
+        return "Read" in sender or "View" in sender
+
+    def render(self, content: str, _tool_data: Any) -> None:
+        lines = content.split("\n")
+        line_count = len(lines)
+        self.console.print(f"  ⎿  [dim]Read {line_count} lines[/]")
+        if self.verbose:
+            preview = lines[:30]
+            for line in preview:
+                self.console.print(line, markup=False)
+            if len(lines) > len(preview):
+                self.console.print(f"[dim]... ({len(lines) - len(preview)} more lines)[/]")
+
+
+class EditResultRenderer(ToolResultRenderer):
+    """Render Write/Edit/MultiEdit tool results."""
+
+    def can_handle(self, sender: str) -> bool:
+        return "Write" in sender or "Edit" in sender or "MultiEdit" in sender
+
+    def render(self, _content: str, tool_data: Any) -> None:
+        if tool_data and (hasattr(tool_data, "file_path") or isinstance(tool_data, dict)):
+            file_path = self._get_field(tool_data, "file_path")
+            additions = self._get_field(tool_data, "additions", 0)
+            deletions = self._get_field(tool_data, "deletions", 0)
+            diff_with_line_numbers = self._get_field(tool_data, "diff_with_line_numbers", [])
+
+            if not file_path:
+                self.console.print("  ⎿  [dim]File updated successfully[/]")
+                return
+
+            self.console.print(
+                f"  ⎿  [dim]Updated {escape(str(file_path))} with {additions} additions and {deletions} removals[/]"
+            )
+
+            if self.verbose:
+                for line in diff_with_line_numbers:
+                    self.console.print(line, markup=False)
+        else:
+            self.console.print("  ⎿  [dim]File updated successfully[/]")
+
+
+class GlobResultRenderer(ToolResultRenderer):
+    """Render Glob tool results."""
+
+    def can_handle(self, sender: str) -> bool:
+        return "Glob" in sender
+
+    def render(self, content: str, _tool_data: Any) -> None:
+        files = content.split("\n")
+        file_count = len([f for f in files if f.strip()])
+        self.console.print(f"  ⎿  [dim]Found {file_count} files[/]")
+        if self.verbose:
+            for line in files[:30]:
+                if line.strip():
+                    self.console.print(f"      {line}", markup=False)
+            if file_count > 30:
+                self.console.print(f"[dim]... ({file_count - 30} more)[/]")
+
+
+class GrepResultRenderer(ToolResultRenderer):
+    """Render Grep tool results."""
+
+    def can_handle(self, sender: str) -> bool:
+        return "Grep" in sender
+
+    def render(self, content: str, _tool_data: Any) -> None:
+        matches = content.split("\n")
+        match_count = len([m for m in matches if m.strip()])
+        self.console.print(f"  ⎿  [dim]Found {match_count} matches[/]")
+        if self.verbose:
+            for line in matches[:30]:
+                if line.strip():
+                    self.console.print(f"      {line}", markup=False)
+            if match_count > 30:
+                self.console.print(f"[dim]... ({match_count - 30} more)[/]")
+
+
+class LSResultRenderer(ToolResultRenderer):
+    """Render LS tool results."""
+
+    def can_handle(self, sender: str) -> bool:
+        return "LS" in sender
+
+    def render(self, content: str, _tool_data: Any) -> None:
+        tree_lines = content.splitlines()
+        self.console.print(f"  ⎿  [dim]Directory tree ({len(tree_lines)} lines)[/]")
+        if self.verbose:
+            preview = tree_lines[:40]
+            for line in preview:
+                self.console.print(f"      {line}", markup=False)
+            if len(tree_lines) > len(preview):
+                self.console.print(f"[dim]... ({len(tree_lines) - len(preview)} more)[/]")
+
+
+# Type alias for bash output parser callback
+BashOutputParser = Callable[[str], tuple[List[str], List[str]]]
+
+
+class BashResultRenderer(ToolResultRenderer):
+    """Render Bash tool results."""
+
+    def __init__(
+        self, console: Console, verbose: bool = False, parse_fallback: Optional[BashOutputParser] = None
+    ):
+        super().__init__(console, verbose)
+        self._parse_fallback = parse_fallback
+
+    def can_handle(self, sender: str) -> bool:
+        return "Bash" in sender
+
+    def render(self, content: str, tool_data: Any) -> None:
+        stdout_lines: List[str] = []
+        stderr_lines: List[str] = []
+        exit_code = 0
+        duration_ms = 0
+        timeout_ms = 0
+
+        if tool_data:
+            exit_code = self._get_field(tool_data, "exit_code", 0)
+            stdout = self._get_field(tool_data, "stdout", "") or ""
+            stderr = self._get_field(tool_data, "stderr", "") or ""
+            duration_ms = self._get_field(tool_data, "duration_ms", 0) or 0
+            timeout_ms = self._get_field(tool_data, "timeout_ms", 0) or 0
+            stdout_lines = stdout.splitlines() if stdout else []
+            stderr_lines = stderr.splitlines() if stderr else []
+
+        if not stdout_lines and not stderr_lines and content and self._parse_fallback:
+            stdout_lines, stderr_lines = self._parse_fallback(content)
+
+        show_inline_stdout = (
+            stdout_lines and not stderr_lines and exit_code == 0 and not self.verbose
+        )
+
+        if show_inline_stdout:
+            preview = stdout_lines if self.verbose else stdout_lines[:5]
+            self.console.print(f"  ⎿  {preview[0]}", markup=False)
+            for line in preview[1:]:
+                self.console.print(f"      {line}", markup=False)
+            if not self.verbose and len(stdout_lines) > len(preview):
+                self.console.print(f"[dim]... ({len(stdout_lines) - len(preview)} more lines)[/]")
+        else:
+            self._render_detailed_output(
+                tool_data, exit_code, duration_ms, timeout_ms, stdout_lines, stderr_lines
+            )
+
+    def _render_detailed_output(
+        self,
+        tool_data: Any,
+        exit_code: int,
+        duration_ms: float,
+        timeout_ms: int,
+        stdout_lines: List[str],
+        stderr_lines: List[str],
+    ) -> None:
+        """Render detailed Bash output with exit code, stdout, stderr."""
+        if tool_data:
+            timing = ""
+            if duration_ms:
+                timing = f" ({duration_ms / 1000:.2f}s"
+                if timeout_ms:
+                    timing += f" / timeout {timeout_ms / 1000:.0f}s"
+                timing += ")"
+            elif timeout_ms:
+                timing = f" (timeout {timeout_ms / 1000:.0f}s)"
+            self.console.print(f"  ⎿  [dim]Exit code {exit_code}{timing}[/]")
+        else:
+            self.console.print("  ⎿  [dim]Command executed[/]")
+
+        # Render stdout
+        if stdout_lines:
+            preview = stdout_lines if self.verbose else stdout_lines[:5]
+            self.console.print("[dim]stdout:[/]")
+            for line in preview:
+                self.console.print(f"      {line}", markup=False)
+            if not self.verbose and len(stdout_lines) > len(preview):
+                self.console.print(
+                    f"[dim]... ({len(stdout_lines) - len(preview)} more stdout lines)[/]"
+                )
+        else:
+            self.console.print("[dim]stdout:[/]")
+            self.console.print("      [dim](no stdout)[/]")
+
+        # Render stderr
+        if stderr_lines:
+            preview = stderr_lines if self.verbose else stderr_lines[:5]
+            self.console.print("[dim]stderr:[/]")
+            for line in preview:
+                self.console.print(f"      {line}", markup=False)
+            if not self.verbose and len(stderr_lines) > len(preview):
+                self.console.print(
+                    f"[dim]... ({len(stderr_lines) - len(preview)} more stderr lines)[/]"
+                )
+        else:
+            self.console.print("[dim]stderr:[/]")
+            self.console.print("      [dim](no stderr)[/]")
+
+
+class ToolResultRendererRegistry:
+    """Registry that selects the appropriate renderer for a tool result."""
+
+    def __init__(
+        self, console: Console, verbose: bool = False, parse_bash_fallback: Optional[BashOutputParser] = None
+    ):
+        self.console = console
+        self.verbose = verbose
+        self._renderers: List[ToolResultRenderer] = [
+            TodoResultRenderer(console, verbose),
+            ReadResultRenderer(console, verbose),
+            EditResultRenderer(console, verbose),
+            GlobResultRenderer(console, verbose),
+            GrepResultRenderer(console, verbose),
+            LSResultRenderer(console, verbose),
+            BashResultRenderer(console, verbose, parse_bash_fallback),
+        ]
+
+    def get_renderer(self, sender: str) -> Optional[ToolResultRenderer]:
+        """Get the appropriate renderer for the given tool name."""
+        for renderer in self._renderers:
+            if renderer.can_handle(sender):
+                return renderer
+        return None
+
+    def render(self, sender: str, content: str, tool_data: Any) -> bool:
+        """Render the tool result. Returns True if rendered, False otherwise."""
+        renderer = self.get_renderer(sender)
+        if renderer:
+            renderer.render(content, tool_data)
+            return True
+        return False
+
+
+__all__ = [
+    "ToolResultRenderer",
+    "ToolResultRendererRegistry",
+    "TodoResultRenderer",
+    "ReadResultRenderer",
+    "EditResultRenderer",
+    "GlobResultRenderer",
+    "GrepResultRenderer",
+    "LSResultRenderer",
+    "BashResultRenderer",
+    "BashOutputParser",
+]

ripperdoc/core/agents.py

@@ -11,11 +11,63 @@ from typing import Any, Dict, Iterable, List, Optional, Tuple
 import yaml
 
 from ripperdoc.utils.log import get_logger
+from ripperdoc.tools.ask_user_question_tool import AskUserQuestionTool
+from ripperdoc.tools.bash_output_tool import BashOutputTool
+from ripperdoc.tools.bash_tool import BashTool
+from ripperdoc.tools.enter_plan_mode_tool import EnterPlanModeTool
+from ripperdoc.tools.exit_plan_mode_tool import ExitPlanModeTool
+from ripperdoc.tools.file_edit_tool import FileEditTool
+from ripperdoc.tools.file_read_tool import FileReadTool
+from ripperdoc.tools.file_write_tool import FileWriteTool
+from ripperdoc.tools.glob_tool import GlobTool
+from ripperdoc.tools.grep_tool import GrepTool
+from ripperdoc.tools.kill_bash_tool import KillBashTool
+from ripperdoc.tools.ls_tool import LSTool
+from ripperdoc.tools.multi_edit_tool import MultiEditTool
+from ripperdoc.tools.notebook_edit_tool import NotebookEditTool
+from ripperdoc.tools.todo_tool import TodoReadTool, TodoWriteTool
+from ripperdoc.tools.tool_search_tool import ToolSearchTool
+from ripperdoc.tools.mcp_tools import (
+    ListMcpResourcesTool,
+    ListMcpServersTool,
+    ReadMcpResourceTool,
+)
 
 
 logger = get_logger()
 
 
+def _safe_tool_name(factory: Any, fallback: str) -> str:
+    try:
+        name = getattr(factory(), "name", None)
+        return str(name) if name else fallback
+    except (TypeError, ValueError, RuntimeError, AttributeError):
+        return fallback
+
+
+GLOB_TOOL_NAME = _safe_tool_name(GlobTool, "Glob")
+GREP_TOOL_NAME = _safe_tool_name(GrepTool, "Grep")
+VIEW_TOOL_NAME = _safe_tool_name(FileReadTool, "View")
+FILE_EDIT_TOOL_NAME = _safe_tool_name(FileEditTool, "FileEdit")
+MULTI_EDIT_TOOL_NAME = _safe_tool_name(MultiEditTool, "MultiEdit")
+NOTEBOOK_EDIT_TOOL_NAME = _safe_tool_name(NotebookEditTool, "NotebookEdit")
+FILE_WRITE_TOOL_NAME = _safe_tool_name(FileWriteTool, "FileWrite")
+LS_TOOL_NAME = _safe_tool_name(LSTool, "LS")
+BASH_TOOL_NAME = _safe_tool_name(BashTool, "Bash")
+BASH_OUTPUT_TOOL_NAME = _safe_tool_name(BashOutputTool, "BashOutput")
+KILL_BASH_TOOL_NAME = _safe_tool_name(KillBashTool, "KillBash")
+TODO_READ_TOOL_NAME = _safe_tool_name(TodoReadTool, "TodoRead")
+TODO_WRITE_TOOL_NAME = _safe_tool_name(TodoWriteTool, "TodoWrite")
+ASK_USER_QUESTION_TOOL_NAME = _safe_tool_name(AskUserQuestionTool, "AskUserQuestion")
+ENTER_PLAN_MODE_TOOL_NAME = _safe_tool_name(EnterPlanModeTool, "EnterPlanMode")
+EXIT_PLAN_MODE_TOOL_NAME = _safe_tool_name(ExitPlanModeTool, "ExitPlanMode")
+TOOL_SEARCH_TOOL_NAME = _safe_tool_name(ToolSearchTool, "ToolSearch")
+MCP_LIST_SERVERS_TOOL_NAME = _safe_tool_name(ListMcpServersTool, "ListMcpServers")
+MCP_LIST_RESOURCES_TOOL_NAME = _safe_tool_name(ListMcpResourcesTool, "ListMcpResources")
+MCP_READ_RESOURCE_TOOL_NAME = _safe_tool_name(ReadMcpResourceTool, "ReadMcpResource")
+TASK_TOOL_NAME = "Task"
+
+
 AGENT_DIR_NAME = "agents"
 
 
@@ -64,6 +116,86 @@ CODE_REVIEW_AGENT_PROMPT = (
     "Provide clear, actionable feedback that the parent agent can relay to the user."
 )
 
+EXPLORE_AGENT_PROMPT = (
+    "You are a file search specialist. "
+    "You excel at thoroughly navigating and exploring codebases.\n\n"
+    "=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===\n"
+    "This is a READ-ONLY exploration task. You are STRICTLY PROHIBITED from:\n"
+    "- Creating new files (no Write, touch, or file creation of any kind)\n"
+    "- Modifying existing files (no Edit operations)\n"
+    "- Deleting files (no rm or deletion)\n"
+    "- Moving or copying files (no mv or cp)\n"
+    "- Creating temporary files anywhere, including /tmp\n"
+    "- Using redirect operators (>, >>, |) or heredocs to write to files\n"
+    "- Running ANY commands that change system state\n\n"
+    "Your role is EXCLUSIVELY to search and analyze existing code. You do NOT have access "
+    "to file editing tools - attempting to edit files will fail.\n\n"
+    "Your strengths:\n"
+    "- Rapidly finding files using glob patterns\n"
+    "- Searching code and text with powerful regex patterns\n"
+    "- Reading and analyzing file contents\n\n"
+    "Guidelines:\n"
+    f"- Use {GLOB_TOOL_NAME} for broad file pattern matching\n"
+    f"- Use {GREP_TOOL_NAME} for searching file contents with regex\n"
+    f"- Use {VIEW_TOOL_NAME} when you know the specific file path you need to read\n"
+    f"- Use {BASH_TOOL_NAME} ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail)\n"
+    f"- NEVER use {BASH_TOOL_NAME} for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification\n"
+    "- Adapt your search approach based on the thoroughness level specified by the caller\n"
+    "- Return file paths as absolute paths in your final response\n"
+    "- For clear communication, avoid using emojis\n"
+    "- Communicate your final report directly as a regular message - do NOT attempt to create files\n\n"
+    "NOTE: You are meant to be a fast agent that returns output as quickly as possible. In order to achieve this you must:\n"
+    "- Make efficient use of the tools that you have at your disposal: be smart about how you search for files and implementations\n"
+    "- Wherever possible you should try to spawn multiple parallel tool calls for grepping and reading files\n\n"
+    "Complete the user's search request efficiently and report your findings clearly."
+)
+
+PLAN_AGENT_PROMPT = (
+    "You are a software architect and planning specialist. Your role is "
+    "to explore the codebase and design implementation plans.\n\n"
+    "=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===\n"
+    "This is a READ-ONLY planning task. You are STRICTLY PROHIBITED from:\n"
+    "- Creating new files (no Write, touch, or file creation of any kind)\n"
+    "- Modifying existing files (no Edit operations)\n"
+    "- Deleting files (no rm or deletion)\n"
+    "- Moving or copying files (no mv or cp)\n"
+    "- Creating temporary files anywhere, including /tmp\n"
+    "- Using redirect operators (>, >>, |) or heredocs to write to files\n"
+    "- Running ANY commands that change system state\n\n"
+    "Your role is EXCLUSIVELY to explore the codebase and design implementation plans. "
+    "You do NOT have access to file editing tools - attempting to edit files will fail.\n\n"
+    "You will be provided with a set of requirements and optionally a perspective on how "
+    "to approach the design process.\n\n"
+    "## Your Process\n\n"
+    "1. **Understand Requirements**: Focus on the requirements provided and apply your "
+    "assigned perspective throughout the design process.\n\n"
+    "2. **Explore Thoroughly**:\n"
+    "   - Read any files provided to you in the initial prompt\n"
+    f"   - Find existing patterns and conventions using {GLOB_TOOL_NAME}, {GREP_TOOL_NAME}, and {VIEW_TOOL_NAME}\n"
+    "   - Understand the current architecture\n"
+    "   - Identify similar features as reference\n"
+    "   - Trace through relevant code paths\n"
+    f"   - Use {BASH_TOOL_NAME} ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail)\n"
+    f"   - NEVER use {BASH_TOOL_NAME} for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification\n\n"
+    "3. **Design Solution**:\n"
+    "   - Create implementation approach based on your assigned perspective\n"
+    "   - Consider trade-offs and architectural decisions\n"
+    "   - Follow existing patterns where appropriate\n\n"
+    "4. **Detail the Plan**:\n"
+    "   - Provide step-by-step implementation strategy\n"
+    "   - Identify dependencies and sequencing\n"
+    "   - Anticipate potential challenges\n\n"
+    "## Required Output\n\n"
+    "End your response with:\n\n"
+    "### Critical Files for Implementation\n"
+    "List 3-5 files most critical for implementing this plan:\n"
+    '- path/to/file1.ts - [Brief reason: e.g., "Core logic to modify"]\n'
+    '- path/to/file2.ts - [Brief reason: e.g., "Interfaces to implement"]\n'
+    '- path/to/file3.ts - [Brief reason: e.g., "Pattern to follow"]\n\n'
+    "REMEMBER: You can ONLY explore and plan. You CANNOT and MUST NOT write, edit, or "
+    "modify any files. You do NOT have access to file editing tools."
+)
+
 
 def _built_in_agents() -> List[AgentDefinition]:
     return [
@@ -89,6 +221,34 @@ def _built_in_agents() -> List[AgentDefinition]:
             location=AgentLocation.BUILT_IN,
             color="yellow",
         ),
+        AgentDefinition(
+            agent_type="explore",
+            when_to_use=(
+                "Fast agent specialized for exploring codebases. Use this when you need to quickly find "
+                'files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), '
+                'or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, '
+                'specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, '
+                'or "very thorough" for comprehensive analysis across multiple locations and naming conventions.'
+            ),
+            tools=["View", "Glob", "Grep"],
+            system_prompt=EXPLORE_AGENT_PROMPT,
+            location=AgentLocation.BUILT_IN,
+            color="green",
+            model="task",
+        ),
+        AgentDefinition(
+            agent_type="plan",
+            when_to_use=(
+                "Software architect agent for designing implementation plans. Use this when "
+                "you need to plan the implementation strategy for a task. Returns step-by-step "
+                "plans, identifies critical files, and considers architectural trade-offs."
+            ),
+            tools=["View", "Glob", "Grep"],
+            system_prompt=PLAN_AGENT_PROMPT,
+            location=AgentLocation.BUILT_IN,
+            color="blue",
+            model=None,
+        ),
     ]
 
 
@@ -118,8 +278,12 @@ def _split_frontmatter(raw_text: str) -> Tuple[Dict[str, Any], str]:
                 body = "\n".join(lines[idx + 1 :])
                 try:
                     frontmatter = yaml.safe_load(frontmatter_text) or {}
-                except Exception as exc:  # pragma: no cover - defensive
-                    logger.exception("Invalid frontmatter in agent file", extra={"error": str(exc)})
+                except (yaml.YAMLError, ValueError, TypeError) as exc:  # pragma: no cover - defensive
+                    logger.warning(
+                        "Invalid frontmatter in agent file: %s: %s",
+                        type(exc).__name__, exc,
+                        extra={"error": str(exc)},
+                    )
                     return {"__error__": f"Invalid frontmatter: {exc}"}, body
                 return frontmatter, body
     return {}, raw_text
@@ -145,8 +309,12 @@ def _parse_agent_file(
     """Parse a single agent file."""
     try:
         text = path.read_text(encoding="utf-8")
-    except Exception as exc:
-        logger.exception("Failed to read agent file", extra={"error": str(exc), "path": str(path)})
+    except (OSError, IOError, UnicodeDecodeError) as exc:
+        logger.warning(
+            "Failed to read agent file: %s: %s",
+            type(exc).__name__, exc,
+            extra={"error": str(exc), "path": str(path)},
+        )
         return None, f"Failed to read agent file {path}: {exc}"
 
     frontmatter, body = _split_frontmatter(text)