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

klaude_code/core/tool/shell/bash_tool.py

@@ -2,6 +2,7 @@ import asyncio
 import contextlib
 import os
 import re
+import shlex
 import signal
 import subprocess
 from pathlib import Path
@@ -12,6 +13,7 @@ from pydantic import BaseModel
 from klaude_code import const
 from klaude_code.core.tool.shell.command_safety import is_safe_command
 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
 
@@ -117,6 +119,149 @@ class BashTool(ToolABC):
             }
         )
 
+        def _hash_file_content_sha256(file_path: str) -> str | None:
+            try:
+                suffix = Path(file_path).suffix.lower()
+                if suffix in {".png", ".jpg", ".jpeg", ".gif", ".webp"}:
+                    import hashlib
+
+                    with open(file_path, "rb") as f:
+                        return hashlib.sha256(f.read()).hexdigest()
+
+                import hashlib
+
+                hasher = hashlib.sha256()
+                with open(file_path, encoding="utf-8", errors="replace") as f:
+                    for line in f:
+                        hasher.update(line.encode("utf-8"))
+                return hasher.hexdigest()
+            except (FileNotFoundError, IsADirectoryError, OSError, PermissionError, UnicodeDecodeError):
+                return None
+
+        def _resolve_in_dir(base_dir: str, path: str) -> str:
+            if os.path.isabs(path):
+                return os.path.abspath(path)
+            return os.path.abspath(os.path.join(base_dir, path))
+
+        def _track_files_read(file_paths: list[str], *, base_dir: str) -> None:
+            file_tracker = get_current_file_tracker()
+            if file_tracker is None:
+                return
+            for p in file_paths:
+                abs_path = _resolve_in_dir(base_dir, p)
+                if not os.path.exists(abs_path) or os.path.isdir(abs_path):
+                    continue
+                sha = _hash_file_content_sha256(abs_path)
+                if sha is None:
+                    continue
+                existing = file_tracker.get(abs_path)
+                is_mem = existing.is_memory if existing else False
+                with contextlib.suppress(Exception):
+                    file_tracker[abs_path] = model.FileStatus(
+                        mtime=Path(abs_path).stat().st_mtime,
+                        content_sha256=sha,
+                        is_memory=is_mem,
+                    )
+
+        def _track_files_written(file_paths: list[str], *, base_dir: str) -> None:
+            # Same as read tracking, but intentionally kept separate for clarity.
+            _track_files_read(file_paths, base_dir=base_dir)
+
+        def _track_mv(src_paths: list[str], dest_path: str, *, base_dir: str) -> None:
+            file_tracker = get_current_file_tracker()
+            if file_tracker is None:
+                return
+
+            abs_dest = _resolve_in_dir(base_dir, dest_path)
+            dest_is_dir = os.path.isdir(abs_dest)
+
+            for src in src_paths:
+                abs_src = _resolve_in_dir(base_dir, src)
+                abs_new = os.path.join(abs_dest, os.path.basename(abs_src)) if dest_is_dir else abs_dest
+
+                # Remove old entry if present.
+                existing = file_tracker.pop(abs_src, None)
+                is_mem = existing.is_memory if existing else False
+
+                if not os.path.exists(abs_new) or os.path.isdir(abs_new):
+                    continue
+
+                sha = _hash_file_content_sha256(abs_new)
+                if sha is None:
+                    continue
+                with contextlib.suppress(Exception):
+                    file_tracker[abs_new] = model.FileStatus(
+                        mtime=Path(abs_new).stat().st_mtime,
+                        content_sha256=sha,
+                        is_memory=is_mem,
+                    )
+
+        def _best_effort_update_file_tracker(command: str) -> None:
+            # Best-effort heuristics for common shell tools that access/modify files.
+            # We intentionally do not try to interpret complex shell scripts here.
+            try:
+                argv = shlex.split(command, posix=True)
+            except ValueError:
+                return
+            if not argv:
+                return
+
+            # Handle common patterns like: cd subdir && cat file
+            base_dir = os.getcwd()
+            while len(argv) >= 4 and argv[0] == "cd" and argv[2] == "&&":
+                dest = argv[1]
+                if dest != "-":
+                    base_dir = _resolve_in_dir(base_dir, dest)
+                argv = argv[3:]
+                if not argv:
+                    return
+
+            cmd0 = argv[0]
+            if cmd0 == "cat":
+                paths = [a for a in argv[1:] if a and not a.startswith("-") and a != "-"]
+                _track_files_read(paths, base_dir=base_dir)
+                return
+
+            if cmd0 == "sed":
+                # Support: sed [-i ...] 's/old/new/' file1 [file2 ...]
+                # and: sed -n 'Np' file
+                saw_script = False
+                file_paths: list[str] = []
+                for a in argv[1:]:
+                    if not a:
+                        continue
+                    if a == "--":
+                        continue
+                    if a.startswith("-") and not saw_script:
+                        continue
+                    if not saw_script and (a.startswith("s/") or a.startswith("s|") or a.endswith("p")):
+                        saw_script = True
+                        continue
+                    if saw_script and not a.startswith("-"):
+                        file_paths.append(a)
+
+                if file_paths:
+                    _track_files_written(file_paths, base_dir=base_dir)
+                return
+
+            if cmd0 == "mv":
+                # Support: mv [opts] src... dest
+                operands: list[str] = []
+                end_of_opts = False
+                for a in argv[1:]:
+                    if not end_of_opts and a == "--":
+                        end_of_opts = True
+                        continue
+                    if not end_of_opts and a.startswith("-"):
+                        continue
+                    operands.append(a)
+                if len(operands) < 2:
+                    return
+                srcs = operands[:-1]
+                dest = operands[-1]
+                _track_mv(srcs, dest, base_dir=base_dir)
+                return
+
         async def _terminate_process(proc: asyncio.subprocess.Process) -> None:
             # Best-effort termination. Ensure we don't hang on cancellation.
             if proc.returncode is not None:
@@ -185,6 +330,8 @@ class BashTool(ToolABC):
                 # Include stderr if there is useful diagnostics despite success
                 if stderr.strip():
                     output = (output + ("\n" if output else "")) + f"[stderr]\n{stderr}"
+
+                _best_effort_update_file_tracker(args.command)
                 return model.ToolResultItem(
                     status="success",
                     output=output.strip(),

klaude_code/protocol/commands.py

@@ -4,7 +4,6 @@ from enum import Enum
 class CommandName(str, Enum):
     INIT = "init"
     DEBUG = "debug"
-    DIFF = "diff"
     HELP = "help"
     MODEL = "model"
     COMPACT = "compact"

klaude_code/protocol/model.py

@@ -70,9 +70,15 @@ class TodoItem(BaseModel):
 
 
 class FileStatus(BaseModel):
-    """Tracks file state including modification time and memory file flag."""
+    """Tracks file state including modification time and content hash.
+
+    Notes:
+    - `mtime` is a cheap heuristic and may miss changes on some filesystems.
+    - `content_sha256` provides an explicit content-based change detector.
+    """
 
     mtime: float
+    content_sha256: str | None = None
     is_memory: bool = False
 
 
@@ -86,9 +92,27 @@ class ToolSideEffect(str, Enum):
 
 
 # Discriminated union types for ToolResultUIExtra
-class DiffTextUIExtra(BaseModel):
-    type: Literal["diff_text"] = "diff_text"
-    diff_text: str
+class DiffSpan(BaseModel):
+    op: Literal["equal", "insert", "delete"]
+    text: str
+
+
+class DiffLine(BaseModel):
+    kind: Literal["ctx", "add", "remove", "gap"]
+    new_line_no: int | None = None
+    spans: list[DiffSpan]
+
+
+class DiffFileDiff(BaseModel):
+    file_path: str
+    lines: list[DiffLine]
+    stats_add: int = 0
+    stats_remove: int = 0
+
+
+class DiffUIExtra(BaseModel):
+    type: Literal["diff"] = "diff"
+    files: list[DiffFileDiff]
 
 
 class TodoListUIExtra(BaseModel):
@@ -122,12 +146,7 @@ class SessionStatusUIExtra(BaseModel):
 
 
 ToolResultUIExtra = Annotated[
-    DiffTextUIExtra
-    | TodoListUIExtra
-    | SessionIdUIExtra
-    | MermaidLinkUIExtra
-    | TruncationUIExtra
-    | SessionStatusUIExtra,
+    DiffUIExtra | TodoListUIExtra | SessionIdUIExtra | MermaidLinkUIExtra | TruncationUIExtra | SessionStatusUIExtra,
     Field(discriminator="type"),
 ]
 

klaude_code/protocol/tools.py

@@ -1,14 +1,13 @@
 BASH = "Bash"
 APPLY_PATCH = "apply_patch"
 EDIT = "Edit"
-MULTI_EDIT = "MultiEdit"
+
 READ = "Read"
 WRITE = "Write"
 TODO_WRITE = "TodoWrite"
 UPDATE_PLAN = "update_plan"
 SKILL = "Skill"
 MERMAID = "Mermaid"
-MEMORY = "Memory"
 WEB_FETCH = "WebFetch"
 WEB_SEARCH = "WebSearch"
 REPORT_BACK = "report_back"

klaude_code/session/export.py

@@ -362,33 +362,87 @@ def _should_collapse(text: str) -> bool:
     return text.count("\n") + 1 > _COLLAPSIBLE_LINE_THRESHOLD or len(text) > _COLLAPSIBLE_CHAR_THRESHOLD
 
 
-def _render_diff_block(diff: str) -> str:
-    lines = diff.splitlines()
+def _render_diff_block(diff: model.DiffUIExtra) -> str:
     rendered: list[str] = []
-    for line in lines:
-        escaped = _escape_html(line)
-        if line.startswith("+"):
-            rendered.append(f'<span class="diff-line diff-plus">{escaped}</span>')
-        elif line.startswith("-"):
-            rendered.append(f'<span class="diff-line diff-minus">{escaped}</span>')
-        else:
-            rendered.append(f'<span class="diff-line diff-ctx">{escaped}</span>')
+    line_count = 0
+
+    for file_diff in diff.files:
+        header = _render_diff_file_header(file_diff)
+        if header:
+            rendered.append(header)
+        for line in file_diff.lines:
+            rendered.append(_render_diff_line(line))
+            line_count += 1
+
+    if line_count == 0:
+        rendered.append('<span class="diff-line diff-ctx">&nbsp;</span>')
+
     diff_content = f'<div class="diff-view">{"".join(rendered)}</div>'
-    open_attr = "" if _should_collapse(diff) else " open"
+    open_attr = "" if _should_collapse("\n" * max(1, line_count)) else " open"
     return (
         f'<details class="diff-collapsible"{open_attr}>'
-        f"<summary>Diff ({len(lines)} lines)</summary>"
+        f"<summary>Diff ({line_count} lines)</summary>"
         f"{diff_content}"
         "</details>"
     )
 
 
-def _get_diff_text(ui_extra: model.ToolResultUIExtra | None) -> str | None:
-    if isinstance(ui_extra, model.DiffTextUIExtra):
-        return ui_extra.diff_text
+def _render_diff_file_header(file_diff: model.DiffFileDiff) -> str:
+    stats_parts: list[str] = []
+    if file_diff.stats_add > 0:
+        stats_parts.append(f'<span class="diff-stats-add">+{file_diff.stats_add}</span>')
+    if file_diff.stats_remove > 0:
+        stats_parts.append(f'<span class="diff-stats-remove">-{file_diff.stats_remove}</span>')
+    stats_html = f' <span class="diff-stats">{" ".join(stats_parts)}</span>' if stats_parts else ""
+    file_name = _escape_html(file_diff.file_path)
+    return f'<div class="diff-file">{file_name}{stats_html}</div>'
+
+
+def _render_diff_line(line: model.DiffLine) -> str:
+    if line.kind == "gap":
+        line_class = "diff-ctx"
+        prefix = "⋮"
+    else:
+        line_class = "diff-plus" if line.kind == "add" else "diff-minus" if line.kind == "remove" else "diff-ctx"
+        prefix = "+" if line.kind == "add" else "-" if line.kind == "remove" else " "
+    spans = [_render_diff_span(span, line.kind) for span in line.spans]
+    content = "".join(spans)
+    if not content:
+        content = "&nbsp;"
+    return f'<span class="diff-line {line_class}">{prefix} {content}</span>'
+
+
+def _render_diff_span(span: model.DiffSpan, line_kind: str) -> str:
+    text = _escape_html(span.text)
+    if line_kind == "add" and span.op == "insert":
+        return f'<span class="diff-span diff-char-add">{text}</span>'
+    if line_kind == "remove" and span.op == "delete":
+        return f'<span class="diff-span diff-char-remove">{text}</span>'
+    return f'<span class="diff-span">{text}</span>'
+
+
+def _get_diff_ui_extra(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUIExtra | None:
+    if isinstance(ui_extra, model.DiffUIExtra):
+        return ui_extra
     return None
 
 
+def _build_add_only_diff(text: str, file_path: str) -> model.DiffUIExtra:
+    lines: list[model.DiffLine] = []
+    new_line_no = 1
+    for line in text.splitlines():
+        lines.append(
+            model.DiffLine(
+                kind="add",
+                new_line_no=new_line_no,
+                spans=[model.DiffSpan(op="equal", text=line)],
+            )
+        )
+        new_line_no += 1
+    file_diff = model.DiffFileDiff(file_path=file_path, lines=lines, stats_add=len(lines), stats_remove=0)
+    return model.DiffUIExtra(files=[file_diff])
+
+
 def _get_mermaid_link_html(
     ui_extra: model.ToolResultUIExtra | None, tool_call: model.ToolCallItem | None = None
 ) -> str | None:
@@ -513,18 +567,19 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
     ]
 
     if result:
-        diff_text = _get_diff_text(result.ui_extra)
+        diff_ui = _get_diff_ui_extra(result.ui_extra)
         mermaid_html = _get_mermaid_link_html(result.ui_extra, tool_call)
 
         should_hide_text = tool_call.name in ("TodoWrite", "update_plan") and result.status != "error"
 
-        if tool_call.name == "Edit" and not diff_text and result.status != "error":
+        if tool_call.name == "Edit" and not diff_ui and result.status != "error":
             try:
                 args_data = json.loads(tool_call.arguments)
+                file_path = args_data.get("file_path", "Unknown file")
                 old_string = args_data.get("old_string", "")
                 new_string = args_data.get("new_string", "")
                 if old_string == "" and new_string:
-                    diff_text = "\n".join(f"+{line}" for line in new_string.splitlines())
+                    diff_ui = _build_add_only_diff(new_string, file_path)
             except (json.JSONDecodeError, TypeError):
                 pass
 
@@ -536,8 +591,8 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
             else:
                 items_to_render.append(_render_text_block(result.output))
 
-        if diff_text:
-            items_to_render.append(_render_diff_block(diff_text))
+        if diff_ui:
+            items_to_render.append(_render_diff_block(diff_ui))
 
         if mermaid_html:
             items_to_render.append(mermaid_html)

klaude_code/session/templates/export_session.html

@@ -31,6 +31,8 @@
         --bg-overlay: rgba(248, 246, 240, 0.98);
         --bg-error: #fdecec;
         --bg-success: #eaf6ed;
+        --bg-error-strong: #f9d6d6;
+        --bg-success-strong: #d5efdd;
         --bg-code: #f7f7f4;
         --border: #ded8cf;
         --text: #151515;
@@ -815,6 +817,21 @@
         overflow-x: auto;
         border: 1px solid var(--border);
       }
