klaude-code 1.2.20__py3-none-any.whl → 1.2.22__py3-none-any.whl

klaude_code/core/tool/file/apply_patch_tool.py

@@ -2,13 +2,14 @@
 
 import asyncio
 import contextlib
-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.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
@@ -19,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, diff_ui = 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
@@ -27,11 +28,11 @@ class ApplyPatchHandler:
         return model.ToolResultItem(
             status="success",
             output=output,
-            ui_extra=model.DiffTextUIExtra(diff_text=diff_text),
+            ui_extra=diff_ui,
         )
 
     @staticmethod
-    def _apply_patch_in_thread(patch_text: str) -> tuple[str, str]:
+    def _apply_patch_in_thread(patch_text: str) -> tuple[str, model.DiffUIExtra]:
         ap = apply_patch_module
         normalized_start = patch_text.lstrip()
         if not normalized_start.startswith("*** Begin Patch"):
@@ -66,7 +67,7 @@ class ApplyPatchHandler:
 
         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)
 
         def write_fn(path: str, content: str) -> None:
             resolved = resolve_path(path)
@@ -82,7 +83,11 @@ class ApplyPatchHandler:
                 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, is_memory=is_mem)
+                    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)
@@ -97,74 +102,27 @@ class ApplyPatchHandler:
                     file_tracker.pop(resolved, None)
 
         ap.apply_commit(commit, write_fn, remove_fn)
-        return "Done!", diff_text
+        return "Done!", diff_ui
 
     @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()
+    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:
+                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

@@ -8,7 +8,8 @@ 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._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
@@ -55,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
@@ -74,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 == "":
@@ -112,6 +111,7 @@ class EditTool(ToolABC):
 
         # FileTracker checks (only for editing existing files)
         file_tracker = get_current_file_tracker()
+        tracked_status: model.FileStatus | None = None
         if not file_exists(file_path):
             # We require reading before editing
             return model.ToolResultItem(
@@ -125,17 +125,6 @@ class EditTool(ToolABC):
                     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."
-                    ),
-                )
 
         # Edit existing file: validate and apply
         try:
@@ -146,6 +135,31 @@ class EditTool(ToolABC):
                 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 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."
+                        ),
+                    )
+
         err = cls.valid(
             content=before,
             old_string=args.old_string,
@@ -187,15 +201,18 @@ class EditTool(ToolABC):
                 n=3,
             )
         )
-        diff_text = "\n".join(diff_lines)
-        ui_extra = model.DiffTextUIExtra(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:
             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)
+                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: