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

ripperdoc/tools/exit_plan_mode_tool.py

@@ -0,0 +1,153 @@
+"""Exit plan mode tool for presenting implementation plans.
+
+This tool allows the AI to exit plan mode and present an implementation
+plan to the user for approval before starting to code.
+"""
+
+from __future__ import annotations
+
+from textwrap import dedent
+from typing import AsyncGenerator, Optional
+
+from pydantic import BaseModel, Field
+
+from ripperdoc.core.tool import (
+    Tool,
+    ToolOutput,
+    ToolResult,
+    ToolUseContext,
+    ValidationResult,
+)
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
+
+TOOL_NAME = "ExitPlanMode"
+
+EXIT_PLAN_MODE_PROMPT = dedent(
+    """\
+    Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.
+
+    ## How This Tool Works
+    - You should have already written your plan to the plan file specified in the plan mode system message
+    - This tool does NOT take the plan content as a parameter - it will read the plan from the file you wrote
+    - This tool simply signals that you're done planning and ready for the user to review and approve
+    - The user will see the contents of your plan file when they review it
+
+    ## When to Use This Tool
+    IMPORTANT: Only use this tool when the task requires planning the implementation steps of a task that requires writing code. For research tasks where you're gathering information, searching files, reading files or in general trying to understand the codebase - do NOT use this tool.
+
+    ## Handling Ambiguity in Plans
+    Before using this tool, ensure your plan is clear and unambiguous. If there are multiple valid approaches or unclear requirements:
+    1. Use the AskUserQuestion tool to clarify with the user
+    2. Ask about specific implementation choices (e.g., architectural patterns, which library to use)
+    3. Clarify any assumptions that could affect the implementation
+    4. Edit your plan file to incorporate user feedback
+    5. Only proceed with ExitPlanMode after resolving ambiguities and updating the plan file
+
+    ## Examples
+
+    1. Initial task: "Search for and understand the implementation of vim mode in the codebase" - Do not use the exit plan mode tool because you are not planning the implementation steps of a task.
+    2. Initial task: "Help me implement yank mode for vim" - Use the exit plan mode tool after you have finished planning the implementation steps of the task.
+    3. Initial task: "Add a new feature to handle user authentication" - If unsure about auth method (OAuth, JWT, etc.), use AskUserQuestion first, then use exit plan mode tool after clarifying the approach.
+    """
+)
+
+
+class ExitPlanModeToolInput(BaseModel):
+    """Input for the ExitPlanMode tool."""
+
+    plan: str = Field(
+        description="The plan you came up with, that you want to run by the user for approval. "
+        "Supports markdown. The plan should be pretty concise."
+    )
+
+
+class ExitPlanModeToolOutput(BaseModel):
+    """Output from the ExitPlanMode tool."""
+
+    plan: str
+    is_agent: bool = False
+
+
+class ExitPlanModeTool(Tool[ExitPlanModeToolInput, ExitPlanModeToolOutput]):
+    """Tool for exiting plan mode and presenting a plan for approval."""
+
+    @property
+    def name(self) -> str:
+        return TOOL_NAME
+
+    async def description(self) -> str:
+        return "Prompts the user to exit plan mode and start coding"
+
+    @property
+    def input_schema(self) -> type[ExitPlanModeToolInput]:
+        return ExitPlanModeToolInput
+
+    async def prompt(self, safe_mode: bool = False) -> str:  # noqa: ARG002
+        return EXIT_PLAN_MODE_PROMPT
+
+    def user_facing_name(self) -> str:
+        return "Exit plan mode"
+
+    def is_read_only(self) -> bool:
+        return True
+
+    def is_concurrency_safe(self) -> bool:
+        return True
+
+    def needs_permissions(
+        self,
+        input_data: Optional[ExitPlanModeToolInput] = None,  # noqa: ARG002
+    ) -> bool:
+        return True
+
+    async def validate_input(
+        self,
+        input_data: ExitPlanModeToolInput,
+        context: Optional[ToolUseContext] = None,  # noqa: ARG002
+    ) -> ValidationResult:
+        """Validate that plan is not empty."""
+        if not input_data.plan or not input_data.plan.strip():
+            return ValidationResult(
+                result=False,
+                message="Plan cannot be empty",
+            )
+        return ValidationResult(result=True)
+
+    def render_result_for_assistant(self, output: ExitPlanModeToolOutput) -> str:
+        """Render the tool output for the AI assistant."""
+        return f"Exit plan mode and start coding now. Plan:\n{output.plan}"
+
+    def render_tool_use_message(
+        self,
+        input_data: ExitPlanModeToolInput,
+        verbose: bool = False,  # noqa: ARG002
+    ) -> str:
+        """Render the tool use message for display."""
+        plan = input_data.plan
+        snippet = f"{plan[:77]}..." if len(plan) > 80 else plan
+        return f"Share plan for approval: {snippet}"
+
+    async def call(
+        self,
+        input_data: ExitPlanModeToolInput,
+        context: ToolUseContext,
+    ) -> AsyncGenerator[ToolOutput, None]:
+        """Execute the tool to exit plan mode."""
+        # Invoke the exit plan mode callback if available
+        if context.on_exit_plan_mode:
+            try:
+                context.on_exit_plan_mode()
+            except (RuntimeError, ValueError, TypeError):
+                logger.debug("[exit_plan_mode_tool] Failed to call on_exit_plan_mode")
+
+        is_agent = bool(context.agent_id)
+        output = ExitPlanModeToolOutput(
+            plan=input_data.plan,
+            is_agent=is_agent,
+        )
+        yield ToolResult(
+            data=output,
+            result_for_assistant=self.render_result_for_assistant(output),
+        )

