crabcode 0.1.0__py3-none-any.whl

crabcode_core/tools/file_edit.py

@@ -0,0 +1,145 @@
+"""FileEditTool — string replacement editing."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.tools.diff_utils import compute_diff, format_edit_summary
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+
+class FileEditTool(Tool):
+    name = "Edit"
+    description = "Edit a file by replacing a specific string."
+    is_read_only = False
+    is_concurrency_safe = False
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_path": {
+                "type": "string",
+                "description": "The path of the file to edit.",
+            },
+            "old_string": {
+                "type": "string",
+                "description": "The exact string to find and replace.",
+            },
+            "new_string": {
+                "type": "string",
+                "description": "The replacement string.",
+            },
+            "replace_all": {
+                "type": "boolean",
+                "description": "Replace all occurrences (default: false).",
+            },
+        },
+        "required": ["file_path", "old_string", "new_string"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Edit a file by performing exact string replacements. "
+            "The old_string must uniquely identify the text to replace — "
+            "if it matches multiple locations, the edit will FAIL. Include "
+            "surrounding context lines to make the match unique. Preserves "
+            "exact indentation (tabs/spaces) as it appears in the file. "
+            "Use replace_all=true to replace all occurrences (useful for "
+            "renaming a variable across the file).\n\n"
+            "IMPORTANT: You MUST read the file before editing it. Never "
+            "guess the file content.\n\n"
+            "GOOD example — unique match with context:\n"
+            '  old_string: "def calculate(a, b):\\n    return a + b"\n'
+            '  new_string: "def calculate(a, b):\\n    return a * b"\n\n'
+            "BAD example — too short, likely matches multiple locations:\n"
+            '  old_string: "return"\n'
+            '  new_string: "return None"'
+        )
+
+    async def validate_input(self, tool_input: dict[str, Any]) -> str | None:
+        if tool_input.get("old_string") == tool_input.get("new_string"):
+            return "old_string and new_string must be different"
+        return None
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        file_path = tool_input.get("file_path", "")
+        old_string = tool_input.get("old_string", "")
+        new_string = tool_input.get("new_string", "")
+        replace_all = tool_input.get("replace_all", False)
+
+        if not file_path:
+            return ToolResult(
+                result_for_model="Error: file_path is required",
+                is_error=True,
+            )
+
+        path = Path(file_path)
+        if not path.is_absolute():
+            path = Path(context.cwd) / path
+
+        if not path.exists():
+            return ToolResult(
+                result_for_model=f"Error: file not found: {path}",
+                is_error=True,
+            )
+
+        try:
+            content = path.read_text(errors="replace")
+        except Exception as e:
+            return ToolResult(
+                result_for_model=f"Error reading file: {e}",
+                is_error=True,
+            )
+
+        count = content.count(old_string)
+
+        if count == 0:
+            return ToolResult(
+                result_for_model=f"Error: old_string not found in {path}",
+                is_error=True,
+            )
+
+        if count > 1 and not replace_all:
+            return ToolResult(
+                result_for_model=(
+                    f"Error: old_string found {count} times in {path}. "
+                    "Use replace_all=true to replace all occurrences, "
+                    "or provide more context to make the match unique."
+                ),
+                is_error=True,
+            )
+
+        if replace_all:
+            new_content = content.replace(old_string, new_string)
+        else:
+            new_content = content.replace(old_string, new_string, 1)
+
+        try:
+            path.write_text(new_content)
+        except Exception as e:
+            return ToolResult(
+                result_for_model=f"Error writing file: {e}",
+                is_error=True,
+            )
+
+        replaced = count if replace_all else 1
+
+        diff_info = compute_diff(content, new_content, str(path))
+        model_msg, display_msg = format_edit_summary(
+            str(path), diff_info, replacements=replaced
+        )
+
+        return ToolResult(
+            data={
+                "file_path": str(path),
+                "replacements": replaced,
+                "line_range": diff_info["line_range"],
+                "stats": diff_info["stats"],
+            },
+            result_for_model=model_msg,
+            result_for_display=display_msg,
+        )

crabcode_core/tools/file_read.py

@@ -0,0 +1,123 @@
+"""FileReadTool — read file contents."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+
+class FileReadTool(Tool):
+    name = "Read"
+    description = "Read the contents of a file."
+    is_read_only = True
+    is_concurrency_safe = True
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_path": {
+                "type": "string",
+                "description": "The absolute or relative path of the file to read.",
+            },
+            "offset": {
+                "type": "integer",
+                "description": "Line number to start reading from (1-based). Negative values count from end.",
+            },
+            "limit": {
+                "type": "integer",
+                "description": "Number of lines to read.",
+            },
+        },
+        "required": ["file_path"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Read the contents of a file from the local filesystem. "
+            "You can optionally specify a line offset and limit (especially "
+            "useful for large files), but it's recommended to read the whole "
+            "file by not providing these parameters.\n\n"
+            "Lines in the output are numbered starting at 1, in the format "
+            "LINE_NUMBER|LINE_CONTENT. The LINE_NUMBER prefix is metadata — "
+            "do NOT treat it as part of the actual code.\n\n"
+            "IMPORTANT: You MUST read a file at least once before editing it. "
+            "You can call Read on multiple files in a single response to read "
+            "them in parallel.\n\n"
+            "If the file exists but is empty, you will receive 'File is empty.'.\n"
+            "If the file does not exist, you will receive an error."
+        )
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        file_path = tool_input.get("file_path", "")
+        offset = tool_input.get("offset")
+        limit = tool_input.get("limit")
+
+        if not file_path:
+            return ToolResult(
+                result_for_model="Error: file_path is required",
+                is_error=True,
+            )
+
+        path = Path(file_path)
+        if not path.is_absolute():
+            path = Path(context.cwd) / path
+
+        if not path.exists():
+            return ToolResult(
+                result_for_model=f"Error: file not found: {path}",
+                is_error=True,
+            )
+
+        if not path.is_file():
+            return ToolResult(
+                result_for_model=f"Error: not a file: {path}",
+                is_error=True,
+            )
+
+        try:
+            content = path.read_text(errors="replace")
+        except Exception as e:
+            return ToolResult(
+                result_for_model=f"Error reading file: {e}",
+                is_error=True,
+            )
+
+        if not content:
+            return ToolResult(
+                result_for_model="File is empty.",
+                data={"file_path": str(path), "content": ""},
+            )
+
+        lines = content.splitlines(keepends=True)
+        total_lines = len(lines)
+
+        if offset is not None:
+            if offset < 0:
+                start = max(0, total_lines + offset)
+            else:
+                start = max(0, offset - 1)
+        else:
+            start = 0
+
+        if limit is not None:
+            end = min(total_lines, start + limit)
+        else:
+            end = total_lines
+
+        selected = lines[start:end]
+
+        numbered = []
+        for i, line in enumerate(selected, start=start + 1):
+            numbered.append(f"{i:6d}|{line.rstrip()}")
+
+        result_text = "\n".join(numbered)
+
+        return ToolResult(
+            data={"file_path": str(path), "content": content, "total_lines": total_lines},
+            result_for_model=result_text,
+        )

