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

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:

klaude_code/core/tool/file/read_tool.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+import hashlib
 import os
 from base64 import b64encode
 from dataclasses import dataclass
@@ -37,6 +38,7 @@ class ReadOptions:
     limit: int | None
     char_limit_per_line: int | None = const.READ_CHAR_LIMIT_PER_LINE
     global_line_cap: int | None = const.READ_GLOBAL_LINE_CAP
+    max_total_chars: int | None = const.READ_MAX_CHARS
 
 
 @dataclass
@@ -45,29 +47,32 @@ class ReadSegmentResult:
     selected_lines: list[tuple[int, str]]
     selected_chars_count: int
     remaining_selected_beyond_cap: int
-    # For large file diagnostics: list of (start_line, end_line, char_count)
-    segment_char_stats: list[tuple[int, int, int]]
+    remaining_due_to_char_limit: int
+    content_sha256: str
 
 
 def _read_segment(options: ReadOptions) -> ReadSegmentResult:
     total_lines = 0
     selected_lines_count = 0
     remaining_selected_beyond_cap = 0
+    remaining_due_to_char_limit = 0
     selected_lines: list[tuple[int, str]] = []
     selected_chars = 0
-
-    # Track char counts per 100-line segment for diagnostics
-    segment_size = 100
-    segment_char_stats: list[tuple[int, int, int]] = []
-    current_segment_start = options.offset
-    current_segment_chars = 0
+    char_limit_reached = False
+    hasher = hashlib.sha256()
 
     with open(options.file_path, encoding="utf-8", errors="replace") as f:
         for line_no, raw_line in enumerate(f, start=1):
             total_lines = line_no
+            hasher.update(raw_line.encode("utf-8"))
             within = line_no >= options.offset and (options.limit is None or selected_lines_count < options.limit)
             if not within:
                 continue
+
+            if char_limit_reached:
+                remaining_due_to_char_limit += 1
+                continue
+
             selected_lines_count += 1
             content = raw_line.rstrip("\n")
             original_len = len(content)
@@ -79,42 +84,39 @@ def _read_segment(options: ReadOptions) -> ReadSegmentResult:
                 )
             line_chars = len(content) + 1
             selected_chars += line_chars
-            current_segment_chars += line_chars
 
-            # Check if we've completed a segment
-            if selected_lines_count % segment_size == 0:
-                segment_char_stats.append((current_segment_start, line_no, current_segment_chars))
-                current_segment_start = line_no + 1
-                current_segment_chars = 0
+            if options.max_total_chars is not None and selected_chars > options.max_total_chars:
+                char_limit_reached = True
+                selected_lines.append((line_no, content))
+                continue
 
             if options.global_line_cap is None or len(selected_lines) < options.global_line_cap:
                 selected_lines.append((line_no, content))
             else:
                 remaining_selected_beyond_cap += 1
 
-    # Add the last partial segment if any
-    if current_segment_chars > 0 and selected_lines_count > 0:
-        last_line = options.offset + selected_lines_count - 1
-        segment_char_stats.append((current_segment_start, last_line, current_segment_chars))
-
     return ReadSegmentResult(
         total_lines=total_lines,
         selected_lines=selected_lines,
         selected_chars_count=selected_chars,
         remaining_selected_beyond_cap=remaining_selected_beyond_cap,
-        segment_char_stats=segment_char_stats,
+        remaining_due_to_char_limit=remaining_due_to_char_limit,
+        content_sha256=hasher.hexdigest(),
     )
 
 
-def _track_file_access(file_path: str, *, is_memory: bool = False) -> None:
+def _track_file_access(file_path: str, *, content_sha256: str | None = None, is_memory: bool = False) -> None:
     file_tracker = get_current_file_tracker()
     if file_tracker is None or not file_exists(file_path) or is_directory(file_path):
         return
     with contextlib.suppress(Exception):
         existing = file_tracker.get(file_path)
-        # Preserve is_memory flag if already set
         is_mem = is_memory or (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=content_sha256,
+            is_memory=is_mem,
+        )
 
 
 def _is_supported_image_file(file_path: str) -> bool:
@@ -129,12 +131,6 @@ def _image_mime_type(file_path: str) -> str:
     return mime_type
 
 
