klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/core/tool/file/multi_edit_tool.py

@@ -1,199 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import difflib
-import os
-from pathlib import Path
-
-from pydantic import BaseModel, Field
-
-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
-
-
-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.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 = 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."
-                        ),
-                    )
-        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.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
-
-        # Update tracker
-        if file_tracker is not None:
-            try:
-                file_tracker[file_path] = Path(file_path).stat().st_mtime
-            except Exception:
-                pass
-
-        # 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/memory_tool.md

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

klaude_code/core/tool/memory/memory_tool.py

@@ -1,462 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import difflib
-import os
-import shutil
-import subprocess
-import urllib.parse
-from pathlib import Path
-from typing import Literal
-
-from pydantic import BaseModel, Field
-
-from klaude_code.core.tool.tool_abc import ToolABC, load_desc
-from klaude_code.core.tool.tool_registry import register
-from klaude_code.protocol import llm_param, model, tools
-
-MEMORY_VIRTUAL_ROOT = "/memories"
-MEMORY_DIR_NAME = ".claude/memories"
-
-
-def _get_git_root() -> Path | None:
-    """Get the git repository root directory."""
-    try:
-        result = subprocess.run(
-            ["git", "rev-parse", "--show-toplevel"],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-        if result.returncode == 0:
-            return Path(result.stdout.strip())
-    except Exception:
-        pass
-    return None
-
-
-def _get_memories_root() -> Path:
-    """Get the actual memories directory path."""
-    git_root = _get_git_root()
-    if git_root is not None:
-        return git_root / MEMORY_DIR_NAME
-    return Path.cwd() / MEMORY_DIR_NAME
-
-
-def _ensure_memories_dir() -> Path:
-    """Ensure the memories directory exists and return its path."""
-    memories_root = _get_memories_root()
-    memories_root.mkdir(parents=True, exist_ok=True)
-    return memories_root
-
-
-def _validate_path(virtual_path: str) -> tuple[Path | None, str | None]:
-    """
-    Validate a virtual path and return the actual filesystem path.
-
-    Returns:
-        (actual_path, None) on success
-        (None, error_message) on failure
-    """
-    # Check for URL-encoded traversal attempts
-    decoded = urllib.parse.unquote(virtual_path)
-    if ".." in decoded or ".." in virtual_path:
-        return None, "Path traversal is not allowed"
-
-    # Must start with /memories
-    if not virtual_path.startswith(MEMORY_VIRTUAL_ROOT):
-        return None, f"Path must start with {MEMORY_VIRTUAL_ROOT}"
-
-    # Get relative path from /memories
-    if virtual_path == MEMORY_VIRTUAL_ROOT:
-        relative = ""
-    else:
-        relative = virtual_path[len(MEMORY_VIRTUAL_ROOT) :].lstrip("/")
-
-    memories_root = _get_memories_root()
-    if relative:
-        actual_path = memories_root / relative
-    else:
-        actual_path = memories_root
-
-    # Resolve to canonical path and verify it's still within memories
-    try:
-        resolved = actual_path.resolve()
-        memories_resolved = memories_root.resolve()
-        # Check if resolved path is within or equal to memories root
-        try:
-            resolved.relative_to(memories_resolved)
-        except ValueError:
-            # Also allow the exact memories root
-            if resolved != memories_resolved:
-                return None, "Path traversal is not allowed"
-    except Exception as e:
-        return None, f"Invalid path: {e}"
-
-    return actual_path, None
-
-
-def _format_numbered_line(line_no: int, content: str) -> str:
-    return f"{line_no:>6}|{content}"
-
-
-def _make_diff_ui_extra(before: str, after: str, path: str) -> model.ToolResultUIExtra:
-    diff_lines = list(
-        difflib.unified_diff(
-            before.splitlines(),
-            after.splitlines(),
-            fromfile=path,
-            tofile=path,
-            n=3,
-        )
-    )
-    diff_text = "\n".join(diff_lines)
-    return model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
-
-
-@register(tools.MEMORY)
-class MemoryTool(ToolABC):
-    class MemoryArguments(BaseModel):
-        command: Literal["view", "create", "str_replace", "insert", "delete", "rename"]
-        path: str | None = Field(default=None)
-        # view command
-        view_range: list[int] | None = Field(default=None)
-        # create command
-        file_text: str | None = Field(default=None)
-        # str_replace command
-        old_str: str | None = Field(default=None)
-        new_str: str | None = Field(default=None)
-        # insert command
-        insert_line: int | None = Field(default=None)
-        insert_text: str | None = Field(default=None)
-        # rename command
-        old_path: str | None = Field(default=None)
-        new_path: str | None = Field(default=None)
-
-    @classmethod
-    def schema(cls) -> llm_param.ToolSchema:
-        return llm_param.ToolSchema(
-            name=tools.MEMORY,
-            type="function",
-            description=load_desc(Path(__file__).parent / "memory_tool.md"),
-            parameters={
-                "type": "object",
-                "properties": {
-                    "command": {
-                        "type": "string",
-                        "enum": [
-                            "view",
-                            "create",
-                            "str_replace",
-                            "insert",
-                            "delete",
-                            "rename",
-                        ],
-                        "description": "The memory operation to perform",
-                    },
-                    "path": {
-                        "type": "string",
-                        "description": "Path starting with /memories (for view, create, str_replace, insert, delete)",
-                    },
-                    "view_range": {
-                        "type": "array",
-                        "items": {"type": "integer"},
-                        "description": "Optional [start, end] line range for view command (1-indexed)",
-                    },
-                    "file_text": {
-                        "type": "string",
-                        "description": "Content to write (for create command)",
-                    },
-                    "old_str": {
-                        "type": "string",
-                        "description": "Text to find (for str_replace command)",
-                    },
-                    "new_str": {
-                        "type": "string",
-                        "description": "Text to replace with (for str_replace command)",
-                    },
-                    "insert_line": {
-                        "type": "integer",
-                        "description": "Line number to insert at (for insert command, 1-indexed)",
-                    },
-                    "insert_text": {
-                        "type": "string",
-                        "description": "Text to insert (for insert command)",
-                    },
-                    "old_path": {
-                        "type": "string",
-                        "description": "Source path (for rename command)",
-                    },
-                    "new_path": {
-                        "type": "string",
-                        "description": "Destination path (for rename command)",
-                    },
-                },
-                "required": ["command"],
-                "additionalProperties": False,
-            },
-        )
-
-    @classmethod
-    async def call(cls, arguments: str) -> model.ToolResultItem:
-        try:
-            args = cls.MemoryArguments.model_validate_json(arguments)
-        except Exception as e:
-            return model.ToolResultItem(status="error", output=f"Invalid arguments: {e}")
-
-        command = args.command
-        if command == "view":
-            return await cls._view(args)
-        elif command == "create":
-            return await cls._create(args)
-        elif command == "str_replace":
-            return await cls._str_replace(args)
-        elif command == "insert":
-            return await cls._insert(args)
-        elif command == "delete":
-            return await cls._delete(args)
-        elif command == "rename":
-            return await cls._rename(args)
-        else:
-            return model.ToolResultItem(status="error", output=f"Unknown command: {command}")
-
-    @classmethod
-    async def _view(cls, args: MemoryArguments) -> model.ToolResultItem:
-        if args.path is None:
-            return model.ToolResultItem(status="error", output="path is required for view command")
-
-        actual_path, error = _validate_path(args.path)
-        if error:
-            return model.ToolResultItem(status="error", output=error)
-        assert actual_path is not None
-
-        # Ensure memories directory exists
-        _ensure_memories_dir()
-
-        if not actual_path.exists():
-            return model.ToolResultItem(status="error", output=f"Path does not exist: {args.path}")
-
-        if actual_path.is_dir():
-            # List directory contents
-            try:
-                entries = sorted(
-                    actual_path.iterdir(),
-                    key=lambda p: (not p.is_dir(), p.name.lower()),
-                )
-                lines = [f"Directory: {args.path}"]
-                for entry in entries:
-                    prefix = "/" if entry.is_dir() else ""
-                    lines.append(f"- {entry.name}{prefix}")
-                if len(entries) == 0:
-                    lines.append("(empty directory)")
-                return model.ToolResultItem(status="success", output="\n".join(lines))
-            except Exception as e:
-                return model.ToolResultItem(status="error", output=f"Failed to list directory: {e}")
-        else:
-            # Read file contents
-            try:
-                content = await asyncio.to_thread(actual_path.read_text, encoding="utf-8")
-                lines = content.splitlines()
-                total_lines = len(lines)
-
-                # Apply view_range if specified
-                start = 1
-                end = total_lines
-                if args.view_range and len(args.view_range) >= 2:
-                    start = max(1, args.view_range[0])
-                    end = min(total_lines, args.view_range[1])
-
-                if start > total_lines:
-                    return model.ToolResultItem(
-                        status="success",
-                        output=f"File has {total_lines} lines, requested start line {start} is beyond end of file",
-                    )
-
-                selected = lines[start - 1 : end]
-                numbered = [_format_numbered_line(start + i, line) for i, line in enumerate(selected)]
-                output = "\n".join(numbered)
-                if not output:
-                    output = "(empty file)"
-                return model.ToolResultItem(status="success", output=output)
-            except Exception as e:
-                return model.ToolResultItem(status="error", output=f"Failed to read file: {e}")
-
-    @classmethod
-    async def _create(cls, args: MemoryArguments) -> model.ToolResultItem:
-        if args.path is None:
-            return model.ToolResultItem(status="error", output="path is required for create command")
-        if args.file_text is None:
-            return model.ToolResultItem(status="error", output="file_text is required for create command")
-
-        actual_path, error = _validate_path(args.path)
-        if error:
-            return model.ToolResultItem(status="error", output=error)
-        assert actual_path is not None
-
-        # Cannot create the root directory itself
-        if args.path == MEMORY_VIRTUAL_ROOT or args.path == MEMORY_VIRTUAL_ROOT + "/":
-            return model.ToolResultItem(
-                status="error",
-                output="Cannot create the memories root directory as a file",
-            )
-
-        try:
-            # Read existing content for diff (if file exists)
-            before = ""
-            if actual_path.exists():
-                before = await asyncio.to_thread(actual_path.read_text, encoding="utf-8")
-
-            # Ensure parent directories exist
-            actual_path.parent.mkdir(parents=True, exist_ok=True)
-            await asyncio.to_thread(actual_path.write_text, args.file_text, encoding="utf-8")
-
-            ui_extra = _make_diff_ui_extra(before, args.file_text, args.path)
-            return model.ToolResultItem(status="success", output=f"File created: {args.path}", ui_extra=ui_extra)
-        except Exception as e:
-            return model.ToolResultItem(status="error", output=f"Failed to create file: {e}")
-
-    @classmethod
-    async def _str_replace(cls, args: MemoryArguments) -> model.ToolResultItem:
-        if args.path is None:
-            return model.ToolResultItem(status="error", output="path is required for str_replace command")
-        if args.old_str is None:
-            return model.ToolResultItem(status="error", output="old_str is required for str_replace command")
-        if args.new_str is None:
-            return model.ToolResultItem(status="error", output="new_str is required for str_replace command")
-
-        actual_path, error = _validate_path(args.path)
-        if error:
-            return model.ToolResultItem(status="error", output=error)
-        assert actual_path is not None
-
-        if not actual_path.exists():
-            return model.ToolResultItem(status="error", output=f"File does not exist: {args.path}")
-        if actual_path.is_dir():
-            return model.ToolResultItem(status="error", output="Cannot perform str_replace on a directory")
-
-        try:
-            before = await asyncio.to_thread(actual_path.read_text, encoding="utf-8")
-            if args.old_str not in before:
-                return model.ToolResultItem(status="error", output=f"String not found in file: {args.old_str}")
-
-            after = before.replace(args.old_str, args.new_str, 1)
-            await asyncio.to_thread(actual_path.write_text, after, encoding="utf-8")
-
-            ui_extra = _make_diff_ui_extra(before, after, args.path)
-            return model.ToolResultItem(
-                status="success",
-                output=f"Replaced text in {args.path}",
-                ui_extra=ui_extra,
-            )
-        except Exception as e:
-            return model.ToolResultItem(status="error", output=f"Failed to replace text: {e}")
-
-    @classmethod
-    async def _insert(cls, args: MemoryArguments) -> model.ToolResultItem:
-        if args.path is None:
-            return model.ToolResultItem(status="error", output="path is required for insert command")
-        if args.insert_line is None:
-            return model.ToolResultItem(status="error", output="insert_line is required for insert command")
-        if args.insert_text is None:
-            return model.ToolResultItem(status="error", output="insert_text is required for insert command")
-
-        actual_path, error = _validate_path(args.path)
-        if error:
-            return model.ToolResultItem(status="error", output=error)
-        assert actual_path is not None
-
-        if not actual_path.exists():
-            return model.ToolResultItem(status="error", output=f"File does not exist: {args.path}")
-        if actual_path.is_dir():
-            return model.ToolResultItem(status="error", output="Cannot insert into a directory")
-
-        try:
-            before = await asyncio.to_thread(actual_path.read_text, encoding="utf-8")
-            lines = before.splitlines(keepends=True)
-
-            # Handle empty file
-            if not lines:
-                lines = []
-
-            # Normalize insert_line (1-indexed)
-            insert_idx = max(0, args.insert_line - 1)
-            insert_idx = min(insert_idx, len(lines))
-
-            # Ensure insert_text ends with newline if inserting in middle
-            insert_text = args.insert_text
-            if insert_idx < len(lines) and not insert_text.endswith("\n"):
-                insert_text += "\n"
-
-            lines.insert(insert_idx, insert_text)
-            after = "".join(lines)
-            await asyncio.to_thread(actual_path.write_text, after, encoding="utf-8")
-
-            ui_extra = _make_diff_ui_extra(before, after, args.path)
-            return model.ToolResultItem(
-                status="success",
-                output=f"Inserted text at line {args.insert_line} in {args.path}",
-                ui_extra=ui_extra,
-            )
-        except Exception as e:
-            return model.ToolResultItem(status="error", output=f"Failed to insert text: {e}")
-
-    @classmethod
-    async def _delete(cls, args: MemoryArguments) -> model.ToolResultItem:
-        if args.path is None:
-            return model.ToolResultItem(status="error", output="path is required for delete command")
-
-        # Prevent deleting the root memories directory
-        if args.path == MEMORY_VIRTUAL_ROOT or args.path == MEMORY_VIRTUAL_ROOT + "/":
-            return model.ToolResultItem(status="error", output="Cannot delete the memories root directory")
-
-        actual_path, error = _validate_path(args.path)
-        if error:
-            return model.ToolResultItem(status="error", output=error)
-        assert actual_path is not None
-
-        if not actual_path.exists():
-            return model.ToolResultItem(status="error", output=f"Path does not exist: {args.path}")
-
-        try:
-            if actual_path.is_dir():
-                await asyncio.to_thread(shutil.rmtree, actual_path)
-                return model.ToolResultItem(status="success", output=f"Directory deleted: {args.path}")
-            else:
-                await asyncio.to_thread(os.remove, actual_path)
-                return model.ToolResultItem(status="success", output=f"File deleted: {args.path}")
-        except Exception as e:
-            return model.ToolResultItem(status="error", output=f"Failed to delete: {e}")
-
-    @classmethod
-    async def _rename(cls, args: MemoryArguments) -> model.ToolResultItem:
-        if args.old_path is None:
-            return model.ToolResultItem(status="error", output="old_path is required for rename command")
-        if args.new_path is None:
-            return model.ToolResultItem(status="error", output="new_path is required for rename command")
-
-        # Prevent renaming the root memories directory
-        if args.old_path == MEMORY_VIRTUAL_ROOT or args.old_path == MEMORY_VIRTUAL_ROOT + "/":
-            return model.ToolResultItem(status="error", output="Cannot rename the memories root directory")
-
-        old_actual, error = _validate_path(args.old_path)
-        if error:
-            return model.ToolResultItem(status="error", output=f"Invalid old_path: {error}")
-        assert old_actual is not None
-
-        new_actual, error = _validate_path(args.new_path)
-        if error:
-            return model.ToolResultItem(status="error", output=f"Invalid new_path: {error}")
-        assert new_actual is not None
-
-        if not old_actual.exists():
-            return model.ToolResultItem(status="error", output=f"Source path does not exist: {args.old_path}")
-        if new_actual.exists():
-            return model.ToolResultItem(status="error", output=f"Destination already exists: {args.new_path}")
-
-        try:
-            # Ensure parent directory of destination exists
-            new_actual.parent.mkdir(parents=True, exist_ok=True)
-            await asyncio.to_thread(shutil.move, str(old_actual), str(new_actual))
-            return model.ToolResultItem(status="success", output=f"Renamed {args.old_path} to {args.new_path}")
-        except Exception as e:
-            return model.ToolResultItem(status="error", output=f"Failed to rename: {e}")