ripperdoc/tools/file_edit_tool.py

@@ -4,6 +4,7 @@ Allows the AI to edit files by replacing text.
 """
 
 import os
+from pathlib import Path
 from typing import AsyncGenerator, List, Optional
 from pydantic import BaseModel, Field
 
@@ -17,6 +18,7 @@ from ripperdoc.core.tool import (
 )
 from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.file_watch import record_snapshot
+from ripperdoc.utils.path_ignore import check_path_for_tool
 
 logger = get_logger()
 
@@ -108,20 +110,59 @@ match exactly (including whitespace and indentation)."""
     ) -> ValidationResult:
         # Check if file exists
         if not os.path.exists(input_data.file_path):
-            return ValidationResult(result=False, message=f"File not found: {input_data.file_path}")
+            return ValidationResult(
+                result=False,
+                message=f"File not found: {input_data.file_path}",
+                error_code=1,
+            )
 
         # Check if it's a file
         if not os.path.isfile(input_data.file_path):
             return ValidationResult(
-                result=False, message=f"Path is not a file: {input_data.file_path}"
+                result=False,
+                message=f"Path is not a file: {input_data.file_path}",
+                error_code=2,
             )
 
         # Check that old_string and new_string are different
         if input_data.old_string == input_data.new_string:
             return ValidationResult(
-                result=False, message="old_string and new_string must be different"
+                result=False,
+                message="old_string and new_string must be different",
+                error_code=3,
+            )
+
+        # Check if file has been read before editing
+        file_state_cache = getattr(context, "file_state_cache", {}) if context else {}
+        file_path = os.path.abspath(input_data.file_path)
+        file_snapshot = file_state_cache.get(file_path)
+
+        if not file_snapshot:
+            return ValidationResult(
+                result=False,
+                message="File has not been read yet. Read it first before editing.",
+                error_code=4,
             )
 
+        # Check if file has been modified since it was read
+        try:
+            current_mtime = os.path.getmtime(file_path)
+            if current_mtime > file_snapshot.timestamp:
+                return ValidationResult(
+                    result=False,
+                    message="File has been modified since read, either by the user or by a linter. "
+                    "Read it again before attempting to edit it.",
+                    error_code=5,
+                )
+        except OSError:
+            pass  # File mtime check failed, proceed anyway
+
+        # Check if path is ignored (warning for edit operations)
+        file_path_obj = Path(file_path)
+        should_proceed, warning_msg = check_path_for_tool(file_path_obj, tool_name="Edit", warn_only=True)
+        if warning_msg:
+            logger.warning("[file_edit_tool] %s", warning_msg)
+
         return ValidationResult(result=True)
 
     def render_result_for_assistant(self, output: FileEditToolOutput) -> str:
@@ -192,9 +233,10 @@ match exactly (including whitespace and indentation)."""
                     new_content,
                     getattr(context, "file_state_cache", {}),
                 )
-            except Exception:
-                logger.exception(
-                    "[file_edit_tool] Failed to record file snapshot",
+            except (OSError, IOError, RuntimeError) as exc:
+                logger.warning(
+                    "[file_edit_tool] Failed to record file snapshot: %s: %s",
+                    type(exc).__name__, exc,
                     extra={"file_path": input_data.file_path},
                 )
 
@@ -283,10 +325,11 @@ match exactly (including whitespace and indentation)."""
                 data=output, result_for_assistant=self.render_result_for_assistant(output)
             )
 
