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

klaude_code/core/tool/file/apply_patch_tool.py

@@ -1,13 +1,15 @@
 """ApplyPatch tool providing direct patch application capability."""
 
 import asyncio
-import difflib
+import contextlib
 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.file._utils import hash_text_sha256
+from klaude_code.core.tool.file.diff_builder import build_structured_file_diff
 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
@@ -18,7 +20,7 @@ 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)
+            output, ui_extra = 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
@@ -26,11 +28,11 @@ class ApplyPatchHandler:
         return model.ToolResultItem(
             status="success",
             output=output,
-            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text),
+            ui_extra=ui_extra,
         )
 
     @staticmethod
-    def _apply_patch_in_thread(patch_text: str) -> tuple[str, str]:
+    def _apply_patch_in_thread(patch_text: str) -> tuple[str, model.ToolResultUIExtra]:
         ap = apply_patch_module
         normalized_start = patch_text.lstrip()
         if not normalized_start.startswith("*** Begin Patch"):
@@ -58,14 +60,24 @@ class ApplyPatchHandler:
             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:
+                with open(resolved, 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)
+        diff_ui = ApplyPatchHandler._commit_to_structured_diff(commit)
+
+        md_items: list[model.MarkdownDocUIExtra] = []
+        for change_path, change in commit.changes.items():
+            if change.type == apply_patch_module.ActionType.ADD and change_path.endswith(".md"):
+                md_items.append(
+                    model.MarkdownDocUIExtra(
+                        file_path=resolve_path(change_path),
+                        content=change.new_content or "",
+                    )
+                )
 
         def write_fn(path: str, content: str) -> None:
             resolved = resolve_path(path)
@@ -78,10 +90,14 @@ class ApplyPatchHandler:
                 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
+                with contextlib.suppress(Exception):  # pragma: no cover - file tracker best-effort
+                    existing = file_tracker.get(resolved)
+                    is_mem = existing.is_memory if existing else False
+                    file_tracker[resolved] = model.FileStatus(
+                        mtime=Path(resolved).stat().st_mtime,
+                        content_sha256=hash_text_sha256(content),
+                        is_memory=is_mem,
+                    )
 
         def remove_fn(path: str) -> None:
             resolved = resolve_path(path)
@@ -92,80 +108,44 @@ class ApplyPatchHandler:
             os.remove(resolved)
 
             if file_tracker is not None:
-                try:
+                with contextlib.suppress(Exception):  # pragma: no cover - file tracker best-effort
                     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)
+        # apply_patch can include multiple operations. If we added markdown files,
+        # return a MultiUIExtra so UI can render markdown previews (without showing a diff for those markdown adds).
+        if md_items:
+            items: list[model.MultiUIExtraItem] = []
+            items.extend(md_items)
+            if diff_ui.files:
+                items.append(diff_ui)
+            return "Done!", model.MultiUIExtra(items=items)
 
-    @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
+        return "Done!", diff_ui
 
     @staticmethod
-    def _split_lines(text: str | None) -> list[str]:
-        if not text:
-            return []
-        return text.splitlines()
+    def _commit_to_structured_diff(commit: apply_patch_module.Commit) -> model.DiffUIExtra:
+        files: list[model.DiffFileDiff] = []
+        for path in sorted(commit.changes):
+            change = commit.changes[path]
+            if change.type == apply_patch_module.ActionType.ADD:
+                # For markdown files created via Add File, we render content via MarkdownDocUIExtra instead of a diff.
+                if path.endswith(".md"):
+                    continue
+                files.append(build_structured_file_diff("", change.new_content or "", file_path=path))
+            elif change.type == apply_patch_module.ActionType.DELETE:
+                files.append(build_structured_file_diff(change.old_content or "", "", file_path=path))
+            elif change.type == apply_patch_module.ActionType.UPDATE:
+                display_path = path
+                if change.move_path and change.move_path != path:
+                    display_path = f"{path} → {change.move_path}"
+                files.append(
+                    build_structured_file_diff(
+                        change.old_content or "", change.new_content or "", file_path=display_path
+                    )
+                )
+        return model.DiffUIExtra(files=files)
 
 
 @register(tools.APPLY_PATCH)