-def _encode_image_to_data_url(file_path: str, mime_type: str) -> str:
-    with open(file_path, "rb") as image_file:
-        encoded = b64encode(image_file.read()).decode("ascii")
-    return f"data:{mime_type};base64,{encoded}"
-
-
 @register(tools.READ)
 class ReadTool(ToolABC):
     class ReadArguments(BaseModel):
@@ -178,24 +174,18 @@ class ReadTool(ToolABC):
         return await cls.call_with_args(args)
 
     @classmethod
-    def _effective_limits(cls) -> tuple[int | None, int | None, int | None, int | None]:
-        """Return effective limits based on current policy: char_per_line, global_line_cap, max_chars, max_kb"""
+    def _effective_limits(cls) -> tuple[int | None, int | None, int | None]:
         return (
             const.READ_CHAR_LIMIT_PER_LINE,
             const.READ_GLOBAL_LINE_CAP,
             const.READ_MAX_CHARS,
-            const.READ_MAX_KB,
         )
 
     @classmethod
     async def call_with_args(cls, args: ReadTool.ReadArguments) -> model.ToolResultItem:
-        # Accept relative path by resolving to absolute (schema encourages absolute)
         file_path = os.path.abspath(args.file_path)
+        char_per_line, line_cap, max_chars = cls._effective_limits()
 
-        # Get effective limits based on policy
-        char_per_line, line_cap, max_chars, max_kb = cls._effective_limits()
-
-        # Common file errors
         if is_directory(file_path):
             return model.ToolResultItem(
                 status="error",
@@ -228,11 +218,9 @@ class ReadTool(ToolABC):
                 ),
             )
 
-        # If file is too large and no pagination provided (only check if limits are enabled)
         try:
             size_bytes = Path(file_path).stat().st_size
         except OSError:
-            # Best-effort size detection; on stat errors fall back to treating size as unknown.
             size_bytes = 0
 
         is_image_file = _is_supported_image_file(file_path)
@@ -247,42 +235,26 @@ class ReadTool(ToolABC):
                 )
             try:
                 mime_type = _image_mime_type(file_path)
-                data_url = _encode_image_to_data_url(file_path, mime_type)
+                with open(file_path, "rb") as image_file:
+                    image_bytes = image_file.read()
+                data_url = f"data:{mime_type};base64,{b64encode(image_bytes).decode('ascii')}"
             except Exception as exc:
                 return model.ToolResultItem(
                     status="error",
                     output=f"<tool_use_error>Failed to read image file: {exc}</tool_use_error>",
                 )
 
-            _track_file_access(file_path)
+            _track_file_access(file_path, content_sha256=hashlib.sha256(image_bytes).hexdigest())
             size_kb = size_bytes / 1024.0 if size_bytes else 0.0
             output_text = f"[image] {Path(file_path).name} ({size_kb:.1f}KB)"
             image_part = model.ImageURLPart(image_url=model.ImageURLPart.ImageURL(url=data_url, id=None))
             return model.ToolResultItem(status="success", output=output_text, images=[image_part])
 
-        if (
-            not is_image_file
-            and max_kb is not None
-            and args.offset is None
-            and args.limit is None
-            and size_bytes > max_kb * 1024
-        ):
-            size_kb = size_bytes / 1024.0
-            return model.ToolResultItem(
-                status="error",
-                output=(
-                    f"File content ({size_kb:.1f}KB) exceeds maximum allowed size ({max_kb}KB). Please use offset and limit parameters to read specific portions of the file, or use the `rg` command to search for specific content."
-                ),
-            )
-
         offset = 1 if args.offset is None or args.offset < 1 else int(args.offset)
         limit = None if args.limit is None else int(args.limit)
         if limit is not None and limit < 0:
             limit = 0
 
-        # Stream file line-by-line and build response
-        read_result: ReadSegmentResult | None = None
-
         try:
             read_result = await asyncio.to_thread(
                 _read_segment,
@@ -292,6 +264,7 @@ class ReadTool(ToolABC):
                     limit=limit,
                     char_limit_per_line=char_per_line,
                     global_line_cap=line_cap,
+                    max_total_chars=max_chars,
                 ),
             )
 
@@ -306,40 +279,26 @@ class ReadTool(ToolABC):
                 output="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
             )
 
-        # If offset beyond total lines, emit system reminder warning
         if offset > max(read_result.total_lines, 0):
             warn = f"<system-reminder>Warning: the file exists but is shorter than the provided offset ({offset}). The file has {read_result.total_lines} lines.</system-reminder>"
