crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_core/tools/diff_utils.py

@@ -0,0 +1,123 @@
+"""Diff utilities for file edit/write tools."""
+
+from __future__ import annotations
+
+import difflib
+
+
+def compute_diff(
+    old: str,
+    new: str,
+    filepath: str = "",
+    context_lines: int = 3,
+) -> dict:
+    """Compute a structured diff between old and new file content.
+
+    Returns a dict with:
+      line_range  - (start, end) 1-indexed line range of first change
+      diff_text   - unified diff string (compact, for model)
+      display     - formatted diff string (for terminal display)
+      stats       - {"added": N, "removed": N}
+    """
+    # ``unified_diff`` supplies separators through ``lineterm``. Passing
+    # keepends=True and then joining the result inserted blank lines between
+    # every diff row in terminal and desktop renderers.
+    old_lines = old.splitlines(keepends=False)
+    new_lines = new.splitlines(keepends=False)
+
+    diff_lines = list(difflib.unified_diff(
+        old_lines,
+        new_lines,
+        fromfile=filepath,
+        tofile=filepath,
+        lineterm="",
+        n=context_lines,
+    ))
+
+    if not diff_lines:
+        return {
+            "line_range": None,
+            "diff_text": "",
+            "display": "",
+            "stats": {"added": 0, "removed": 0},
+        }
+
+    added = sum(1 for l in diff_lines if l.startswith("+") and not l.startswith("+++"))
+    removed = sum(1 for l in diff_lines if l.startswith("-") and not l.startswith("---"))
+
+    first_change_line = _find_first_change_line(old_lines, new_lines)
+    last_change_line = _find_last_change_line(old_lines, new_lines)
+
+    diff_text = "\n".join(diff_lines)
+
+    max_diff_chars = 10_000
+    if len(diff_text) > max_diff_chars:
+        diff_text = diff_text[:max_diff_chars] + "\n... (diff truncated)"
+
+    return {
+        "line_range": (first_change_line, last_change_line),
+        "diff_text": diff_text,
+        "display": diff_text,
+        "stats": {"added": added, "removed": removed},
+    }
+
+
+def _find_first_change_line(old: list[str], new: list[str]) -> int:
+    """Find the 1-indexed line number of the first difference."""
+    for i, (a, b) in enumerate(zip(old, new)):
+        if a != b:
+            return i + 1
+    return min(len(old), len(new)) + 1
+
+
+def _find_last_change_line(old: list[str], new: list[str]) -> int:
+    """Find the 1-indexed line number (in new file) of the last difference."""
+    old_rev = list(reversed(old))
+    new_rev = list(reversed(new))
+    tail_common = 0
+    for a, b in zip(old_rev, new_rev):
+        if a != b:
+            break
+        tail_common += 1
+    return max(1, len(new) - tail_common)
+
+
+def format_edit_summary(
+    filepath: str,
+    diff_info: dict,
+    replacements: int = 1,
+) -> tuple[str, str]:
+    """Format diff info into (result_for_model, result_for_display).
+
+    Returns a pair of strings optimized for model consumption and
+    terminal display respectively.
+    """
+    lr = diff_info["line_range"]
+    stats = diff_info["stats"]
+
+    if lr:
+        line_desc = f"lines {lr[0]}-{lr[1]}" if lr[0] != lr[1] else f"line {lr[0]}"
+    else:
+        line_desc = ""
+
+    stat_parts = []
+    if stats["added"]:
+        stat_parts.append(f"+{stats['added']}")
+    if stats["removed"]:
+        stat_parts.append(f"-{stats['removed']}")
+    stat_str = ", ".join(stat_parts)
+
+    model_msg = f"Updated {filepath}"
+    if line_desc:
+        model_msg += f" ({line_desc})"
+    if stat_str:
+        model_msg += f" [{stat_str}]"
+    if replacements > 1:
+        model_msg += f" ({replacements} replacements)"
+
+    display_parts = [model_msg]
+    if diff_info["display"]:
+        display_parts.append(diff_info["display"])
+    display_msg = "\n".join(display_parts)
+
+    return model_msg, display_msg

crabcode_core/tools/file_edit.py

