klaude-code 1.2.6__py3-none-any.whl

klaude_code/core/tool/file/apply_patch_tool.py

@@ -0,0 +1,204 @@
+"""ApplyPatch tool providing direct patch application capability."""
+
+import asyncio
+import difflib
+import os
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from klaude_code.core.tool.file import apply_patch as apply_patch_module
+from klaude_code.core.tool.tool_abc import ToolABC, load_desc
+from klaude_code.core.tool.tool_context import get_current_file_tracker
+from klaude_code.core.tool.tool_registry import register
+from klaude_code.protocol import llm_param, model, tools
+
+
+class ApplyPatchHandler:
+    @classmethod
+    async def handle_apply_patch(cls, patch_text: str) -> model.ToolResultItem:
+        try:
+            output, diff_text = await asyncio.to_thread(cls._apply_patch_in_thread, patch_text)
+        except apply_patch_module.DiffError as error:
+            return model.ToolResultItem(status="error", output=str(error))
+        except Exception as error:  # pragma: no cover  # unexpected errors bubbled to tool result
+            return model.ToolResultItem(status="error", output=f"Execution error: {error}")
+        return model.ToolResultItem(
+            status="success",
+            output=output,
+            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text),
+        )
+
+    @staticmethod
+    def _apply_patch_in_thread(patch_text: str) -> tuple[str, str]:
+        ap = apply_patch_module
+        normalized_start = patch_text.lstrip()
+        if not normalized_start.startswith("*** Begin Patch"):
+            raise ap.DiffError("apply_patch content must start with *** Begin Patch")
+
+        workspace_root = os.path.realpath(os.getcwd())
+        file_tracker = get_current_file_tracker()
+
+        def resolve_path(path: str) -> str:
+            candidate = os.path.realpath(path if os.path.isabs(path) else os.path.join(workspace_root, path))
+            if not os.path.isabs(path):
+                try:
+                    common = os.path.commonpath([workspace_root, candidate])
+                except ValueError:
+                    raise ap.DiffError(f"Path escapes workspace: {path}") from None
+                if common != workspace_root:
+                    raise ap.DiffError(f"Path escapes workspace: {path}")
+            return candidate
+
+        orig: dict[str, str] = {}
+        for path in ap.identify_files_needed(patch_text):
+            resolved = resolve_path(path)
+            if not os.path.exists(resolved):
+                raise ap.DiffError(f"Missing File: {path}")
+            if os.path.isdir(resolved):
+                raise ap.DiffError(f"Cannot apply patch to directory: {path}")
+            try:
+                with open(resolved, "r", encoding="utf-8") as handle:
+                    orig[path] = handle.read()
+            except OSError as error:
+                raise ap.DiffError(f"Failed to read {path}: {error}") from error
+
+        patch, _ = ap.text_to_patch(patch_text, orig)
+        commit = ap.patch_to_commit(patch, orig)
+        diff_text = ApplyPatchHandler._commit_to_diff(commit)
+
+        def write_fn(path: str, content: str) -> None:
+            resolved = resolve_path(path)
+            if os.path.isdir(resolved):
+                raise ap.DiffError(f"Cannot overwrite directory: {path}")
+            parent = os.path.dirname(resolved)
+            if parent:
+                os.makedirs(parent, exist_ok=True)
+            with open(resolved, "w", encoding="utf-8") as handle:
+                handle.write(content)
+
+            if file_tracker is not None:
+                try:
+                    file_tracker[resolved] = Path(resolved).stat().st_mtime
+                except Exception:  # pragma: no cover - file tracker best-effort
+                    pass
+
+        def remove_fn(path: str) -> None:
+            resolved = resolve_path(path)
+            if not os.path.exists(resolved):
+                raise ap.DiffError(f"Missing File: {path}")
+            if os.path.isdir(resolved):
+                raise ap.DiffError(f"Cannot delete directory: {path}")
+            os.remove(resolved)
+
+            if file_tracker is not None:
+                try:
+                    file_tracker.pop(resolved, None)
+                except Exception:  # pragma: no cover - file tracker best-effort
+                    pass
+
+        ap.apply_commit(commit, write_fn, remove_fn)
+        return "Done!", diff_text
+
+    @staticmethod
+    def _commit_to_diff(commit: apply_patch_module.Commit) -> str:
+        diff_chunks: list[str] = []
+        for path, change in commit.changes.items():
+            chunk = ApplyPatchHandler._render_change_diff(path, change)
+            if chunk:
+                if diff_chunks:
+                    diff_chunks.append("")
+                diff_chunks.extend(chunk)
+        return "\n".join(diff_chunks)
+
+    @staticmethod
+    def _render_change_diff(path: str, change: apply_patch_module.FileChange) -> list[str]:
+        lines: list[str] = []
+        if change.type == apply_patch_module.ActionType.ADD:
+            lines.append(f"diff --git a/{path} b/{path}")
+            lines.append("new file mode 100644")
+            new_lines = ApplyPatchHandler._split_lines(change.new_content)
+            lines.extend(ApplyPatchHandler._unified_diff([], new_lines, fromfile="/dev/null", tofile=f"b/{path}"))
+            return lines
+        if change.type == apply_patch_module.ActionType.DELETE:
+            lines.append(f"diff --git a/{path} b/{path}")
+            lines.append("deleted file mode 100644")
+            old_lines = ApplyPatchHandler._split_lines(change.old_content)
+            lines.extend(ApplyPatchHandler._unified_diff(old_lines, [], fromfile=f"a/{path}", tofile="/dev/null"))
+            return lines
+        if change.type == apply_patch_module.ActionType.UPDATE:
+            new_path = change.move_path or path
+            lines.append(f"diff --git a/{path} b/{new_path}")
+            if change.move_path and change.move_path != path:
+                lines.append(f"rename from {path}")
+                lines.append(f"rename to {new_path}")
+            old_lines = ApplyPatchHandler._split_lines(change.old_content)
+            new_lines = ApplyPatchHandler._split_lines(change.new_content)
+            lines.extend(
+                ApplyPatchHandler._unified_diff(old_lines, new_lines, fromfile=f"a/{path}", tofile=f"b/{new_path}")
+            )
+            return lines
+        return lines
+
+    @staticmethod
+    def _unified_diff(
+        old_lines: list[str],
+        new_lines: list[str],
+        *,
+        fromfile: str,
+        tofile: str,
+    ) -> list[str]:
+        diff_lines = list(
+            difflib.unified_diff(
+                old_lines,
+                new_lines,
+                fromfile=fromfile,
+                tofile=tofile,
+                lineterm="",
+            )
+        )
+        if not diff_lines:
+            diff_lines = [f"--- {fromfile}", f"+++ {tofile}"]
+        return diff_lines
+
+    @staticmethod
+    def _split_lines(text: str | None) -> list[str]:
+        if not text:
+            return []
+        return text.splitlines()
+
+
+@register(tools.APPLY_PATCH)
+class ApplyPatchTool(ToolABC):
+    class ApplyPatchArguments(BaseModel):
+        patch: str
+
+    @classmethod
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.APPLY_PATCH,
+            type="function",
+            description=load_desc(Path(__file__).parent / "apply_patch_tool.md"),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "patch": {
+                        "type": "string",
+                        "description": """Patch content""",
+                    },
+                },
+                "required": ["patch"],
+            },
+        )
+
+    @classmethod
+    async def call(cls, arguments: str) -> model.ToolResultItem:
+        try:
+            args = cls.ApplyPatchArguments.model_validate_json(arguments)
+        except ValueError as exc:
+            return model.ToolResultItem(status="error", output=f"Invalid arguments: {exc}")
+        return await cls.call_with_args(args)
+
+    @classmethod
+    async def call_with_args(cls, args: ApplyPatchArguments) -> model.ToolResultItem:
+        return await ApplyPatchHandler.handle_apply_patch(args.patch)

klaude_code/core/tool/file/edit_tool.md

@@ -0,0 +1,9 @@
+Performs exact string replacements in files.
+
+Usage:
+- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if `old_string` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`. 
+- Use `replace_all` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.

klaude_code/core/tool/file/edit_tool.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import asyncio
+import difflib
+import os
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from klaude_code.core.tool.tool_abc import ToolABC, load_desc
+from klaude_code.core.tool.tool_context import get_current_file_tracker
+from klaude_code.core.tool.tool_registry import register
+from klaude_code.protocol import llm_param, model, tools
+
+
+def _is_directory(path: str) -> bool:
+    try:
+        return Path(path).is_dir()
+    except Exception:
+        return False
+
+
+def _file_exists(path: str) -> bool:
+    try:
+        return Path(path).exists()
+    except Exception:
+        return False
+
+
+def _read_text(path: str) -> str:
+    with open(path, "r", encoding="utf-8", errors="replace") as f:
+        return f.read()
+
+
+def _write_text(path: str, content: str) -> None:
+    parent = Path(path).parent
+    parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(content)
+
+
+@register(tools.EDIT)
+class EditTool(ToolABC):
+    class EditArguments(BaseModel):
+        file_path: str
+        old_string: str
+        new_string: str
+        replace_all: bool = Field(default=False)
+
+    @classmethod
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.EDIT,
+            type="function",
+            description=load_desc(Path(__file__).parent / "edit_tool.md"),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "The absolute path to the file to modify",
+                    },
+                    "old_string": {
+                        "type": "string",
+                        "description": "The text to replace",
+                    },
+                    "new_string": {
+                        "type": "string",
+                        "description": "The text to replace it with (must be different from old_string)",
+                    },
+                    "replace_all": {
+                        "type": "boolean",
+                        "default": False,
+                        "description": "Replace all occurences of old_string (default false)",
+                    },
+                },
+                "required": ["file_path", "old_string", "new_string"],
+                "additionalProperties": False,
+            },
+        )
+
+    # Validation utility for MultiEdit integration
+    @classmethod
+    def valid(
+        cls, *, content: str, old_string: str, new_string: str, replace_all: bool
+    ) -> str | None:  # returns error message or None
+        if old_string == new_string:
+            return (
+                "<tool_use_error>No changes to make: old_string and new_string are exactly the same.</tool_use_error>"
+            )
+        count = content.count(old_string)
+        if count == 0:
+            return f"<tool_use_error>String to replace not found in file.\nString: {old_string}</tool_use_error>"
+        if not replace_all and count > 1:
+            return (
+                f"<tool_use_error>Found {count} matches of the string to replace, but replace_all is false. To replace all occurrences, set replace_all to true. To replace only one occurrence, please provide more context to uniquely identify the instance.\n"
+                f"String: {old_string}</tool_use_error>"
+            )
+        return None
+
+    # Execute utility for MultiEdit integration
+    @classmethod
+    def execute(cls, *, content: str, old_string: str, new_string: str, replace_all: bool) -> str:
+        if old_string == "":
+            # Creating new file content
+            return new_string
+        if replace_all:
+            return content.replace(old_string, new_string)
+        # Replace one occurrence only (we already ensured uniqueness)
+        return content.replace(old_string, new_string, 1)
+
+    @classmethod
+    async def call(cls, arguments: str) -> model.ToolResultItem:
+        try:
+            args = EditTool.EditArguments.model_validate_json(arguments)
+        except Exception as e:  # pragma: no cover - defensive
+            return model.ToolResultItem(status="error", output=f"Invalid arguments: {e}")
+
+        file_path = os.path.abspath(args.file_path)
+
+        # Common file errors
+        if _is_directory(file_path):
+            return model.ToolResultItem(
+                status="error",
+                output="<tool_use_error>Illegal operation on a directory. edit</tool_use_error>",
+            )
+
+        if args.old_string == "":
+            return model.ToolResultItem(
+                status="error",
+                output=(
+                    "<tool_use_error>old_string must not be empty for Edit. "
+                    "To create or overwrite a file, use the Write tool instead.</tool_use_error>"
+                ),
+            )
+
+        # FileTracker checks (only for editing existing files)
+        file_tracker = get_current_file_tracker()
+        if not _file_exists(file_path):
+            # We require reading before editing
+            return model.ToolResultItem(
+                status="error",
+                output=("File has not been read yet. Read it first before writing to it."),
+            )
+        if file_tracker is not None:
+            tracked = file_tracker.get(file_path)
+            if tracked is None:
+                return model.ToolResultItem(
+                    status="error",
+                    output=("File has not been read yet. Read it first before writing to it."),
+                )
+            try:
+                current_mtime = Path(file_path).stat().st_mtime
+            except Exception:
+                current_mtime = tracked
+            if current_mtime != tracked:
+                return model.ToolResultItem(
+                    status="error",
+                    output=(
+                        "File has been modified externally. Either by user or a linter. Read it first before writing to it."
+                    ),
+                )
+
+        # Edit existing file: validate and apply
+        try:
+            before = await asyncio.to_thread(_read_text, file_path)
+        except FileNotFoundError:
+            return model.ToolResultItem(
+                status="error",
+                output="File has not been read yet. Read it first before writing to it.",
+            )
+
+        err = cls.valid(
+            content=before,
+            old_string=args.old_string,
+            new_string=args.new_string,
+            replace_all=args.replace_all,
+        )
+        if err is not None:
+            return model.ToolResultItem(status="error", output=err)
+
+        after = cls.execute(
+            content=before,
+            old_string=args.old_string,
+            new_string=args.new_string,
+            replace_all=args.replace_all,
+        )
+
+        # If nothing changed due to replacement semantics (should not happen after valid), guard anyway
+        if before == after:
+            return model.ToolResultItem(
+                status="error",
+                output=(
+                    "<tool_use_error>No changes to make: old_string and new_string are exactly the same.</tool_use_error>"
+                ),
+            )
+
+        # Write back
+        try:
+            await asyncio.to_thread(_write_text, file_path, after)
+        except Exception as e:  # pragma: no cover
+            return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
+
+        # Prepare UI extra: unified diff with 3 context lines
+        diff_lines = list(
+            difflib.unified_diff(
+                before.splitlines(),
+                after.splitlines(),
+                fromfile=file_path,
+                tofile=file_path,
+                n=3,
+            )
+        )
+        diff_text = "\n".join(diff_lines)
+        ui_extra = model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+
+        # Update tracker with new mtime
+        if file_tracker is not None:
+            try:
+                file_tracker[file_path] = Path(file_path).stat().st_mtime
+            except Exception:
+                pass
+
+        # Build output message
+        if args.replace_all:
+            msg = f"The file {file_path} has been updated. All occurrences of '{args.old_string}' were successfully replaced with '{args.new_string}'."
+            return model.ToolResultItem(status="success", output=msg, ui_extra=ui_extra)
+
+        # For single replacement, show a snippet consisting of context + added lines only
+        # Parse the diff to collect target line numbers in the 'after' file
+        include_after_line_nos: list[int] = []
+        after_line_no = 0
+        for line in diff_lines:
+            if line.startswith("@@"):
+                # Parse header: @@ -l,s +l,s @@
+                # Extract the +l,s part
+                try:
+                    header = line
+                    plus = header.split("+", 1)[1]
+                    plus_range = plus.split(" ")[0]
+                    if "," in plus_range:
+                        start = int(plus_range.split(",")[0])
+                    else:
+                        start = int(plus_range)
+                    after_line_no = start - 1
+                except Exception:
+                    after_line_no = 0
+                continue
+            if line.startswith(" "):
+                after_line_no += 1
+                include_after_line_nos.append(after_line_no)
+            elif line.startswith("+") and not line.startswith("+++ "):
+                after_line_no += 1
+                include_after_line_nos.append(after_line_no)
+            elif line.startswith("-") and not line.startswith("--- "):
+                # Removed line does not advance after_line_no
+                continue
+            else:
+                # file header lines etc.
+                continue
+
+        # Build numbered snippet from the new content
+        snippet_lines: list[str] = []
+        after_lines = after.splitlines()
+        for no in include_after_line_nos:
+            if 1 <= no <= len(after_lines):
+                snippet_lines.append(f"{no:>6}→{after_lines[no - 1]}")
+
+        snippet = "\n".join(snippet_lines)
+        output = (
+            f"The file {file_path} has been updated. Here's the result of running `cat -n` on a snippet of the edited file:\n"
+            f"{snippet}"
+        )
+        return model.ToolResultItem(status="success", output=output, ui_extra=ui_extra)

klaude_code/core/tool/file/multi_edit_tool.md

@@ -0,0 +1,42 @@
+This is a tool for making multiple edits to a single file in one operation. It is built on top of the Edit tool and allows you to perform multiple find-and-replace operations efficiently. Prefer this tool over the Edit tool when you need to make multiple edits to the same file.
+
+Before using this tool:
+
+1. Use the Read tool to understand the file's contents and context
+2. Verify the directory path is correct
+
+To make multiple file edits, provide the following:
+1. file_path: The absolute path to the file to modify (must be absolute, not relative)
+2. edits: An array of edit operations to perform, where each edit contains:
+   - old_string: The text to replace (must match the file contents exactly, including all whitespace and indentation)
+   - new_string: The edited text to replace the old_string
+   - replace_all: Replace all occurences of old_string. This parameter is optional and defaults to false.
+
+IMPORTANT:
+- All edits are applied in sequence, in the order they are provided
+- Each edit operates on the result of the previous edit
+- All edits must be valid for the operation to succeed - if any edit fails, none will be applied
+- This tool is ideal when you need to make several changes to different parts of the same file
+- For Jupyter notebooks (.ipynb files), use the NotebookEdit instead
+
+CRITICAL REQUIREMENTS:
+1. All edits follow the same requirements as the single Edit tool
+2. The edits are atomic - either all succeed or none are applied
+3. Plan your edits carefully to avoid conflicts between sequential operations
+
+WARNING:
+- The tool will fail if edits.old_string doesn't match the file contents exactly (including whitespace)
+- The tool will fail if edits.old_string and edits.new_string are the same
+- Since edits are applied in sequence, ensure that earlier edits don't affect the text that later edits are trying to find
+
+When making edits:
+- Ensure all edits result in idiomatic, correct code
+- Do not leave the code in a broken state
+- Always use absolute file paths (starting with /)
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- Use replace_all for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.
+
+If you want to create a new file, use:
+- A new file path, including dir name if needed
+- First edit: empty old_string and the new file's contents as new_string
+- Subsequent edits: normal edit operations on the created content