-            # Update FileTracker (we still consider it as a read attempt)
-            _track_file_access(file_path)
+            _track_file_access(file_path, content_sha256=read_result.content_sha256)
             return model.ToolResultItem(status="success", output=warn)
 
-        # After limit/offset, if total selected chars exceed limit, error (only check if limits are enabled)
-        if max_chars is not None and read_result.selected_chars_count > max_chars:
-            # Build segment statistics for better guidance
-            stats_lines: list[str] = []
-            for start, end, chars in read_result.segment_char_stats:
-                stats_lines.append(f"  Lines {start}-{end}: {chars} chars")
-            segment_stats_str = "\n".join(stats_lines) if stats_lines else "  (no segment data)"
+        lines_out: list[str] = [_format_numbered_line(no, content) for no, content in read_result.selected_lines]
 
-            return model.ToolResultItem(
-                status="error",
-                output=(
-                    f"Selected file content {read_result.selected_chars_count} chars exceeds maximum allowed chars ({max_chars}).\n"
-                    f"File has {read_result.total_lines} total lines.\n\n"
-                    f"Character distribution by segment:\n{segment_stats_str}\n\n"
-                    f"Use offset and limit parameters to read specific portions. "
-                    f"For example: offset=1, limit=100 to read the first 100 lines. "
-                    f"Or use `rg` command to search for specific content."
-                ),
+        # Show truncation info with reason
+        if read_result.remaining_due_to_char_limit > 0:
+            lines_out.append(
+                f"... ({read_result.remaining_due_to_char_limit} more lines truncated due to {max_chars} char limit, "
+                f"file has {read_result.total_lines} lines total, use offset/limit to read other parts)"
+            )
+        elif read_result.remaining_selected_beyond_cap > 0:
+            lines_out.append(
+                f"... ({read_result.remaining_selected_beyond_cap} more lines truncated due to {line_cap} line limit, "
+                f"file has {read_result.total_lines} lines total, use offset/limit to read other parts)"
             )
 
-        # Build display with numbering and reminders
-        lines_out: list[str] = [_format_numbered_line(no, content) for no, content in read_result.selected_lines]
-        if read_result.remaining_selected_beyond_cap > 0:
-            lines_out.append(f"... (more {read_result.remaining_selected_beyond_cap} lines are truncated)")
         read_result_str = "\n".join(lines_out)
-
-        # Update FileTracker with last modified time
-        _track_file_access(file_path)
+        _track_file_access(file_path, content_sha256=read_result.content_sha256)
 
         return model.ToolResultItem(status="success", output=read_result_str)

klaude_code/core/tool/file/write_tool.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
-import difflib
 import os
 from pathlib import Path
 
 from pydantic import BaseModel
 
-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
@@ -62,36 +62,52 @@ class WriteTool(ToolABC):
 
         file_tracker = get_current_file_tracker()
         exists = file_exists(file_path)
+        tracked_status: model.FileStatus | None = None
 
         if exists:
-            tracked_status: model.FileStatus | None = None
-            if file_tracker is not None:
-                tracked_status = file_tracker.get(file_path)
+            tracked_status = file_tracker.get(file_path) if file_tracker is not None else None
             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."
-                    ),
-                )
 
-        # Capture previous content (if any) for diff generation
+        # Capture previous content (if any) for diff generation and external-change detection.
         before = ""
+        before_read_ok = False
         if exists:
             try:
                 before = await asyncio.to_thread(read_text, file_path)
+                before_read_ok = True
             except Exception:
                 before = ""
+                before_read_ok = False
+
+            # Re-check external modifications using content hash when available.
+            if before_read_ok and tracked_status is not None and 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."
+                        ),
+                    )
+            elif tracked_status is not None:
+                # Backward-compat: old sessions only stored mtime, or we couldn't hash.
+                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."
+                        ),
+                    )
 
         try:
             await asyncio.to_thread(write_text, file_path, args.content)
@@ -102,21 +118,15 @@ class WriteTool(ToolABC):
             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(args.content),
+                    is_memory=is_mem,
+                )
 
         # Build diff between previous and new content
         after = args.content
-        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.DiffTextUIExtra(diff_text=diff_text)
+        ui_extra = build_structured_diff(before, after, file_path=file_path)
 
         message = f"File {'overwritten' if exists else 'created'} successfully at: {file_path}"
         return model.ToolResultItem(status="success", output=message, ui_extra=ui_extra)