ripperdoc 0.1.0__py3-none-any.whl

ripperdoc/tools/file_edit_tool.py

@@ -0,0 +1,281 @@
+"""File editing tool.
+
+Allows the AI to edit files by replacing text.
+"""
+
+import os
+from typing import AsyncGenerator, List, Optional
+from pydantic import BaseModel, Field
+
+from ripperdoc.core.tool import (
+    Tool,
+    ToolUseContext,
+    ToolResult,
+    ToolOutput,
+    ToolUseExample,
+    ValidationResult,
+)
+
+
+class FileEditToolInput(BaseModel):
+    """Input schema for FileEditTool."""
+
+    file_path: str = Field(description="Absolute path to the file to edit")
+    old_string: str = Field(description="The text to replace (must match exactly)")
+    new_string: str = Field(description="The text to replace it with")
+    replace_all: bool = Field(
+        default=False, description="Replace all occurrences (default: false, only first)"
+    )
+
+
+class FileEditToolOutput(BaseModel):
+    """Output from file editing."""
+
+    file_path: str
+    replacements_made: int
+    success: bool
+    message: str
+    additions: int = 0
+    deletions: int = 0
+    diff_lines: list[str] = []
+    diff_with_line_numbers: list[str] = []
+
+
+class FileEditTool(Tool[FileEditToolInput, FileEditToolOutput]):
+    """Tool for editing files by replacing text."""
+
+    @property
+    def name(self) -> str:
+        return "Edit"
+
+    async def description(self) -> str:
+        return """Edit a file by replacing exact string matches. The old_string must
+match exactly (including whitespace and indentation)."""
+
+    @property
+    def input_schema(self) -> type[FileEditToolInput]:
+        return FileEditToolInput
+
+    def input_examples(self) -> List[ToolUseExample]:
+        return [
+            ToolUseExample(
+                description="Rename a function definition once",
+                input={
+                    "file_path": "/repo/src/app.py",
+                    "old_string": "def old_name(",
+                    "new_string": "def new_name(",
+                    "replace_all": False,
+                },
+            ),
+            ToolUseExample(
+                description="Replace every occurrence of a constant across a file",
+                input={
+                    "file_path": "/repo/src/config.ts",
+                    "old_string": 'API_BASE = "http://localhost"',
+                    "new_string": 'API_BASE = "https://api.example.com"',
+                    "replace_all": True,
+                },
+            ),
+        ]
+
+    async def prompt(self, safe_mode: bool = False) -> str:
+        return (
+            "Performs exact string replacements in files.\n\n"
+            "Usage:\n"
+            "- You must use your `View` tool at least once in the conversation to read the file before editing; edits will fail if you skip reading.\n"
+            "- When editing text from View output, preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix is formatted as spaces + line number + tab. Never include any part of the prefix in old_string or new_string.\n"
+            "- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n"
+            "- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.\n"
+            "- The edit will FAIL if `old_string` is not unique in the file. Provide more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`.\n"
+            "- Use `replace_all` when replacing or renaming strings across the file (e.g., renaming a variable)."
+        )
+
+    def is_read_only(self) -> bool:
+        return False
+
+    def is_concurrency_safe(self) -> bool:
+        return False
+
+    def needs_permissions(self, input_data: Optional[FileEditToolInput] = None) -> bool:
+        return True
+
+    async def validate_input(
+        self, input_data: FileEditToolInput, context: Optional[ToolUseContext] = None
+    ) -> 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}")
+
+        # 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}"
+            )
+
+        # 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"
+            )
+
+        return ValidationResult(result=True)
+
+    def render_result_for_assistant(self, output: FileEditToolOutput) -> str:
+        """Format output for the AI."""
+        # Return simple message for AI, but include structured data for UI
+        # The UI will extract the structured data from the output object
+        return output.message
+
+    def render_tool_use_message(self, input_data: FileEditToolInput, verbose: bool = False) -> str:
+        """Format the tool use for display."""
+        return f"Editing: {input_data.file_path}"
+
+    async def call(
+        self, input_data: FileEditToolInput, context: ToolUseContext
+    ) -> AsyncGenerator[ToolOutput, None]:
+        """Edit the file."""
+
+        try:
+            # Read the file
+            with open(input_data.file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Check if old_string exists
+            if input_data.old_string not in content:
+                output = FileEditToolOutput(
+                    file_path=input_data.file_path,
+                    replacements_made=0,
+                    success=False,
+                    message=f"String not found in file: {input_data.file_path}",
+                )
+                yield ToolResult(
+                    data=output, result_for_assistant=self.render_result_for_assistant(output)
+                )
+                return
+
+            # Count occurrences
+            occurrence_count = content.count(input_data.old_string)
+
+            # Check for ambiguity if not replace_all
+            if not input_data.replace_all and occurrence_count > 1:
+                output = FileEditToolOutput(
+                    file_path=input_data.file_path,
+                    replacements_made=0,
+                    success=False,
+                    message=f"String appears {occurrence_count} times in file. "
+                    f"Either provide a unique string or use replace_all=true",
+                )
+                yield ToolResult(
+                    data=output, result_for_assistant=self.render_result_for_assistant(output)
+                )
+                return
+
+            # Perform replacement
+            if input_data.replace_all:
+                new_content = content.replace(input_data.old_string, input_data.new_string)
+                replacements = occurrence_count
+            else:
+                new_content = content.replace(input_data.old_string, input_data.new_string, 1)
+                replacements = 1
+
+            # Write the file
+            with open(input_data.file_path, "w", encoding="utf-8") as f:
+                f.write(new_content)
+
+            # Generate diff for display
+            import difflib
+
+            old_lines = content.splitlines(keepends=True)
+            new_lines = new_content.splitlines(keepends=True)
+
+            diff = list(
+                difflib.unified_diff(
+                    old_lines,
+                    new_lines,
+                    fromfile=input_data.file_path,
+                    tofile=input_data.file_path,
+                    lineterm="",
+                )
+            )
+
+            # Count additions and deletions from diff
+            additions = sum(
+                1 for line in diff if line.startswith("+") and not line.startswith("+++")
+            )
+            deletions = sum(
+                1 for line in diff if line.startswith("-") and not line.startswith("---")
+            )
+
+            # Store diff lines for display
+            diff_lines = []
+            for line in diff[3:]:  # Skip header lines
+                diff_lines.append(line)
+
+            # Generate diff with line numbers for better display
+            diff_with_line_numbers = []
+            old_line_num = None
+            new_line_num = None
+
+            for line in diff[3:]:  # Skip header lines
+                if line.startswith("@@"):
+                    # Parse line numbers from diff header
+                    import re
+
+                    match = re.search(r"@@ -(\d+),(\d+) \+(\d+),(\d+) @@", line)
+                    if match:
+                        old_line_num = int(match.group(1))
+                        new_line_num = int(match.group(3))
+                        diff_with_line_numbers.append(f"      [dim]{line}[/dim]")
+                elif line.startswith("+") and not line.startswith("+++"):
+                    if new_line_num is not None:
+                        diff_with_line_numbers.append(
+                            f"      [green]{new_line_num:6d} + {line[1:]}[/green]"
+                        )
+                        new_line_num += 1
+                    else:
+                        diff_with_line_numbers.append(f"      [green]{line}[/green]")
+                elif line.startswith("-") and not line.startswith("---"):
+                    if old_line_num is not None:
+                        diff_with_line_numbers.append(
+                            f"      [red]{old_line_num:6d} - {line[1:]}[/red]"
+                        )
+                        old_line_num += 1
+                    else:
+                        diff_with_line_numbers.append(f"      [red]{line}[/red]")
+                elif line.strip():
+                    if old_line_num is not None and new_line_num is not None:
+                        diff_with_line_numbers.append(
+                            f"      {old_line_num:6d}   {new_line_num:6d}   {line}"
+                        )
+                        old_line_num += 1
+                        new_line_num += 1
+                    else:
+                        diff_with_line_numbers.append(f"      {line}")
+
+            output = FileEditToolOutput(
+                file_path=input_data.file_path,
+                replacements_made=replacements,
+                success=True,
+                message=f"Successfully made {replacements} replacement(s) in {input_data.file_path}",
+                additions=additions,
+                deletions=deletions,
+                diff_lines=diff_lines,
+                diff_with_line_numbers=diff_with_line_numbers,
+            )
+
+            yield ToolResult(
+                data=output, result_for_assistant=self.render_result_for_assistant(output)
+            )
+
+        except Exception as e:
+            error_output = FileEditToolOutput(
+                file_path=input_data.file_path,
+                replacements_made=0,
+                success=False,
+                message=f"Error editing file: {str(e)}",
+            )
+
+            yield ToolResult(
+                data=error_output,
+                result_for_assistant=self.render_result_for_assistant(error_output),
+            )

ripperdoc/tools/file_read_tool.py

@@ -0,0 +1,168 @@
+"""File reading tool.
+
+Allows the AI to read file contents.
+"""
+
+import os
+from typing import AsyncGenerator, List, Optional
+from pydantic import BaseModel, Field
+
+from ripperdoc.core.tool import (
+    Tool,
+    ToolUseContext,
+    ToolResult,
+    ToolOutput,
+    ToolUseExample,
+    ValidationResult,
+)
+
+
+class FileReadToolInput(BaseModel):
+    """Input schema for FileReadTool."""
+
+    file_path: str = Field(description="Absolute path to the file to read")
+    offset: Optional[int] = Field(
+        default=None, description="Line number to start reading from (optional)"
+    )
+    limit: Optional[int] = Field(default=None, description="Number of lines to read (optional)")
+
+
+class FileReadToolOutput(BaseModel):
+    """Output from file reading."""
+
+    content: str
+    file_path: str
+    line_count: int
+    offset: int
+    limit: Optional[int]
+
+
+class FileReadTool(Tool[FileReadToolInput, FileReadToolOutput]):
+    """Tool for reading file contents."""
+
+    @property
+    def name(self) -> str:
+        return "View"
+
+    async def description(self) -> str:
+        return """Read the contents of a file. You can optionally specify an offset
+and limit to read only a portion of the file."""
+
+    @property
+    def input_schema(self) -> type[FileReadToolInput]:
+        return FileReadToolInput
+
+    def input_examples(self) -> List[ToolUseExample]:
+        return [
+            ToolUseExample(
+                description="Read the top of a file to understand structure",
+                input={"file_path": "/repo/src/main.py", "limit": 50},
+            ),
+            ToolUseExample(
+                description="Inspect a slice of a large log without loading everything",
+                input={"file_path": "/repo/logs/server.log", "offset": 200, "limit": 40},
+            ),
+        ]
+
+    async def prompt(self, safe_mode: bool = False) -> str:
+        return (
+            "Read a file from the local filesystem.\n\n"
+            "Usage:\n"
+            "- The file_path parameter must be an absolute path (not relative).\n"
+            "- By default, the entire file is read. You can optionally specify a line offset and limit (handy for long files); offset is zero-based and output line numbers start at 1.\n"
+            "- Lines longer than 2000 characters are truncated in the output.\n"
+            "- Results are returned with cat -n style numbering: spaces + line number + tab, then the file content.\n"
+            "- You can call multiple tools in a single response—speculatively read multiple potentially useful files together.\n"
+            "- It is okay to attempt reading a non-existent file; an error will be returned if the file is missing."
+        )
+
+    def is_read_only(self) -> bool:
+        return True
+
+    def is_concurrency_safe(self) -> bool:
+        return True
+
+    def needs_permissions(self, input_data: Optional[FileReadToolInput] = None) -> bool:
+        return False
+
+    async def validate_input(
+        self, input_data: FileReadToolInput, context: Optional[ToolUseContext] = None
+    ) -> 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}")
+
+        # Check if it's a file (not a directory)
+        if not os.path.isfile(input_data.file_path):
+            return ValidationResult(
+                result=False, message=f"Path is not a file: {input_data.file_path}"
+            )
+
+        return ValidationResult(result=True)
+
+    def render_result_for_assistant(self, output: FileReadToolOutput) -> str:
+        """Format output for the AI."""
+        lines = output.content.split("\n")
+        numbered_lines = []
+
+        for i, line in enumerate(lines, start=output.offset + 1):
+            # Truncate very long lines
+            if len(line) > 2000:
+                line = line[:2000] + "... [truncated]"
+            numbered_lines.append(f"{i:6d}\t{line}")
+
+        return "\n".join(numbered_lines)
+
+    def render_tool_use_message(self, input_data: FileReadToolInput, verbose: bool = False) -> str:
+        """Format the tool use for display."""
+        msg = f"Reading: {input_data.file_path}"
+        if input_data.offset or input_data.limit:
+            msg += f" (offset: {input_data.offset}, limit: {input_data.limit})"
+        return msg
+
+    async def call(
+        self, input_data: FileReadToolInput, context: ToolUseContext
+    ) -> AsyncGenerator[ToolOutput, None]:
+        """Read the file."""
+
+        try:
+            with open(input_data.file_path, "r", encoding="utf-8", errors="replace") as f:
+                lines = f.readlines()
+
+            offset = input_data.offset or 0
+            limit = input_data.limit
+
+            # Apply offset and limit
+            if limit is not None:
+                selected_lines = lines[offset : offset + limit]
+            else:
+                selected_lines = lines[offset:]
+
+            content = "".join(selected_lines)
+
+            output = FileReadToolOutput(
+                content=content,
+                file_path=input_data.file_path,
+                line_count=len(selected_lines),
+                offset=offset,
+                limit=limit,
+            )
+
+            yield ToolResult(
+                data=output, result_for_assistant=self.render_result_for_assistant(output)
+            )
+
+        except Exception as e:
+            # Create an error output
+            error_output = FileReadToolOutput(
+                content=f"Error reading file: {str(e)}",
+                file_path=input_data.file_path,
+                line_count=0,
+                offset=0,
+                limit=None,
+            )
+
+            yield ToolResult(
+                data=error_output,
+                result_for_assistant=f"Error reading file {input_data.file_path}: {str(e)}",
+            )

