klaude-code 1.2.21__py3-none-any.whl → 1.2.23__py3-none-any.whl

klaude_code/core/tool/file/multi_edit_tool.md

@@ -1,42 +0,0 @@
-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

klaude_code/core/tool/file/multi_edit_tool.py

@@ -1,175 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import difflib
-import os
-from pathlib import Path
-
-from pydantic import BaseModel, Field
-
-from klaude_code.core.tool.file._utils import file_exists, is_directory, read_text, write_text
-from klaude_code.core.tool.file.edit_tool import EditTool
-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
-
-
-@register(tools.MULTI_EDIT)
-class MultiEditTool(ToolABC):
-    class MultiEditEditItem(BaseModel):
-        old_string: str
-        new_string: str
-        replace_all: bool = Field(default=False)
-
-    class MultiEditArguments(BaseModel):
-        file_path: str
-        edits: list[MultiEditTool.MultiEditEditItem]
-
-    @classmethod
-    def schema(cls) -> llm_param.ToolSchema:
-        return llm_param.ToolSchema(
-            name=tools.MULTI_EDIT,
-            type="function",
-            description=load_desc(Path(__file__).parent / "multi_edit_tool.md"),
-            parameters={
-                "type": "object",
-                "properties": {
-                    "file_path": {
-                        "type": "string",
-                        "description": "The absolute path to the file to modify",
-                    },
-                    "edits": {
-                        "type": "array",
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "old_string": {
-                                    "type": "string",
-                                    "description": "The text to replace",
-                                },
-                                "new_string": {
-                                    "type": "string",
-                                    "description": "The text to replace it with",
-                                },
-                                "replace_all": {
-                                    "type": "boolean",
-                                    "default": False,
-                                    "description": "Replace all occurences of old_string (default false).",
-                                },
-                            },
-                            "required": ["old_string", "new_string"],
-                            "additionalProperties": False,
-                        },
-                        "minItems": 1,
-                        "description": "Array of edit operations to perform sequentially on the file",
-                    },
-                },
-                "required": ["file_path", "edits"],
-                "additionalProperties": False,
-            },
-        )
-
-    @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
-        try:
-            args = MultiEditTool.MultiEditArguments.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)
-
-        # Directory error first
-        if is_directory(file_path):
-            return model.ToolResultItem(
-                status="error",
-                output="<tool_use_error>Illegal operation on a directory. multi_edit</tool_use_error>",
-            )
-
-        file_tracker = get_current_file_tracker()
-
-        # FileTracker check:
-        if file_exists(file_path):
-            if file_tracker is not None:
-                tracked_status = file_tracker.get(file_path)
-                if tracked_status 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_status.mtime
-                if current_mtime != tracked_status.mtime:
-                    return model.ToolResultItem(
-                        status="error",
-                        output=(
-                            "File has been modified externally. Either by user or a linter. Read it first before writing to it."
-                        ),
-                    )
-        else:
-            # Allow creation only if first edit is creating content (old_string == "")
-            if not args.edits or args.edits[0].old_string != "":
-                return model.ToolResultItem(
-                    status="error",
-                    output=("File has not been read yet. Read it first before writing to it."),
-                )
-
-        # Load initial content (empty for new file case)
-        if file_exists(file_path):
-            before = await asyncio.to_thread(read_text, file_path)
-        else:
-            before = ""
-
-        # Validate all edits atomically against staged content
-        staged = before
-        for edit in args.edits:
-            err = EditTool.valid(
-                content=staged,
-                old_string=edit.old_string,
-                new_string=edit.new_string,
-                replace_all=edit.replace_all,
-            )
-            if err is not None:
-                return model.ToolResultItem(status="error", output=err)
-            # Apply to staged content
-            staged = EditTool.execute(
-                content=staged,
-                old_string=edit.old_string,
-                new_string=edit.new_string,
-                replace_all=edit.replace_all,
-            )
-
-        # All edits valid; write to disk
-        try:
-            await asyncio.to_thread(write_text, file_path, staged)
-        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
-        diff_lines = list(
-            difflib.unified_diff(
-                before.splitlines(),
-                staged.splitlines(),
-                fromfile=file_path,
-                tofile=file_path,
-                n=3,
-            )
-        )
-        diff_text = "\n".join(diff_lines)
-        ui_extra = model.DiffTextUIExtra(diff_text=diff_text)
-
-        # Update tracker
-        if file_tracker is not None:
-            with contextlib.suppress(Exception):
-                existing = file_tracker.get(file_path)
-                is_mem = existing.is_memory if existing else False
-                file_tracker[file_path] = model.FileStatus(mtime=Path(file_path).stat().st_mtime, is_memory=is_mem)
-
-        # Build output message
-        lines = [f"Applied {len(args.edits)} edits to {file_path}:"]
-        for i, edit in enumerate(args.edits, start=1):
-            lines.append(f'{i}. Replaced "{edit.old_string}" with "{edit.new_string}"')
-        return model.ToolResultItem(status="success", output="\n".join(lines), ui_extra=ui_extra)

klaude_code/core/tool/memory/__init__.py

@@ -1,5 +0,0 @@
-from .skill_loader import SkillLoader
-from .skill_tool import SkillTool
-
-skill_loader = SkillLoader()
-SkillTool.set_skill_loader(skill_loader)

klaude_code/core/tool/memory/memory_tool.md

@@ -1,20 +0,0 @@
-Stores and retrieves information across conversations through a memory file directory. Use this tool to persist knowledge, progress, and context that should survive between sessions.
-
-The memory directory is located at `.claude/memories/` in the current project root (git repository root if present, otherwise the current working directory). Memories are scoped to the current project/directory and are not shared globally. All paths must start with `/memories` (e.g., `/memories/notes.txt`).
-
-Commands:
-- `view`: Show directory contents or file contents with optional line range
-- `create`: Create or overwrite a file
-- `str_replace`: Replace text in a file
-- `insert`: Insert text at a specific line
-- `delete`: Delete a file or directory
-- `rename`: Rename or move a file/directory
-
-Usage tips:
-- Check your memory directory before starting tasks to recall previous context
-- Record important decisions, progress, and learnings as you work
-- Keep memory files organized and up-to-date; delete obsolete files
-
-Note: when editing your memory folder, always try to keep its content up-to-date, coherent and organized. You can rename or delete files that are no longer relevant. Do not create new files unless necessary.
-
-Only write down information relevant to current project in your memory system.