-        except Exception as e:
-            logger.exception(
-                "[file_edit_tool] Error editing file",
-                extra={"file_path": input_data.file_path, "error": str(e)},
+        except (OSError, IOError, PermissionError, UnicodeDecodeError, ValueError) as e:
+            logger.warning(
+                "[file_edit_tool] Error editing file: %s: %s",
+                type(e).__name__, e,
+                extra={"file_path": input_data.file_path},
             )
             error_output = FileEditToolOutput(
                 file_path=input_data.file_path,

ripperdoc/tools/file_read_tool.py

@@ -4,6 +4,7 @@ Allows the AI to read file contents.
 """
 
 import os
+from pathlib import Path
 from typing import AsyncGenerator, List, Optional
 from pydantic import BaseModel, Field
 
@@ -17,6 +18,7 @@ from ripperdoc.core.tool import (
 )
 from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.file_watch import record_snapshot
+from ripperdoc.utils.path_ignore import check_path_for_tool, is_path_ignored
 
 logger = get_logger()
 
@@ -102,6 +104,12 @@ and limit to read only a portion of the file."""
                 result=False, message=f"Path is not a file: {input_data.file_path}"
             )
 
+        # Check if path is ignored (warning only for read operations)
+        file_path = Path(input_data.file_path)
+        should_proceed, warning_msg = check_path_for_tool(file_path, tool_name="Read", warn_only=True)
+        if warning_msg:
+            logger.info("[file_read_tool] %s", warning_msg)
+
         return ValidationResult(result=True)
 
     def render_result_for_assistant(self, output: FileReadToolOutput) -> str:
@@ -153,9 +161,10 @@ and limit to read only a portion of the file."""
                     offset=offset,
                     limit=limit,
                 )
-            except Exception:
-                logger.exception(
-                    "[file_read_tool] Failed to record file snapshot",
+            except (OSError, IOError, RuntimeError) as exc:
+                logger.warning(
+                    "[file_read_tool] Failed to record file snapshot: %s: %s",
+                    type(exc).__name__, exc,
                     extra={"file_path": input_data.file_path},
                 )
 
@@ -171,10 +180,11 @@ and limit to read only a portion of the file."""
                 data=output, result_for_assistant=self.render_result_for_assistant(output)
             )
 
