devorch 0.1.2__py3-none-any.whl

tools/edit.py

@@ -0,0 +1,236 @@
+"""
+Edit Tool - Make targeted edits to files.
+Supports find/replace, line-based edits, and smart code modifications.
+"""
+
+import difflib
+import os
+import re
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+from tools.base import Tool
+
+
+class EditToolSchema(BaseModel):
+    action: Literal["replace", "replace_lines", "insert", "delete", "patch"] = Field(
+        ..., description="Edit action: replace (find/replace), replace_lines, insert, delete, patch"
+    )
+    path: str = Field(..., description="Path to the file to edit.")
+    find: str = Field(default="", description="Text or pattern to find (for replace action).")
+    replace_with: str = Field(default="", description="Replacement text.")
+    line_start: int = Field(
+        default=0, description="Start line number (1-indexed, for line-based actions)."
+    )
+    line_end: int = Field(default=0, description="End line number (for replace_lines/delete).")
+    content: str = Field(default="", description="Content for insert or patch action.")
+    regex: bool = Field(default=False, description="Treat 'find' as regex pattern.")
+    count: int = Field(default=1, description="Number of replacements (0 = all).")
+    dry_run: bool = Field(default=False, description="Preview changes without applying.")
+
+
+class EditTool(Tool):
+    """
+    Make targeted edits to files with precise control.
+    Returns a diff showing the changes made.
+    """
+
+    name = "edit"
+    description = """Make targeted edits to files. More precise than full file writes.
+
+Actions:
+- replace: Find and replace text (supports regex)
+- replace_lines: Replace specific line range with new content
+- insert: Insert content at a specific line
+- delete: Delete lines in a range
+- patch: Apply a unified diff patch
+
+Examples:
+- Replace text: action="replace", path="file.py", find="old_func", replace_with="new_func"
+- Replace all: action="replace", path="file.py", find="TODO", replace_with="DONE", count=0
+- Regex replace: action="replace", find="def (\\w+)\\(", replace_with="async def \\1(", regex=true
+- Replace lines 10-15: action="replace_lines", line_start=10, line_end=15, content="new code"
+- Insert at line 5: action="insert", line_start=5, content="# New comment"
+- Delete lines 20-25: action="delete", line_start=20, line_end=25
+- Preview changes: dry_run=true
+
+Always use dry_run=true first to preview significant changes!"""
+    args_schema = EditToolSchema
+
+    def _read_file(self, path: str) -> list[str]:
+        """Read file and return lines."""
+        with open(path, encoding="utf-8") as f:
+            return f.readlines()
+
+    def _write_file(self, path: str, lines: list[str]):
+        """Write lines to file."""
+        with open(path, "w", encoding="utf-8") as f:
+            f.writelines(lines)
+
+    def _generate_diff(self, original: list[str], modified: list[str], path: str) -> str:
+        """Generate a unified diff between original and modified content."""
+        diff = difflib.unified_diff(
+            original, modified, fromfile=f"a/{path}", tofile=f"b/{path}", lineterm=""
+        )
+        return "\n".join(diff)
+
+    def _replace_text(
+        self, lines: list[str], find: str, replace_with: str, regex: bool = False, count: int = 1
+    ) -> tuple[list[str], int]:
+        """Replace text in content. Returns (new_lines, replacement_count)."""
+        content = "".join(lines)
+        replacements = 0
+
+        if regex:
+            try:
+                pattern = re.compile(find)
+                if count == 0:
+                    new_content, replacements = pattern.subn(replace_with, content)
+                else:
+                    new_content, replacements = pattern.subn(replace_with, content, count=count)
+            except re.error as e:
+                raise ValueError(f"Invalid regex: {e}") from e
+        else:
+            if count == 0:
+                replacements = content.count(find)
+                new_content = content.replace(find, replace_with)
+            else:
+                new_content = content.replace(find, replace_with, count)
+                replacements = min(content.count(find), count)
+
+        # Preserve line structure
+        if new_content and not new_content.endswith("\n") and lines and lines[-1].endswith("\n"):
+            new_content += "\n"
+
+        new_lines = new_content.splitlines(keepends=True)
+        return new_lines, replacements
+
+    def _replace_lines(self, lines: list[str], start: int, end: int, new_content: str) -> list[str]:
+        """Replace lines in range with new content."""
+        # Convert to 0-indexed
+        start_idx = max(0, start - 1)
+        end_idx = min(len(lines), end)
+
+        # Ensure new content ends with newline
+        if new_content and not new_content.endswith("\n"):
+            new_content += "\n"
+
+        new_lines = new_content.splitlines(keepends=True) if new_content else []
+
+        return lines[:start_idx] + new_lines + lines[end_idx:]
+
+    def _insert_lines(self, lines: list[str], at_line: int, content: str) -> list[str]:
+        """Insert content at a specific line."""
+        # Convert to 0-indexed
+        insert_idx = max(0, min(len(lines), at_line - 1))
+
+        # Ensure content ends with newline
+        if content and not content.endswith("\n"):
+            content += "\n"
+
+        new_lines = content.splitlines(keepends=True) if content else []
+
+        return lines[:insert_idx] + new_lines + lines[insert_idx:]
+
+    def _delete_lines(self, lines: list[str], start: int, end: int) -> list[str]:
+        """Delete lines in range."""
+        start_idx = max(0, start - 1)
+        end_idx = min(len(lines), end)
+
+        return lines[:start_idx] + lines[end_idx:]
+
+    def run(self, arguments: dict[str, Any]) -> Any:
+        action = arguments.get("action")
+        path = arguments.get("path")
+        find = arguments.get("find", "")
+        replace_with = arguments.get("replace_with", "")
+        line_start = arguments.get("line_start", 0)
+        line_end = arguments.get("line_end", 0)
+        content = arguments.get("content", "")
+        regex = arguments.get("regex", False)
+        count = arguments.get("count", 1)
+        dry_run = arguments.get("dry_run", False)
+
+        if not path:
+            return "Error: Path not provided."
+
+        if not os.path.isfile(path):
+            return f"Error: File '{path}' not found."
+
+        try:
+            original_lines = self._read_file(path)
+            modified_lines = original_lines.copy()
+            change_summary = ""
+
+            if action == "replace":
+                if not find:
+                    return "Error: 'find' parameter required for replace action."
+
+                modified_lines, num_replacements = self._replace_text(
+                    modified_lines, find, replace_with, regex, count
+                )
+
+                if num_replacements == 0:
+                    return f"No matches found for: {find}"
+
+                change_summary = f"Replaced {num_replacements} occurrence(s)"
+
+            elif action == "replace_lines":
+                if line_start <= 0:
+                    return "Error: line_start must be >= 1"
+                if line_end <= 0:
+                    line_end = line_start  # Replace single line
+
+                if line_start > len(original_lines):
+                    return f"Error: line_start ({line_start}) exceeds file length ({len(original_lines)})"
+
+                modified_lines = self._replace_lines(modified_lines, line_start, line_end, content)
+                change_summary = f"Replaced lines {line_start}-{line_end}"
+
+            elif action == "insert":
+                if line_start <= 0:
+                    return "Error: line_start must be >= 1"
+                if not content:
+                    return "Error: 'content' parameter required for insert action."
+
+                modified_lines = self._insert_lines(modified_lines, line_start, content)
+                inserted_count = len(content.splitlines())
+                change_summary = f"Inserted {inserted_count} line(s) at line {line_start}"
+
+            elif action == "delete":
+                if line_start <= 0:
+                    return "Error: line_start must be >= 1"
+                if line_end <= 0:
+                    line_end = line_start  # Delete single line
+
+                if line_start > len(original_lines):
+                    return f"Error: line_start ({line_start}) exceeds file length ({len(original_lines)})"
+
+                modified_lines = self._delete_lines(modified_lines, line_start, line_end)
+                deleted_count = min(line_end, len(original_lines)) - line_start + 1
+                change_summary = f"Deleted {deleted_count} line(s) ({line_start}-{line_end})"
+
+            elif action == "patch":
+                # Apply a unified diff patch (more complex, basic implementation)
+                return "Error: Patch action not yet implemented. Use replace_lines instead."
+
+            else:
+                return f"Error: Unknown action '{action}'"
+
+            # Generate diff
+            diff = self._generate_diff(original_lines, modified_lines, path)
+
+            if not diff:
+                return "No changes needed."
+
+            if dry_run:
+                return f"[DRY RUN] {change_summary}\n\nPreview:\n{diff}"
+
+            # Apply changes
+            self._write_file(path, modified_lines)
+
+            return f"{change_summary}\n\nDiff:\n{diff}"
+
+        except Exception as e:
+            return f"Edit error: {str(e)}"