+      .diff-file {
+        color: var(--accent);
+        font-weight: 700;
+        margin: 6px 0 4px 0;
+        font-size: var(--font-size-sm);
+      }
+      .diff-stats {
+        font-weight: 600;
+      }
+      .diff-stats-add {
+        color: var(--success);
+      }
+      .diff-stats-remove {
+        color: var(--error);
+      }
       .diff-line {
         white-space: pre;
       }
@@ -833,6 +850,17 @@
         opacity: 0.7;
         display: block;
       }
+      .diff-span {
+        white-space: pre;
+      }
+      .diff-char-add {
+        background: var(--bg-success-strong);
+        font-weight: 600;
+      }
+      .diff-char-remove {
+        background: var(--bg-error-strong);
+        font-weight: 600;
+      }
 
       /* Collapsible Diff View */
       details.diff-collapsible {

klaude_code/ui/renderers/common.py

@@ -31,16 +31,20 @@ def truncate_display(
         return Text(f"… (more {remaining} lines)", style=ThemeKey.TOOL_RESULT_TRUNCATED)
 
     lines = text.split("\n")
-    extra_lines = 0
-    if len(lines) > max_lines:
-        extra_lines = len(lines) - max_lines
-        lines = lines[:max_lines]
+    truncated_lines = 0
+    head_lines: list[str] = []
+    tail_lines: list[str] = []
 
-    out = Text()
-    if base_style is not None:
-        out.style = base_style
+    if len(lines) > max_lines:
+        truncated_lines = len(lines) - max_lines
+        head_count = max_lines // 2
+        tail_count = max_lines - head_count
+        head_lines = lines[:head_count]
+        tail_lines = lines[-tail_count:]
+    else:
+        head_lines = lines
 
-    for idx, line in enumerate(lines):
+    def append_line(out: Text, line: str) -> None:
         if len(line) > max_line_length:
             extra_chars = len(line) - max_line_length
             out.append(line[:max_line_length])
@@ -53,10 +57,21 @@ def truncate_display(
         else:
             out.append(line)
 
-        if idx != len(lines) - 1 or extra_lines > 0:
+    out = Text()
+    if base_style is not None:
+        out.style = base_style
+
+    for idx, line in enumerate(head_lines):
+        append_line(out, line)
+        if idx < len(head_lines) - 1 or truncated_lines > 0 or tail_lines:
             out.append("\n")
 
-    if extra_lines > 0:
-        out.append_text(Text(f"… (more {extra_lines} lines)", style=ThemeKey.TOOL_RESULT_TRUNCATED))
+    if truncated_lines > 0:
+        out.append_text(Text(f"⋮ (more {truncated_lines} lines)\n", style=ThemeKey.TOOL_RESULT_TRUNCATED))
+
+    for idx, line in enumerate(tail_lines):
+        append_line(out, line)
+        if idx < len(tail_lines) - 1:
+            out.append("\n")
 
     return out

klaude_code/ui/renderers/developer.py

@@ -4,7 +4,6 @@ from rich.table import Table
 from rich.text import Text
 
 from klaude_code.protocol import commands, events, model
-from klaude_code.ui.renderers import diffs as r_diffs
 from klaude_code.ui.renderers.common import create_grid, truncate_display
 from klaude_code.ui.renderers.tools import render_path
 from klaude_code.ui.rich.markdown import NoInsetMarkdown
@@ -103,10 +102,6 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
         return Text("")
 
     match e.item.command_output.command_name:
-        case commands.CommandName.DIFF:
-            if e.item.content is None or len(e.item.content) == 0:
-                return Padding.indent(Text("(no changes)", style=ThemeKey.TOOL_RESULT), level=2)
-            return r_diffs.render_diff_panel(e.item.content, show_file_name=True)
         case commands.CommandName.HELP:
             return Padding.indent(Text.from_markup(e.item.content or ""), level=2)
         case commands.CommandName.STATUS:

klaude_code/ui/renderers/diffs.py

@@ -5,6 +5,7 @@ from rich.panel import Panel
 from rich.text import Text
 
 from klaude_code import const
+from klaude_code.protocol import model
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.theme import ThemeKey
 
@@ -179,6 +180,30 @@ def render_diff(diff_text: str, show_file_name: bool = False) -> RenderableType:
     return grid
 
 
+def render_structured_diff(ui_extra: model.DiffUIExtra, show_file_name: bool = False) -> RenderableType:
+    files = ui_extra.files
+    if not files:
+        return Text("")
+
+    grid = create_grid()
+    grid.padding = (0, 0)
+    show_headers = show_file_name or len(files) > 1
+
+    for idx, file_diff in enumerate(files):
+        if idx > 0:
+            grid.add_row("", "")
+
+        if show_headers:
+            grid.add_row(*_render_file_header(file_diff))
+
+        for line in file_diff.lines:
+            prefix = _make_structured_prefix(line, const.DIFF_PREFIX_WIDTH)
+            text = _render_structured_line(line)
+            grid.add_row(Text(prefix, ThemeKey.TOOL_RESULT), text)
+
+    return grid
+
+
 def render_diff_panel(
     diff_text: str,
     *,
@@ -210,3 +235,62 @@ def render_diff_panel(
     if indent <= 0:
         return panel
     return Padding.indent(panel, level=indent)
+
+
+def _render_file_header(file_diff: model.DiffFileDiff) -> tuple[Text, Text]:
+    file_text = Text(file_diff.file_path, style=ThemeKey.DIFF_FILE_NAME)
+    stats_text = Text()
+    if file_diff.stats_add > 0:
+        stats_text.append(f"+{file_diff.stats_add}", style=ThemeKey.DIFF_STATS_ADD)
+    if file_diff.stats_remove > 0:
+        if stats_text.plain:
+            stats_text.append(" ")
+        stats_text.append(f"-{file_diff.stats_remove}", style=ThemeKey.DIFF_STATS_REMOVE)
+
+    file_line = Text(style=ThemeKey.DIFF_FILE_NAME)
+    file_line.append_text(file_text)
+    if stats_text.plain:
+        file_line.append(" (")
+        file_line.append_text(stats_text)
+        file_line.append(")")
+
+    if file_diff.stats_add > 0 and file_diff.stats_remove == 0:
+        file_mark = "+"
+    elif file_diff.stats_remove > 0 and file_diff.stats_add == 0:
+        file_mark = "-"
+    else:
+        file_mark = "±"
+
+    prefix = Text(f"{file_mark:>{const.DIFF_PREFIX_WIDTH}}  ", style=ThemeKey.DIFF_FILE_NAME)
+    return prefix, file_line
+
+
+def _make_structured_prefix(line: model.DiffLine, width: int) -> str:
+    if line.kind == "gap":
+        return f"{'⋮':>{width}}  "
+    number = " " * width
+    if line.kind in {"add", "ctx"} and line.new_line_no is not None:
+        number = f"{line.new_line_no:>{width}}"
+    marker = "+" if line.kind == "add" else "-" if line.kind == "remove" else " "
+    return f"{number} {marker}"
+
+
+def _render_structured_line(line: model.DiffLine) -> Text:
+    if line.kind == "gap":
+        return Text("")
+    text = Text()
+    for span in line.spans:
+        text.append(span.text, style=_span_style(line.kind, span.op))
+    return text
+
+
+def _span_style(line_kind: str, span_op: str) -> ThemeKey:
+    if line_kind == "add":
+        if span_op == "insert":
+            return ThemeKey.DIFF_ADD_CHAR
+        return ThemeKey.DIFF_ADD
+    if line_kind == "remove":
+        if span_op == "delete":
+            return ThemeKey.DIFF_REMOVE_CHAR
+        return ThemeKey.DIFF_REMOVE
+    return ThemeKey.TOOL_RESULT