ripperdoc/tools/file_write_tool.py

@@ -0,0 +1,141 @@
+"""File writing tool.
+
+Allows the AI to create new files.
+"""
+
+import os
+from pathlib import Path
+from typing import AsyncGenerator, List, Optional
+from pydantic import BaseModel, Field
+
+from ripperdoc.core.tool import (
+    Tool,
+    ToolUseContext,
+    ToolResult,
+    ToolOutput,
+    ToolUseExample,
+    ValidationResult,
+)
+
+
+class FileWriteToolInput(BaseModel):
+    """Input schema for FileWriteTool."""
+
+    file_path: str = Field(description="Absolute path to the file to create")
+    content: str = Field(description="Content to write to the file")
+
+
+class FileWriteToolOutput(BaseModel):
+    """Output from file writing."""
+
+    file_path: str
+    bytes_written: int
+    success: bool
+    message: str
+
+
+class FileWriteTool(Tool[FileWriteToolInput, FileWriteToolOutput]):
+    """Tool for creating new files."""
+
+    @property
+    def name(self) -> str:
+        return "Write"
+
+    async def description(self) -> str:
+        return """Create a new file with the specified content. This will overwrite
+the file if it already exists."""
+
+    @property
+    def input_schema(self) -> type[FileWriteToolInput]:
+        return FileWriteToolInput
+
+    def input_examples(self) -> List[ToolUseExample]:
+        return [
+            ToolUseExample(
+                description="Create a JSON fixture file",
+                input={"file_path": "/repo/tests/fixtures/sample.json", "content": '{\n  "items": []\n}\n'},
+            ),
+            ToolUseExample(
+                description="Write a short markdown note",
+                input={"file_path": "/repo/docs/USAGE.md", "content": "# Usage\n\nRun `make test`.\n"},
+            ),
+        ]
+
+    async def prompt(self, safe_mode: bool = False) -> str:
+        prompt = """Use the Write tool to create new files. """
+
+        if safe_mode:
+            prompt += """IMPORTANT: You must ALWAYS prefer editing existing files.
+NEVER write new files unless explicitly required by the user."""
+
+        return prompt
+
+    def is_read_only(self) -> bool:
+        return False
+
+    def is_concurrency_safe(self) -> bool:
+        return False
+
+    def needs_permissions(self, input_data: Optional[FileWriteToolInput] = None) -> bool:
+        return True
+
+    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}"
+            )
+
+        return ValidationResult(result=True)
+
+    def render_result_for_assistant(self, output: FileWriteToolOutput) -> str:
+        """Format output for the AI."""
+        return output.message
+
+    def render_tool_use_message(self, input_data: FileWriteToolInput, verbose: bool = False) -> str:
+        """Format the tool use for display."""
+        return f"Writing: {input_data.file_path} ({len(input_data.content)} bytes)"
+
+    async def call(
+        self, input_data: FileWriteToolInput, context: ToolUseContext
+    ) -> AsyncGenerator[ToolOutput, None]:
+        """Write the file."""
+
+        try:
+            # Write the file
+            with open(input_data.file_path, "w", encoding="utf-8") as f:
+                f.write(input_data.content)
+
+            bytes_written = len(input_data.content.encode("utf-8"))
+
+            output = FileWriteToolOutput(
+                file_path=input_data.file_path,
+                bytes_written=bytes_written,
+                success=True,
+                message=f"Successfully wrote {bytes_written} bytes to {input_data.file_path}",
+            )
+
+            yield ToolResult(
+                data=output, result_for_assistant=self.render_result_for_assistant(output)
+            )
+
+        except Exception as e:
+            error_output = FileWriteToolOutput(
+                file_path=input_data.file_path,
+                bytes_written=0,
+                success=False,
+                message=f"Error writing file: {str(e)}",
+            )
+
+            yield ToolResult(
+                data=error_output,
+                result_for_assistant=self.render_result_for_assistant(error_output),
+            )