codemaster-cli 2.2.0__py3-none-any.whl

vibe/core/tools/builtins/read_file.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar, NamedTuple, final
+
+import anyio
+from pydantic import BaseModel, Field
+
+from vibe.core.tools.base import (
+    BaseTool,
+    BaseToolConfig,
+    BaseToolState,
+    InvokeContext,
+    ToolError,
+    ToolPermission,
+)
+from vibe.core.tools.ui import ToolCallDisplay, ToolResultDisplay, ToolUIData
+from vibe.core.types import ToolStreamEvent
+
+if TYPE_CHECKING:
+    from vibe.core.types import ToolCallEvent, ToolResultEvent
+
+
+class _ReadResult(NamedTuple):
+    lines: list[str]
+    bytes_read: int
+    was_truncated: bool
+
+
+class ReadFileArgs(BaseModel):
+    path: str
+    offset: int = Field(
+        default=0,
+        description="Line number to start reading from (0-indexed, inclusive).",
+    )
+    limit: int | None = Field(
+        default=None, description="Maximum number of lines to read."
+    )
+
+
+class ReadFileResult(BaseModel):
+    path: str
+    content: str
+    lines_read: int
+    was_truncated: bool = Field(
+        description="True if the reading was stopped due to the max_read_bytes limit."
+    )
+
+
+class ReadFileToolConfig(BaseToolConfig):
+    permission: ToolPermission = ToolPermission.ALWAYS
+
+    max_read_bytes: int = Field(
+        default=64_000, description="Maximum total bytes to read from a file in one go."
+    )
+    max_state_history: int = Field(
+        default=10, description="Number of recently read files to remember in state."
+    )
+
+
+class ReadFileState(BaseToolState):
+    recently_read_files: list[str] = Field(default_factory=list)
+
+
+class ReadFile(
+    BaseTool[ReadFileArgs, ReadFileResult, ReadFileToolConfig, ReadFileState],
+    ToolUIData[ReadFileArgs, ReadFileResult],
+):
+    description: ClassVar[str] = (
+        "Read a UTF-8 file, returning content from a specific line range. "
+        "Reading is capped by a byte limit for safety."
+    )
+
+    @final
+    async def run(
+        self, args: ReadFileArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | ReadFileResult, None]:
+        file_path = self._prepare_and_validate_path(args)
+
+        read_result = await self._read_file(args, file_path)
+
+        self._update_state_history(file_path)
+
+        yield ReadFileResult(
+            path=str(file_path),
+            content="".join(read_result.lines),
+            lines_read=len(read_result.lines),
+            was_truncated=read_result.was_truncated,
+        )
+
+    def check_allowlist_denylist(self, args: ReadFileArgs) -> ToolPermission | None:
+        import fnmatch
+
+        file_path = Path(args.path).expanduser()
+        if not file_path.is_absolute():
+            file_path = Path.cwd() / file_path
+        file_str = str(file_path)
+
+        for pattern in self.config.denylist:
+            if fnmatch.fnmatch(file_str, pattern):
+                return ToolPermission.NEVER
+
+        for pattern in self.config.allowlist:
+            if fnmatch.fnmatch(file_str, pattern):
+                return ToolPermission.ALWAYS
+
+        return None
+
+    def _prepare_and_validate_path(self, args: ReadFileArgs) -> Path:
+        self._validate_inputs(args)
+
+        file_path = Path(args.path).expanduser()
+        if not file_path.is_absolute():
+            file_path = Path.cwd() / file_path
+
+        self._validate_path(file_path)
+        return file_path
+
+    async def _read_file(self, args: ReadFileArgs, file_path: Path) -> _ReadResult:
+        try:
+            lines_to_return: list[str] = []
+            bytes_read = 0
+            was_truncated = False
+
+            async with await anyio.Path(file_path).open(
+                encoding="utf-8", errors="ignore"
+            ) as f:
+                line_index = 0
+                async for line in f:
+                    if line_index < args.offset:
+                        line_index += 1
+                        continue
+
+                    if args.limit is not None and len(lines_to_return) >= args.limit:
+                        break
+
+                    line_bytes = len(line.encode("utf-8"))
+                    if bytes_read + line_bytes > self.config.max_read_bytes:
+                        was_truncated = True
+                        break
+
+                    lines_to_return.append(line)
+                    bytes_read += line_bytes
+                    line_index += 1
+
+            return _ReadResult(
+                lines=lines_to_return,
+                bytes_read=bytes_read,
+                was_truncated=was_truncated,
+            )
+
+        except OSError as exc:
+            raise ToolError(f"Error reading {file_path}: {exc}") from exc
+
+    def _validate_inputs(self, args: ReadFileArgs) -> None:
+        if not args.path.strip():
+            raise ToolError("Path cannot be empty")
+        if args.offset < 0:
+            raise ToolError("Offset cannot be negative")
+        if args.limit is not None and args.limit <= 0:
+            raise ToolError("Limit, if provided, must be a positive number")
+
+    def _validate_path(self, file_path: Path) -> None:
+        try:
+            resolved_path = file_path.resolve()
+        except ValueError:
+            raise ToolError(
+                f"Security error: Cannot read path '{file_path}' outside of the project directory '{Path.cwd()}'."
+            )
+        except FileNotFoundError:
+            raise ToolError(f"File not found at: {file_path}")
+
+        if not resolved_path.exists():
+            raise ToolError(f"File not found at: {file_path}")
+        if resolved_path.is_dir():
+            raise ToolError(f"Path is a directory, not a file: {file_path}")
+
+    def _update_state_history(self, file_path: Path) -> None:
+        self.state.recently_read_files.append(str(file_path.resolve()))
+        if len(self.state.recently_read_files) > self.config.max_state_history:
+            self.state.recently_read_files.pop(0)
+
+    @classmethod
+    def get_call_display(cls, event: ToolCallEvent) -> ToolCallDisplay:
+        if not isinstance(event.args, ReadFileArgs):
+            return ToolCallDisplay(summary="read_file")
+
+        summary = f"Reading {event.args.path}"
+        if event.args.offset > 0 or event.args.limit is not None:
+            parts = []
+            if event.args.offset > 0:
+                parts.append(f"from line {event.args.offset}")
+            if event.args.limit is not None:
+                parts.append(f"limit {event.args.limit} lines")
+            summary += f" ({', '.join(parts)})"
+
+        return ToolCallDisplay(summary=summary)
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if not isinstance(event.result, ReadFileResult):
+            return ToolResultDisplay(
+                success=False, message=event.error or event.skip_reason or "No result"
+            )
+
+        path_obj = Path(event.result.path)
+        message = f"Read {event.result.lines_read} line{'' if event.result.lines_read <= 1 else 's'} from {path_obj.name}"
+        if event.result.was_truncated:
+            message += " (truncated)"
+
+        return ToolResultDisplay(
+            success=True,
+            message=message,
+            warnings=["File was truncated due to size limit"]
+            if event.result.was_truncated
+            else [],
+        )
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Reading file"