klaude_code/core/tool/file/diff_builder.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import difflib
+from typing import cast
+
+from diff_match_patch import diff_match_patch  # type: ignore[import-untyped]
+
+from klaude_code.protocol import model
+
+_MAX_LINE_LENGTH_FOR_CHAR_DIFF = 2000
+_DEFAULT_CONTEXT_LINES = 3
+
+
+def build_structured_diff(before: str, after: str, *, file_path: str) -> model.DiffUIExtra:
+    """Build a structured diff with char-level spans for a single file."""
+    file_diff = _build_file_diff(before, after, file_path=file_path)
+    return model.DiffUIExtra(files=[file_diff])
+
+
+def build_structured_file_diff(before: str, after: str, *, file_path: str) -> model.DiffFileDiff:
+    """Build a structured diff for a single file."""
+    return _build_file_diff(before, after, file_path=file_path)
+
+
+def _build_file_diff(before: str, after: str, *, file_path: str) -> model.DiffFileDiff:
+    before_lines = _split_lines(before)
+    after_lines = _split_lines(after)
+
+    matcher = difflib.SequenceMatcher(None, before_lines, after_lines)
+    lines: list[model.DiffLine] = []
+    stats_add = 0
+    stats_remove = 0
+
+    grouped_opcodes = matcher.get_grouped_opcodes(n=_DEFAULT_CONTEXT_LINES)
+    for group_idx, group in enumerate(grouped_opcodes):
+        if group_idx > 0:
+            lines.append(_gap_line())
+
+        # Anchor line numbers to the actual start of the displayed hunk in the "after" file.
+        new_line_no = group[0][3] + 1
+
+        for tag, i1, i2, j1, j2 in group:
+            if tag == "equal":
+                for line in after_lines[j1:j2]:
+                    lines.append(_ctx_line(line, new_line_no))
+                    new_line_no += 1
+            elif tag == "delete":
+                for line in before_lines[i1:i2]:
+                    lines.append(_remove_line([model.DiffSpan(op="equal", text=line)]))
+                    stats_remove += 1
+            elif tag == "insert":
+                for line in after_lines[j1:j2]:
+                    lines.append(_add_line([model.DiffSpan(op="equal", text=line)], new_line_no))
+                    stats_add += 1
+                    new_line_no += 1
+            elif tag == "replace":
+                old_block = before_lines[i1:i2]
+                new_block = after_lines[j1:j2]
+                max_len = max(len(old_block), len(new_block))
+                for idx in range(max_len):
+                    old_line = old_block[idx] if idx < len(old_block) else None
+                    new_line = new_block[idx] if idx < len(new_block) else None
+                    if old_line is not None and new_line is not None:
+                        remove_spans, add_spans = _diff_line_spans(old_line, new_line)
+                        lines.append(_remove_line(remove_spans))
+                        lines.append(_add_line(add_spans, new_line_no))
+                        stats_remove += 1
+                        stats_add += 1
+                        new_line_no += 1
+                    elif old_line is not None:
+                        lines.append(_remove_line([model.DiffSpan(op="equal", text=old_line)]))
+                        stats_remove += 1
+                    elif new_line is not None:
+                        lines.append(_add_line([model.DiffSpan(op="equal", text=new_line)], new_line_no))
+                        stats_add += 1
+                        new_line_no += 1
+
+    return model.DiffFileDiff(
+        file_path=file_path,
+        lines=lines,
+        stats_add=stats_add,
+        stats_remove=stats_remove,
+    )
+
+
+def _split_lines(text: str) -> list[str]:
+    if not text:
+        return []
+    return text.splitlines()
+
+
+def _ctx_line(text: str, new_line_no: int) -> model.DiffLine:
+    return model.DiffLine(
+        kind="ctx",
+        new_line_no=new_line_no,
+        spans=[model.DiffSpan(op="equal", text=text)],
+    )
+
+
+def _gap_line() -> model.DiffLine:
+    return model.DiffLine(
+        kind="gap",
+        new_line_no=None,
+        spans=[model.DiffSpan(op="equal", text="")],
+    )
+
+
+def _add_line(spans: list[model.DiffSpan], new_line_no: int) -> model.DiffLine:
+    return model.DiffLine(kind="add", new_line_no=new_line_no, spans=_ensure_spans(spans))
+
+
+def _remove_line(spans: list[model.DiffSpan]) -> model.DiffLine:
+    return model.DiffLine(kind="remove", new_line_no=None, spans=_ensure_spans(spans))
+
+
+def _ensure_spans(spans: list[model.DiffSpan]) -> list[model.DiffSpan]:
+    if spans:
+        return spans
+    return [model.DiffSpan(op="equal", text="")]
+
+
+def _diff_line_spans(old_line: str, new_line: str) -> tuple[list[model.DiffSpan], list[model.DiffSpan]]:
+    if not _should_char_diff(old_line, new_line):
+        return (
+            [model.DiffSpan(op="equal", text=old_line)],
+            [model.DiffSpan(op="equal", text=new_line)],
+        )
+
+    differ = diff_match_patch()
+    diffs = cast(list[tuple[int, str]], differ.diff_main(old_line, new_line))  # type: ignore[no-untyped-call]
+    differ.diff_cleanupSemantic(diffs)  # type: ignore[no-untyped-call]
+
+    remove_spans: list[model.DiffSpan] = []
+    add_spans: list[model.DiffSpan] = []
+
+    for op, text in diffs:
+        if not text:
+            continue
+        if op == diff_match_patch.DIFF_EQUAL:  # type: ignore[no-untyped-call]
+            remove_spans.append(model.DiffSpan(op="equal", text=text))
+            add_spans.append(model.DiffSpan(op="equal", text=text))
+        elif op == diff_match_patch.DIFF_DELETE:  # type: ignore[no-untyped-call]
+            remove_spans.append(model.DiffSpan(op="delete", text=text))
+        elif op == diff_match_patch.DIFF_INSERT:  # type: ignore[no-untyped-call]
+            add_spans.append(model.DiffSpan(op="insert", text=text))
+
+    return _ensure_spans(remove_spans), _ensure_spans(add_spans)
+
+
+def _should_char_diff(old_line: str, new_line: str) -> bool:
+    return len(old_line) <= _MAX_LINE_LENGTH_FOR_CHAR_DIFF and len(new_line) <= _MAX_LINE_LENGTH_FOR_CHAR_DIFF

klaude_code/core/tool/file/edit_tool.py

@@ -1,44 +1,21 @@
 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, hash_text_sha256, is_directory, read_text, write_text
+from klaude_code.core.tool.file.diff_builder import build_structured_diff
 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):
@@ -79,7 +56,6 @@ class EditTool(ToolABC):
             },
         )
 
-    # Validation utility for MultiEdit integration
     @classmethod
     def valid(
         cls, *, content: str, old_string: str, new_string: str, replace_all: bool
@@ -98,7 +74,6 @@ class EditTool(ToolABC):
             )
         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 == "":
@@ -113,13 +88,13 @@ class EditTool(ToolABC):
     async def call(cls, arguments: str) -> model.ToolResultItem:
         try:
             args = EditTool.EditArguments.model_validate_json(arguments)
-        except Exception as e:  # pragma: no cover - defensive
+        except ValueError 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):
+        if is_directory(file_path):
             return model.ToolResultItem(
                 status="error",
                 output="<tool_use_error>Illegal operation on a directory. edit</tool_use_error>",
@@ -136,40 +111,55 @@ class EditTool(ToolABC):
 
         # FileTracker checks (only for editing existing files)
         file_tracker = get_current_file_tracker()
-        if not _file_exists(file_path):
+        tracked_status: model.FileStatus | None = None
+        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:
+            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
-            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)
+            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.",
             )
 
+        # Re-check external modifications using content hash when available.
+        if tracked_status is not None:
+            if tracked_status.content_sha256 is not None:
+                current_sha256 = hash_text_sha256(before)
+                if current_sha256 != tracked_status.content_sha256:
+                    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:
+                # Backward-compat: old sessions only stored mtime.
+                try:
+                    current_mtime = Path(file_path).stat().st_mtime
+                except OSError:
+                    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."
+                        ),
+                    )
+
         err = cls.valid(
             content=before,
             old_string=args.old_string,
@@ -197,8 +187,8 @@ class EditTool(ToolABC):
 
         # Write back
         try:
-            await asyncio.to_thread(_write_text, file_path, after)
-        except Exception as e:  # pragma: no cover
+            await asyncio.to_thread(write_text, file_path, after)
+        except (OSError, UnicodeError) 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
@@ -211,15 +201,18 @@ class EditTool(ToolABC):
                 n=3,
             )
         )
-        diff_text = "\n".join(diff_lines)
-        ui_extra = model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+        ui_extra = build_structured_diff(before, after, file_path=file_path)
 
-        # Update tracker with new mtime
+        # Update tracker with new mtime and content hash
         if file_tracker is not None:
-            try:
-                file_tracker[file_path] = Path(file_path).stat().st_mtime
-            except Exception:
-                pass
+            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,
+                    content_sha256=hash_text_sha256(after),
+                    is_memory=is_mem,
+                )
 
         # Build output message
         if args.replace_all:
@@ -238,18 +231,12 @@ class EditTool(ToolABC):
                     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)
+                    start = int(plus_range.split(",")[0]) if "," in plus_range else int(plus_range)
                     after_line_no = start - 1
-                except Exception:
+                except (ValueError, IndexError):
                     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("+++ "):
+            if line.startswith(" ") or (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("--- "):

klaude_code/core/tool/file/move_tool.md

@@ -0,0 +1,41 @@
+Moves a range of lines from one file to another.
+
+Usage:
+- Cuts lines from `start_line` to `end_line` (inclusive, 1-indexed) from the source file
+- Pastes them into the target file at `insert_line` (inserted before that line)
+- Both files must have been read first using the Read tool
+- To create a new target file, set `insert_line` to 1 and ensure target file does not exist
+- For same-file moves, line numbers refer to the original file state before any changes
+- Use this tool when refactoring code into separate modules to avoid passing large code blocks twice
+- To move files or directories, use the Bash tool with `mv` command instead
+
+Return format:
+The tool returns context snippets showing the state after the operation:
+
+1. Source file context (after cut): Shows 3 lines before and after the cut location
+2. Target file context (after insert): Shows 3 lines before the inserted content, the inserted content itself, and 3 lines after
+
+Example output:
+```
+Cut 8 lines from /path/source.py (lines 9-16) and pasted into /path/target.py (updated) at line 10.
+
+Source file context (after cut):
+     6	    return value
+     7	
+     8	
+  -------- cut here --------
+     9	class NextClass:
+    10	    pass
+    11	
+
+Target file context (after insert):
+     7	    return {}
+     8	
+     9	
+  -------- inserted --------
+    10	class MovedClass:
+    ...
+    17	        return result
+  -------- end --------
+    18	# Next section
+```