crabcode_core/tools/file_write.py

@@ -0,0 +1,102 @@
+"""FileWriteTool — create or overwrite files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.tools.diff_utils import compute_diff, format_edit_summary
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+
+class FileWriteTool(Tool):
+    name = "Write"
+    description = "Write content to a file, creating it if necessary."
+    is_read_only = False
+    is_concurrency_safe = False
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_path": {
+                "type": "string",
+                "description": "The path of the file to write.",
+            },
+            "content": {
+                "type": "string",
+                "description": "The content to write to the file.",
+            },
+        },
+        "required": ["file_path", "content"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Write content to a file. Creates the file and parent directories "
+            "if they don't exist. WARNING: This will overwrite the existing "
+            "file if there is one.\n\n"
+            "ALWAYS prefer editing existing files with the Edit tool instead "
+            "of rewriting them. Only use Write for:\n"
+            "- Creating new files that don't exist yet\n"
+            "- Cases where the entire file content needs to be replaced\n\n"
+            "NEVER create files unless absolutely necessary for achieving "
+            "your goal. This prevents file bloat and builds on existing "
+            "work more effectively.\n"
+            "NEVER proactively create documentation or README files unless "
+            "the user explicitly requests them."
+        )
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        file_path = tool_input.get("file_path", "")
+        content = tool_input.get("content", "")
+
+        if not file_path:
+            return ToolResult(
+                result_for_model="Error: file_path is required",
+                is_error=True,
+            )
+
+        path = Path(file_path)
+        if not path.is_absolute():
+            path = Path(context.cwd) / path
+
+        is_new = not path.exists()
+        old_content = ""
+        if not is_new:
+            try:
+                old_content = path.read_text(errors="replace")
+            except Exception:
+                pass
+
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content)
+        except Exception as e:
+            return ToolResult(
+                result_for_model=f"Error writing file: {e}",
+                is_error=True,
+            )
+
+        if is_new:
+            line_count = content.count("\n") + (1 if content and not content.endswith("\n") else 0)
+            return ToolResult(
+                data={"file_path": str(path), "created": True, "lines": line_count},
+                result_for_model=f"Created {path} ({line_count} lines).",
+            )
+
+        diff_info = compute_diff(old_content, content, str(path))
+        model_msg, display_msg = format_edit_summary(str(path), diff_info)
+
+        return ToolResult(
+            data={
+                "file_path": str(path),
+                "created": False,
+                "line_range": diff_info["line_range"],
+                "stats": diff_info["stats"],
+            },
+            result_for_model=model_msg,
+            result_for_display=display_msg,
+        )

crabcode_core/tools/glob.py

@@ -0,0 +1,109 @@
+"""GlobTool — find files by pattern."""
+
+from __future__ import annotations
+
+import asyncio
+import fnmatch
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+
+class GlobTool(Tool):
+    name = "Glob"
+    description = "Find files matching a glob pattern."
+    is_read_only = True
+    is_concurrency_safe = True
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "pattern": {
+                "type": "string",
+                "description": "Glob pattern to match (e.g., '**/*.py', 'src/**/*.ts').",
+            },
+            "path": {
+                "type": "string",
+                "description": "Directory to search in (default: cwd).",
+            },
+        },
+        "required": ["pattern"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Find files matching a glob pattern. Returns matching file paths "
+            "sorted by modification time (most recent first). Works fast "
+            "with codebases of any size.\n\n"
+            "Patterns not starting with '**/' are automatically prepended "
+            "with it for recursive searching. Use this instead of find or "
+            "ls via Bash.\n\n"
+            "Examples:\n"
+            '- "*.py" (becomes "**/*.py") — find all Python files\n'
+            '- "src/**/*.ts" — find all TypeScript files under src/\n'
+            '- "**/test_*.py" — find all test files'
+        )
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        pattern = tool_input.get("pattern", "")
+        search_path = tool_input.get("path", context.cwd)
+
+        if not pattern:
+            return ToolResult(
+                result_for_model="Error: pattern is required",
+                is_error=True,
+            )
+
+        if not pattern.startswith("**/") and not pattern.startswith("/"):
+            pattern = f"**/{pattern}"
+
+        root = Path(search_path)
+        if not root.is_absolute():
+            root = Path(context.cwd) / root
+
+        if not root.exists():
+            return ToolResult(
+                result_for_model=f"Error: directory not found: {root}",
+                is_error=True,
+            )
+
+        try:
+            matches: list[tuple[float, str]] = []
+            for path in root.glob(pattern):
+                if path.is_file():
+                    try:
+                        mtime = path.stat().st_mtime
+                    except OSError:
+                        mtime = 0
+                    matches.append((mtime, str(path)))
+
+                if len(matches) > 1000:
+                    break
+
+            matches.sort(key=lambda x: x[0], reverse=True)
+            file_paths = [p for _, p in matches]
+
+        except Exception as e:
+            return ToolResult(
+                result_for_model=f"Error during glob: {e}",
+                is_error=True,
+            )
+
+        if not file_paths:
+            return ToolResult(
+                result_for_model="No files matched the pattern.",
+                data={"count": 0},
+            )
+
+        result_text = "\n".join(file_paths)
+        count = len(file_paths)
+        suffix = " (showing first 1000)" if count >= 1000 else ""
+
+        return ToolResult(
+            data={"count": count, "files": file_paths},
+            result_for_model=f"Found {count} files{suffix}:\n{result_text}",
+        )

crabcode_core/tools/grep.py

@@ -0,0 +1,130 @@
+"""GrepTool — search file contents using ripgrep."""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+from typing import Any
+
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+
+class GrepTool(Tool):
+    name = "Grep"
+    description = "Search file contents using regex patterns."
+    is_read_only = True
+    is_concurrency_safe = True
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "pattern": {
+                "type": "string",
+                "description": "The regex pattern to search for.",
+            },
+            "path": {
+                "type": "string",
+                "description": "Directory or file to search in (default: cwd).",
+            },
+            "glob": {
+                "type": "string",
+                "description": "File glob pattern to filter (e.g., '*.py').",
+            },
+            "case_insensitive": {
+                "type": "boolean",
+                "description": "Case insensitive search.",
+            },
+        },
+        "required": ["pattern"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Search file contents for a regex pattern using ripgrep. "
+            "Returns matching lines with file paths and line numbers. "
+            "Use this instead of running grep or rg via Bash.\n\n"
+            "Supports full regex syntax (e.g., 'log.*Error', "
+            "'function\\s+\\w+'). Filter files with the glob parameter "
+            "(e.g., '*.py', '*.tsx').\n\n"
+            "Results are capped at 200 matches for responsiveness. "
+            "If you need more specific results, narrow your search "
+            "with a more specific pattern or glob filter."
+        )
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        pattern = tool_input.get("pattern", "")
+        search_path = tool_input.get("path", context.cwd)
+        glob_pattern = tool_input.get("glob")
+        case_insensitive = tool_input.get("case_insensitive", False)
+
+        if not pattern:
+            return ToolResult(
+                result_for_model="Error: pattern is required",
+                is_error=True,
+            )
+
+        rg = shutil.which("rg")
+        if not rg:
+            rg = "rg"
+
+        args = [rg, "--line-number", "--no-heading", "--color=never"]
+
+        if case_insensitive:
+            args.append("-i")
+        if glob_pattern:
+            args.extend(["--glob", glob_pattern])
+
+        args.extend(["--max-count", "200"])
+        args.append(pattern)
+        args.append("--")
+        args.append(search_path)
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *args,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=context.cwd,
+            )
+            stdout_bytes, stderr_bytes = await asyncio.wait_for(
+                proc.communicate(), timeout=30
+            )
+        except asyncio.TimeoutError:
+            return ToolResult(
+                result_for_model="Search timed out after 30s",
+                is_error=True,
+            )
+        except FileNotFoundError:
+            return ToolResult(
+                result_for_model="Error: ripgrep (rg) not found. Please install it.",
+                is_error=True,
+            )
+
+        stdout = stdout_bytes.decode("utf-8", errors="replace")
+        stderr = stderr_bytes.decode("utf-8", errors="replace")
+
+        if proc.returncode == 1:
+            return ToolResult(
+                result_for_model="No matches found.",
+                data={"matches": 0},
+            )
+
+        if proc.returncode and proc.returncode > 1:
+            return ToolResult(
+                result_for_model=f"Grep error: {stderr or 'unknown error'}",
+                is_error=True,
+            )
+
+        lines = stdout.strip().split("\n") if stdout.strip() else []
+
+        max_output = 50_000
+        if len(stdout) > max_output:
+            stdout = stdout[:max_output] + "\n... (truncated)"
+
+        return ToolResult(
+            data={"match_count": len(lines)},
+            result_for_model=stdout or "No matches found.",
+        )