-        except Exception as e:
-            logger.exception(
-                "[file_read_tool] Error reading file",
-                extra={"file_path": input_data.file_path, "error": str(e)},
+        except (OSError, IOError, UnicodeDecodeError, ValueError) as e:
+            logger.warning(
+                "[file_read_tool] Error reading file: %s: %s",
+                type(e).__name__, e,
+                extra={"file_path": input_data.file_path},
             )
             # Create an error output
             error_output = FileReadToolOutput(

ripperdoc/tools/file_write_tool.py

@@ -18,6 +18,7 @@ from ripperdoc.core.tool import (
 )
 from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.file_watch import record_snapshot
+from ripperdoc.utils.path_ignore import check_path_for_tool
 
 logger = get_logger()
 
@@ -92,18 +93,51 @@ NEVER write new files unless explicitly required by the user."""
     async def validate_input(
         self, input_data: FileWriteToolInput, context: Optional[ToolUseContext] = None
     ) -> ValidationResult:
-        # Check if file already exists (warning)
-        if os.path.exists(input_data.file_path):
-            # In safe mode, this should be handled by permissions
-            pass
-
         # Check if parent directory exists
         parent = Path(input_data.file_path).parent
         if not parent.exists():
             return ValidationResult(
-                result=False, message=f"Parent directory does not exist: {parent}"
+                result=False,
+                message=f"Parent directory does not exist: {parent}",
+                error_code=1,
             )
 
+        file_path = os.path.abspath(input_data.file_path)
+
+        # If file doesn't exist, it's a new file - allow without reading first
+        if not os.path.exists(file_path):
+            return ValidationResult(result=True)
+
+        # File exists - check if it has been read before writing
+        file_state_cache = getattr(context, "file_state_cache", {}) if context else {}
+        file_snapshot = file_state_cache.get(file_path)
+
+        if not file_snapshot:
+            return ValidationResult(
+                result=False,
+                message="File has not been read yet. Read it first before writing to it.",
+                error_code=2,
+            )
+
+        # Check if file has been modified since it was read
+        try:
+            current_mtime = os.path.getmtime(file_path)
+            if current_mtime > file_snapshot.timestamp:
+                return ValidationResult(
+                    result=False,
+                    message="File has been modified since read, either by the user or by a linter. "
+                    "Read it again before attempting to write it.",
+                    error_code=3,
+                )
+        except OSError:
+            pass  # File mtime check failed, proceed anyway
+
+        # Check if path is ignored (warning for write operations)
+        file_path_obj = Path(file_path)
+        should_proceed, warning_msg = check_path_for_tool(file_path_obj, tool_name="Write", warn_only=True)
+        if warning_msg:
+            logger.warning("[file_write_tool] %s", warning_msg)
+
         return ValidationResult(result=True)
 
     def render_result_for_assistant(self, output: FileWriteToolOutput) -> str:
@@ -132,9 +166,10 @@ NEVER write new files unless explicitly required by the user."""
                     input_data.content,
                     getattr(context, "file_state_cache", {}),
                 )
-            except Exception:
-                logger.exception(
-                    "[file_write_tool] Failed to record file snapshot",
+            except (OSError, IOError, RuntimeError) as exc:
+                logger.warning(
+                    "[file_write_tool] Failed to record file snapshot: %s: %s",
+                    type(exc).__name__, exc,
                     extra={"file_path": input_data.file_path},
                 )
 
@@ -149,10 +184,11 @@ NEVER write new files unless explicitly required by the user."""
                 data=output, result_for_assistant=self.render_result_for_assistant(output)
             )
 
-        except Exception as e:
-            logger.exception(
-                "[file_write_tool] Error writing file",
-                extra={"file_path": input_data.file_path, "error": str(e)},
+        except (OSError, IOError, PermissionError, UnicodeEncodeError) as e:
+            logger.warning(
+                "[file_write_tool] Error writing file: %s: %s",
+                type(e).__name__, e,
+                extra={"file_path": input_data.file_path},
             )
             error_output = FileWriteToolOutput(
                 file_path=input_data.file_path,

ripperdoc/tools/glob_tool.py

@@ -76,7 +76,7 @@ class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
             ),
         ]
 
-    async def prompt(self, safe_mode: bool = False) -> str:
+    async def prompt(self, _safe_mode: bool = False) -> str:
         return GLOB_USAGE
 
     def is_read_only(self) -> bool:
@@ -85,11 +85,11 @@ class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
     def is_concurrency_safe(self) -> bool:
         return True
 
-    def needs_permissions(self, input_data: Optional[GlobToolInput] = None) -> bool:
+    def needs_permissions(self, _input_data: Optional[GlobToolInput] = None) -> bool:
         return False
 
     async def validate_input(
-        self, input_data: GlobToolInput, context: Optional[ToolUseContext] = None
+        self, _input_data: GlobToolInput, _context: Optional[ToolUseContext] = None
     ) -> ValidationResult:
         return ValidationResult(result=True)
 
@@ -103,7 +103,7 @@ class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
             lines.append("(Results are truncated. Consider using a more specific path or pattern.)")
         return "\n".join(lines)
 
-    def render_tool_use_message(self, input_data: GlobToolInput, verbose: bool = False) -> str:
+    def render_tool_use_message(self, input_data: GlobToolInput, _verbose: bool = False) -> str:
         """Format the tool use for display."""
         if not input_data.pattern:
             return "Glob"
@@ -123,7 +123,7 @@ class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
             except ValueError:
                 relative_path = None
 
-            if verbose or not relative_path or str(relative_path) == ".":
+            if _verbose or not relative_path or str(relative_path) == ".":
                 rendered_path = str(absolute_path)
             else:
                 rendered_path = str(relative_path)
@@ -132,7 +132,7 @@ class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
         return f'pattern: "{input_data.pattern}"{path_fragment}'
 
     async def call(
-        self, input_data: GlobToolInput, context: ToolUseContext
+        self, input_data: GlobToolInput, _context: ToolUseContext
     ) -> AsyncGenerator[ToolOutput, None]:
         """Find files matching the pattern."""
 
@@ -166,9 +166,10 @@ class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
                 data=output, result_for_assistant=self.render_result_for_assistant(output)
             )
 
-        except Exception as e:
-            logger.exception(
-                "[glob_tool] Error executing glob",
+        except (OSError, RuntimeError, ValueError) as e:
+            logger.warning(
+                "[glob_tool] Error executing glob: %s: %s",
+                type(e).__name__, e,
                 extra={"pattern": input_data.pattern, "path": input_data.path},
             )
             error_output = GlobToolOutput(matches=[], pattern=input_data.pattern, count=0)