tools/filesystem.py

@@ -0,0 +1,224 @@
+import os
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+from tools.base import Tool
+
+
+class FilesystemToolSchema(BaseModel):
+    action: Literal["read", "write", "list", "read_lines", "info"] = Field(
+        ..., description="Action: read (full file), read_lines (specific lines), write, list, info"
+    )
+    path: str = Field(..., description="Path to the file or directory.")
+    content: str = Field(default="", description="Content to write (only for 'write' action).")
+    start_line: int = Field(default=1, description="Start line number for read_lines (1-indexed).")
+    end_line: int = Field(
+        default=0, description="End line number for read_lines (0 = to end of file)."
+    )
+    max_lines: int = Field(default=200, description="Maximum lines to return for read action.")
+
+
+class FilesystemTool(Tool):
+    name = "filesystem"
+    description = """Read, write, or list files and directories with line-specific control.
+
+Actions:
+- read: Read file content (with line numbers, truncated at max_lines)
+- read_lines: Read specific line range (start_line to end_line)
+- write: Write content to file
+- list: List directory contents with file info
+- info: Get file metadata (size, modified date, line count)
+
+Examples:
+- Read first 50 lines: action="read", path="file.py", max_lines=50
+- Read lines 100-150: action="read_lines", path="file.py", start_line=100, end_line=150
+- Get file info: action="info", path="file.py"
+"""
+    args_schema = FilesystemToolSchema
+
+    def _format_size(self, size: int) -> str:
+        """Format file size in human-readable format."""
+        for unit in ["B", "KB", "MB", "GB"]:
+            if size < 1024:
+                return f"{size:.1f}{unit}"
+            size /= 1024
+        return f"{size:.1f}TB"
+
+    def _count_lines(self, path: str) -> int:
+        """Count lines in a file efficiently."""
+        try:
+            with open(path, encoding="utf-8", errors="ignore") as f:
+                return sum(1 for _ in f)
+        except Exception:
+            return -1
+
+    def _read_with_line_numbers(
+        self, path: str, start_line: int = 1, end_line: int = 0, max_lines: int = 200
+    ) -> str:
+        """Read file with line numbers, supporting line ranges."""
+        try:
+            with open(path, encoding="utf-8", errors="ignore") as f:
+                lines = f.readlines()
+
+            total_lines = len(lines)
+
+            # Adjust line numbers (1-indexed)
+            start_idx = max(0, start_line - 1)
+            if end_line > 0:
+                end_idx = min(total_lines, end_line)
+            else:
+                end_idx = min(start_idx + max_lines, total_lines)
+
+            # Build output with line numbers
+            output_lines = []
+            line_num_width = len(str(end_idx))
+
+            for i in range(start_idx, end_idx):
+                line_num = str(i + 1).rjust(line_num_width)
+                output_lines.append(f"{line_num} | {lines[i].rstrip()}")
+
+            # Add truncation notice if needed
+            header = f"[{path}] Lines {start_idx + 1}-{end_idx} of {total_lines}\n"
+
+            if end_idx < total_lines and end_line == 0:
+                footer = f"\n... ({total_lines - end_idx} more lines)"
+            else:
+                footer = ""
+
+            return header + "\n".join(output_lines) + footer
+
+        except Exception as e:
+            return f"Error reading file: {str(e)}"
+
+    def _list_directory(self, path: str) -> str:
+        """List directory with file info."""
+        try:
+            items = os.listdir(path)
+            if not items:
+                return "Directory is empty."
+
+            output = []
+            dirs = []
+            files = []
+
+            for item in sorted(items):
+                item_path = os.path.join(path, item)
+                if os.path.isdir(item_path):
+                    dirs.append(f"  [DIR]  {item}/")
+                else:
+                    try:
+                        size = os.path.getsize(item_path)
+                        size_str = self._format_size(size)
+                        files.append(f"  {size_str:>8}  {item}")
+                    except Exception:
+                        files.append(f"  {'?':>8}  {item}")
+
+            if dirs:
+                output.append("Directories:")
+                output.extend(dirs)
+            if files:
+                if dirs:
+                    output.append("")
+                output.append("Files:")
+                output.extend(files)
+
+            return "\n".join(output)
+
+        except Exception as e:
+            return f"Error listing directory: {str(e)}"
+
+    def _get_file_info(self, path: str) -> str:
+        """Get file metadata."""
+        try:
+            stat = os.stat(path)
+            size = self._format_size(stat.st_size)
+            modified = os.path.getmtime(path)
+
+            from datetime import datetime
+
+            mod_date = datetime.fromtimestamp(modified).strftime("%Y-%m-%d %H:%M:%S")
+
+            info = [
+                f"Path: {os.path.abspath(path)}",
+                f"Size: {size} ({stat.st_size} bytes)",
+                f"Modified: {mod_date}",
+            ]
+
+            # Add line count for text files
+            ext = os.path.splitext(path)[1].lower()
+            text_exts = {
+                ".py",
+                ".js",
+                ".ts",
+                ".json",
+                ".yaml",
+                ".yml",
+                ".md",
+                ".txt",
+                ".html",
+                ".css",
+            }
+            if ext in text_exts or not ext:
+                line_count = self._count_lines(path)
+                if line_count >= 0:
+                    info.append(f"Lines: {line_count}")
+
+            return "\n".join(info)
+
+        except Exception as e:
+            return f"Error getting file info: {str(e)}"
+
+    def run(self, arguments: dict[str, Any]) -> Any:
+        action = arguments.get("action")
+        path = arguments.get("path")
+        content = arguments.get("content", "")
+        start_line = arguments.get("start_line", 1)
+        end_line = arguments.get("end_line", 0)
+        max_lines = min(arguments.get("max_lines", 200), 500)  # Cap at 500
+
+        if not path:
+            return "Error: Path not provided."
+
+        try:
+            if action == "read":
+                if not os.path.isfile(path):
+                    return f"Error: File '{path}' not found."
+                return self._read_with_line_numbers(path, max_lines=max_lines)
+
+            elif action == "read_lines":
+                if not os.path.isfile(path):
+                    return f"Error: File '{path}' not found."
+                return self._read_with_line_numbers(path, start_line, end_line, max_lines=500)
+
+            elif action == "write":
+                # Create directory if needed
+                dir_path = os.path.dirname(path)
+                if dir_path and not os.path.exists(dir_path):
+                    os.makedirs(dir_path)
+
+                with open(path, "w", encoding="utf-8") as f:
+                    f.write(content)
+
+                line_count = content.count("\n") + (
+                    1 if content and not content.endswith("\n") else 0
+                )
+                return f"Successfully wrote {line_count} lines to {path}"
+
+            elif action == "list":
+                if not os.path.exists(path):
+                    return f"Error: Path '{path}' does not exist."
+                if os.path.isfile(path):
+                    return self._get_file_info(path)
+                return self._list_directory(path)
+
+            elif action == "info":
+                if not os.path.exists(path):
+                    return f"Error: Path '{path}' does not exist."
+                return self._get_file_info(path)
+
+            else:
+                return f"Error: Unknown action '{action}'. Use: read, read_lines, write, list, info"
+
+        except Exception as e:
+            return f"Filesystem error: {str(e)}"