vibe/core/tools/builtins/search_replace.py

@@ -0,0 +1,456 @@
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+import difflib
+from pathlib import Path
+import re
+import shutil
+from typing import ClassVar, NamedTuple, final
+
+import anyio
+from pydantic import BaseModel, Field
+
+from vibe.core.tools.base import (
+    BaseTool,
+    BaseToolConfig,
+    BaseToolState,
+    InvokeContext,
+    ToolError,
+)
+from vibe.core.tools.ui import ToolCallDisplay, ToolResultDisplay, ToolUIData
+from vibe.core.types import ToolCallEvent, ToolResultEvent, ToolStreamEvent
+
+SEARCH_REPLACE_BLOCK_RE = re.compile(
+    r"<{5,} SEARCH\r?\n(.*?)\r?\n?={5,}\r?\n(.*?)\r?\n?>{5,} REPLACE", flags=re.DOTALL
+)
+
+SEARCH_REPLACE_BLOCK_WITH_FENCE_RE = re.compile(
+    r"```[\s\S]*?\n<{5,} SEARCH\r?\n(.*?)\r?\n?={5,}\r?\n(.*?)\r?\n?>{5,} REPLACE\s*\n```",
+    flags=re.DOTALL,
+)
+
+
+class SearchReplaceBlock(NamedTuple):
+    search: str
+    replace: str
+
+
+class FuzzyMatch(NamedTuple):
+    similarity: float
+    start_line: int
+    end_line: int
+    text: str
+
+
+class BlockApplyResult(NamedTuple):
+    content: str
+    applied: int
+    errors: list[str]
+    warnings: list[str]
+
+
+class SearchReplaceArgs(BaseModel):
+    file_path: str
+    content: str
+
+
+class SearchReplaceResult(BaseModel):
+    file: str
+    blocks_applied: int
+    lines_changed: int
+    content: str
+    warnings: list[str] = Field(default_factory=list)
+
+
+class SearchReplaceConfig(BaseToolConfig):
+    max_content_size: int = 100_000
+    create_backup: bool = False
+    fuzzy_threshold: float = 0.9
+
+
+class SearchReplaceState(BaseToolState):
+    pass
+
+
+class SearchReplace(
+    BaseTool[
+        SearchReplaceArgs, SearchReplaceResult, SearchReplaceConfig, SearchReplaceState
+    ],
+    ToolUIData[SearchReplaceArgs, SearchReplaceResult],
+):
+    description: ClassVar[str] = (
+        "Replace sections of files using SEARCH/REPLACE blocks. "
+        "Supports fuzzy matching and detailed error reporting. "
+        "Format: <<<<<<< SEARCH\\n[text]\\n=======\\n[replacement]\\n>>>>>>> REPLACE"
+    )
+
+    @classmethod
+    def get_call_display(cls, event: ToolCallEvent) -> ToolCallDisplay:
+        if not isinstance(event.args, SearchReplaceArgs):
+            return ToolCallDisplay(summary="Invalid arguments")
+
+        args = event.args
+        blocks = cls._parse_search_replace_blocks(args.content)
+
+        return ToolCallDisplay(
+            summary=f"Patching {args.file_path} ({len(blocks)} blocks)",
+            content=args.content,
+        )
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, SearchReplaceResult):
+            return ToolResultDisplay(
+                success=True,
+                message=f"Applied {event.result.blocks_applied} block{'' if event.result.blocks_applied == 1 else 's'}",
+                warnings=event.result.warnings,
+            )
+
+        return ToolResultDisplay(success=True, message="Patch applied")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Editing files"
+
+    @final
+    async def run(
+        self, args: SearchReplaceArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | SearchReplaceResult, None]:
+        file_path, search_replace_blocks = self._prepare_and_validate_args(args)
+
+        original_content = await self._read_file(file_path)
+
+        block_result = self._apply_blocks(
+            original_content,
+            search_replace_blocks,
+            file_path,
+            self.config.fuzzy_threshold,
+        )
+
+        if block_result.errors:
+            error_message = "SEARCH/REPLACE blocks failed:\n" + "\n\n".join(
+                block_result.errors
+            )
+            if block_result.warnings:
+                error_message += "\n\nWarnings encountered:\n" + "\n".join(
+                    block_result.warnings
+                )
+            raise ToolError(error_message)
+
+        modified_content = block_result.content
+
+        # Calculate line changes
+        if modified_content == original_content:
+            lines_changed = 0
+        else:
+            original_lines = len(original_content.splitlines())
+            new_lines = len(modified_content.splitlines())
+            lines_changed = new_lines - original_lines
+
+            try:
+                if self.config.create_backup:
+                    await self._backup_file(file_path)
+            except Exception:
+                pass
+
+            await self._write_file(file_path, modified_content)
+
+        yield SearchReplaceResult(
+            file=str(file_path),
+            blocks_applied=block_result.applied,
+            lines_changed=lines_changed,
+            warnings=block_result.warnings,
+            content=args.content,
+        )
+
+    @final
+    def _prepare_and_validate_args(
+        self, args: SearchReplaceArgs
+    ) -> tuple[Path, list[SearchReplaceBlock]]:
+        file_path_str = args.file_path.strip()
+        content = args.content.strip()
+
+        if not file_path_str:
+            raise ToolError("File path cannot be empty")
+
+        if len(content) > self.config.max_content_size:
+            raise ToolError(
+                f"Content size ({len(content)} bytes) exceeds max_content_size "
+                f"({self.config.max_content_size} bytes)"
+            )
+
+        if not content:
+            raise ToolError("Empty content provided")
+
+        project_root = Path.cwd()
+        file_path = Path(file_path_str).expanduser()
+        if not file_path.is_absolute():
+            file_path = project_root / file_path
+        file_path = file_path.resolve()
+
+        if not file_path.exists():
+            raise ToolError(f"File does not exist: {file_path}")
+
+        if not file_path.is_file():
+            raise ToolError(f"Path is not a file: {file_path}")
+
+        search_replace_blocks = self._parse_search_replace_blocks(content)
+        if not search_replace_blocks:
+            raise ToolError(
+                "No valid SEARCH/REPLACE blocks found in content.\n"
+                "Expected format:\n"
+                "<<<<<<< SEARCH\n"
+                "[exact content to find]\n"
+                "=======\n"
+                "[new content to replace with]\n"
+                ">>>>>>> REPLACE"
+            )
+
+        return file_path, search_replace_blocks
+
+    async def _read_file(self, file_path: Path) -> str:
+        try:
+            async with await anyio.Path(file_path).open(encoding="utf-8") as f:
+                return await f.read()
+        except UnicodeDecodeError as e:
+            raise ToolError(f"Unicode decode error reading {file_path}: {e}") from e
+        except PermissionError:
+            raise ToolError(f"Permission denied reading file: {file_path}")
+        except Exception as e:
+            raise ToolError(f"Unexpected error reading {file_path}: {e}") from e
+
+    async def _backup_file(self, file_path: Path) -> None:
+        shutil.copy2(file_path, file_path.with_suffix(file_path.suffix + ".bak"))
+
+    async def _write_file(self, file_path: Path, content: str) -> None:
+        try:
+            async with await anyio.Path(file_path).open(
+                mode="w", encoding="utf-8"
+            ) as f:
+                await f.write(content)
+        except PermissionError:
+            raise ToolError(f"Permission denied writing to file: {file_path}")
+        except OSError as e:
+            raise ToolError(f"OS error writing to {file_path}: {e}") from e
+        except Exception as e:
+            raise ToolError(f"Unexpected error writing to {file_path}: {e}") from e
+
+    @final
+    @staticmethod
+    def _apply_blocks(
+        content: str,
+        blocks: list[SearchReplaceBlock],
+        filepath: Path,
+        fuzzy_threshold: float = 0.9,
+    ) -> BlockApplyResult:
+        applied = 0
+        errors: list[str] = []
+        warnings: list[str] = []
+        current_content = content
+
+        for i, (search, replace) in enumerate(blocks, 1):
+            if search not in current_content:
+                context = SearchReplace._find_search_context(current_content, search)
+                fuzzy_context = SearchReplace._find_fuzzy_match_context(
+                    current_content, search, fuzzy_threshold
+                )
+
+                error_msg = (
+                    f"SEARCH/REPLACE block {i} failed: Search text not found in {filepath}\n"
+                    f"Search text was:\n{search!r}\n"
+                    f"Context analysis:\n{context}"
+                )
+
+                if fuzzy_context:
+                    error_msg += f"\n{fuzzy_context}"
+
+                error_msg += (
+                    "\nDebugging tips:\n"
+                    "1. Check for exact whitespace/indentation match\n"
+                    "2. Verify line endings match the file exactly (\\r\\n vs \\n)\n"
+                    "3. Ensure the search text hasn't been modified by previous blocks or user edits\n"
+                    "4. Check for typos or case sensitivity issues"
+                )
+
+                errors.append(error_msg)
+                continue
+
+            occurrences = current_content.count(search)
+            if occurrences > 1:
+                warning_msg = (
+                    f"Search text in block {i} appears {occurrences} times in the file. "
+                    f"Only the first occurrence will be replaced. Consider making your "
+                    f"search pattern more specific to avoid unintended changes."
+                )
+                warnings.append(warning_msg)
+
+            current_content = current_content.replace(search, replace, 1)
+            applied += 1
+
+        return BlockApplyResult(
+            content=current_content, applied=applied, errors=errors, warnings=warnings
+        )
+
+    @final
+    @staticmethod
+    def _find_fuzzy_match_context(
+        content: str, search_text: str, threshold: float = 0.9
+    ) -> str | None:
+        best_match = SearchReplace._find_best_fuzzy_match(
+            content, search_text, threshold
+        )
+
+        if not best_match:
+            return None
+
+        diff = SearchReplace._create_unified_diff(
+            search_text, best_match.text, "SEARCH", "CLOSEST MATCH"
+        )
+
+        similarity_pct = best_match.similarity * 100
+
+        return (
+            f"Closest fuzzy match (similarity {similarity_pct:.1f}%) "
+            f"at lines {best_match.start_line}–{best_match.end_line}:\n"
+            f"```diff\n{diff}\n```"
+        )
+
+    @final
+    @staticmethod
+    def _find_best_fuzzy_match(  # noqa: PLR0914
+        content: str, search_text: str, threshold: float = 0.9
+    ) -> FuzzyMatch | None:
+        content_lines = content.split("\n")
+        search_lines = search_text.split("\n")
+        window_size = len(search_lines)
+
+        if window_size == 0:
+            return None
+
+        non_empty_search = [line for line in search_lines if line.strip()]
+        if not non_empty_search:
+            return None
+
+        first_anchor = non_empty_search[0]
+        last_anchor = (
+            non_empty_search[-1] if len(non_empty_search) > 1 else first_anchor
+        )
+
+        candidate_starts = set()
+        spread = 5
+
+        for i, line in enumerate(content_lines):
+            if first_anchor in line or last_anchor in line:
+                start_min = max(0, i - spread)
+                start_max = min(len(content_lines) - window_size + 1, i + spread + 1)
+                for s in range(start_min, start_max):
+                    candidate_starts.add(s)
+
+        if not candidate_starts:
+            max_positions = min(len(content_lines) - window_size + 1, 100)
+            candidate_starts = set(range(0, max_positions))
+
+        best_match = None
+        best_similarity = 0.0
+
+        for start in candidate_starts:
+            end = start + window_size
+            window_text = "\n".join(content_lines[start:end])
+
+            matcher = difflib.SequenceMatcher(None, search_text, window_text)
+            similarity = matcher.ratio()
+
+            if similarity >= threshold and similarity > best_similarity:
+                best_similarity = similarity
+                best_match = FuzzyMatch(
+                    similarity=similarity,
+                    start_line=start + 1,  # 1-based line numbers
+                    end_line=end,
+                    text=window_text,
+                )
+
+        return best_match
+
+    @final
+    @staticmethod
+    def _create_unified_diff(
+        text1: str, text2: str, label1: str = "SEARCH", label2: str = "CLOSEST MATCH"
+    ) -> str:
+        lines1 = text1.splitlines(keepends=True)
+        lines2 = text2.splitlines(keepends=True)
+
+        lines1 = [line if line.endswith("\n") else line + "\n" for line in lines1]
+        lines2 = [line if line.endswith("\n") else line + "\n" for line in lines2]
+
+        diff = difflib.unified_diff(
+            lines1, lines2, fromfile=label1, tofile=label2, lineterm="", n=3
+        )
+
+        diff_lines = list(diff)
+
+        if diff_lines and not diff_lines[0].startswith("==="):
+            diff_lines.insert(2, "=" * 67 + "\n")
+
+        result = "".join(diff_lines)
+
+        max_chars = 2000
+        if len(result) > max_chars:
+            result = result[:max_chars] + "\n...(diff truncated)"
+
+        return result.rstrip()
+
+    @final
+    @staticmethod
+    def _parse_search_replace_blocks(content: str) -> list[SearchReplaceBlock]:
+        """Parse SEARCH/REPLACE blocks from content.
+
+        Supports two formats:
+        1. With code block fences (```...```)
+        2. Without code block fences
+        """
+        matches = SEARCH_REPLACE_BLOCK_WITH_FENCE_RE.findall(content)
+
+        if not matches:
+            matches = SEARCH_REPLACE_BLOCK_RE.findall(content)
+
+        return [
+            SearchReplaceBlock(
+                search=search.rstrip("\r\n"), replace=replace.rstrip("\r\n")
+            )
+            for search, replace in matches
+        ]
+
+    @final
+    @staticmethod
+    def _find_search_context(
+        content: str, search_text: str, max_context: int = 5
+    ) -> str:
+        lines = content.split("\n")
+        search_lines = search_text.split("\n")
+
+        if not search_lines:
+            return "Search text is empty"
+
+        first_search_line = search_lines[0].strip()
+        if not first_search_line:
+            return "First line of search text is empty or whitespace only"
+
+        matches = []
+        for i, line in enumerate(lines):
+            if first_search_line in line:
+                matches.append(i)
+
+        if not matches:
+            return f"First search line '{first_search_line}' not found anywhere in file"
+
+        context_lines = []
+        for match_idx in matches[:3]:
+            start = max(0, match_idx - max_context)
+            end = min(len(lines), match_idx + max_context + 1)
+
+            context_lines.append(f"\nPotential match area around line {match_idx + 1}:")
+            for i in range(start, end):
+                marker = ">>>" if i == match_idx else "   "
+                context_lines.append(f"{marker} {i + 1:3d}: {lines[i]}")
+
+        return "\n".join(context_lines)