@@ -0,0 +1,240 @@
+"""FileEditTool — string replacement editing."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.logging_utils import get_logger
+from crabcode_core.text_io import normalize_newlines, read_utf8_text, write_utf8_text
+from crabcode_core.tools.diff_utils import compute_diff, format_edit_summary
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+from crabcode_core.io_worker import run_file_tool
+
+logger = get_logger(__name__)
+
+
+async def _get_lsp_diagnostics(
+    file_path: str | Path,
+    context: ToolContext,
+) -> str:
+    """Collect LSP diagnostics for the edited file, return formatted string."""
+    lsp = context.lsp_manager
+    if lsp is None:
+        return ""
+    from crabcode_core.lsp.diagnostics import collect_and_format_diagnostics
+    return await collect_and_format_diagnostics(lsp, str(file_path))
+
+
+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:
+        missing = [
+            key
+            for key in ("file_path", "old_string", "new_string")
+            if key not in tool_input
+        ]
+        if missing:
+            return f"missing required field(s): {', '.join(missing)}"
+
+        old_string = tool_input.get("old_string")
+        new_string = tool_input.get("new_string")
+        if not isinstance(old_string, str) or not isinstance(new_string, str):
+            return "old_string and new_string must be strings"
+        if old_string == "":
+            return "old_string must not be empty"
+        if old_string == 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:
+        result = await run_file_tool(self.name, tool_input, context)
+        if not result.is_error and result.data:
+            result.result_for_model += await _get_lsp_diagnostics(result.data["file_path"], context)
+        return result
+
+    async def _call_local(
+        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:
+            source = read_utf8_text(path)
+            content = source.text
+        except Exception as e:
+            return ToolResult(
+                result_for_model=f"Error reading file: {e}",
+                is_error=True,
+            )
+
+        normalized_old = normalize_newlines(old_string, "\n")
+        pattern = re.compile(
+            r"(?:\r\n|\r|\n)".join(
+                re.escape(part) for part in normalized_old.split("\n")
+            )
+        )
+        matches = list(pattern.finditer(content))
+        count = len(matches)
+
+        if count == 0:
+            # Give the model a head start: show the first 120 chars of the
+            # old_string it provided so it can spot whitespace/encoding drift,
+            # and remind it to re-read before retrying.
+            snippet = repr(old_string[:120]) + ("..." if len(old_string) > 120 else "")
+            return ToolResult(
+                result_for_model=(
+                    f"Error: old_string not found in {path}.\n"
+                    f"The string you provided (first 120 chars): {snippet}\n"
+                    "Common causes: wrong indentation (tabs vs spaces), "
+                    "stale content (file was already modified), or "
+                    "the string was never in this file.\n"
+                    "Fix: use the Read tool to re-read the file and verify "
+                    "the exact content before retrying the Edit."
+                ),
+                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,
+            )
+
+        def render_replacement(match: re.Match[str]) -> str:
+            matched = match.group(0)
+            replacement_newline = source.newline
+            if "\r\n" in matched:
+                replacement_newline = "\r\n"
+            elif "\n" in matched:
+                replacement_newline = "\n"
+            elif "\r" in matched:
+                replacement_newline = "\r"
+            return (
+                normalize_newlines(new_string, replacement_newline)
+                if replacement_newline is not None
+                else new_string
+            )
+
+        if replace_all:
+            new_content = pattern.sub(render_replacement, content)
+        else:
+            match = matches[0]
+            new_content = (
+                content[:match.start()]
+                + render_replacement(match)
+                + content[match.end():]
+            )
+
+        # Track snapshot before writing
+        if context.session_id:
+            try:
+                from crabcode_core.snapshot.tracker import track_snapshot_for_file
+                track_snapshot_for_file(
+                    cwd=context.cwd,
+                    session_id=context.session_id,
+                    file_path=str(path),
+                    old_content=content,
+                    action="modify",
+                )
+            except Exception:
+                logger.debug("Failed to track snapshot for edit", exc_info=True)
+
+        try:
+            write_utf8_text(path, new_content, has_bom=source.has_bom)
+        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
+        )
+        lsp_msg = await _get_lsp_diagnostics(path, context)
+
+        return ToolResult(
+            data={
+                "file_path": str(path),
+                "replacements": replaced,
+                "line_range": diff_info["line_range"],
+                "stats": diff_info["stats"],
+            },
+            result_for_model=model_msg + lsp_msg,
+            result_for_display=display_msg,
+        )

crabcode_core/tools/file_read.py

@@ -0,0 +1,187 @@
+"""FileReadTool — read file contents."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.logging_utils import get_logger
+from crabcode_core.text_io import read_utf8_text
+from crabcode_core.tools._input_helpers import first_non_empty_str
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+from crabcode_core.io_worker import run_file_tool
+
+logger = get_logger(__name__)
+
+
+class FileReadTool(Tool):
+    name = "Read"
+    description = "Read a text file or view a local image, including a saved PSD composite preview."
+    is_read_only = True
+    is_concurrency_safe = True
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_path": {
+                "type": "string",
+                "minLength": 1,
+                "description": "The absolute or relative path of the file to read.",
+            },
+            "offset": {
+                "type": "integer",
+                "description": "Text only: line number to start reading from (1-based). Negative values count from end. Ignored for images.",
+            },
+            "limit": {
+                "type": "integer",
+                "description": "Text only: number of lines to read. Ignored for images.",
+            },
+        },
+        "required": ["file_path"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Read text or visually inspect an image from the local filesystem. "
+            "For images, the actual image content is returned to you for visual analysis, "
+            "not just a filename or a UI preview. Supports PNG, JPEG, WebP, GIF, BMP, TIFF "
+            "and saved PSD composite previews. Non-native formats are converted to PNG; "
+            "large images may be resized. Animated/multipage images return the first frame/page. "
+            "PSD previews show the saved merged appearance, not editable layers. "
+            "offset and limit apply only to text and are ignored for images.\n\n"
+            "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:
+        result = await run_file_tool(self.name, tool_input, context)
+        if (not result.is_error and result.data and not result.images
+                and context.lsp_manager is not None):
+            asyncio.create_task(_lsp_touch(result.data["file_path"], context.lsp_manager))
+        return result
+
+    async def _call_local(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        file_path = first_non_empty_str(
+            tool_input,
+            ("file_path", "filePath", "path", "target_file", "filepath", "file"),
+        )
+        offset = tool_input.get("offset")
+        limit = tool_input.get("limit")
+
+        if not file_path:
+            return ToolResult(
+                result_for_model=(
+                    "Error: file_path is required. Pass the file path as \"file_path\" "
+                    "(aliases: filePath, path, target_file, filepath, file)."
+                ),
+                is_error=True,
+            )
+
+        path = Path(file_path).expanduser()
+        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:
+            from crabcode_core.image_io import is_image_file, load_image_preview
+
+            if is_image_file(path):
+                preview = load_image_preview(path)
+                context.emit_image(preview.data, preview.media_type)
+                message = f"Image read: {path} ({preview.summary()})"
+                if offset is not None or limit is not None:
+                    message += "\nText offset/limit ignored for this image."
+                return ToolResult(
+                    data={"file_path": str(path), "media_type": preview.media_type,
+                          "width": preview.width, "height": preview.height,
+                          "source_format": preview.source_format},
+                    result_for_model=message,
+                    result_for_display=message,
+                    images=[context.emitted_images[-1]],
+                )
+            content = read_utf8_text(path).text
+        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)
+
+        # Background LSP touch — notifies language servers about this file
+        # so diagnostics are ready when the user writes later. Non-blocking.
+        lsp = context.lsp_manager
+        if lsp is not None:
+            try:
+                asyncio.get_event_loop().create_task(
+                    _lsp_touch(str(path), lsp),
+                )
+            except Exception:
+                pass
+
+        return ToolResult(
+            data={"file_path": str(path), "content": content, "total_lines": total_lines},
+            result_for_model=result_text,
+        )
+
+
+async def _lsp_touch(file_path: str, lsp: Any) -> None:
+    """Fire-and-forget LSP touch_file call."""
+    try:
+        await lsp.touch_file(file_path)
+    except Exception:
+        logger.debug("LSP touch_file failed for %s", file_path, exc_info=True)