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

klaude_code/core/task.py

@@ -25,7 +25,7 @@ class MetadataAccumulator:
     """
 
     def __init__(self, model_name: str) -> None:
-        self._main = model.TaskMetadata(model_name=model_name)
+        self._main_agent = model.TaskMetadata(model_name=model_name)  # Main agent metadata
         self._sub_agent_metadata: list[model.TaskMetadata] = []
         self._throughput_weighted_sum: float = 0.0
         self._throughput_tracked_tokens: int = 0
@@ -36,13 +36,12 @@ class MetadataAccumulator:
     def add(self, turn_metadata: model.ResponseMetadataItem) -> None:
         """Merge a turn's metadata into the accumulated state."""
         self._turn_count += 1
-        main = self._main
         usage = turn_metadata.usage
 
         if usage is not None:
-            if main.usage is None:
-                main.usage = model.Usage()
-            acc_usage = main.usage
+            if self._main_agent.usage is None:
+                self._main_agent.usage = model.Usage()
+            acc_usage = self._main_agent.usage
 
             model.TaskMetadata.merge_usage(acc_usage, usage)
             acc_usage.currency = usage.currency
@@ -63,9 +62,9 @@ class MetadataAccumulator:
                     self._throughput_tracked_tokens += current_output
 
         if turn_metadata.provider is not None:
-            main.provider = turn_metadata.provider
+            self._main_agent.provider = turn_metadata.provider
         if turn_metadata.model_name:
-            main.model_name = turn_metadata.model_name
+            self._main_agent.model_name = turn_metadata.model_name
 
     def add_sub_agent_metadata(self, sub_agent_metadata: model.TaskMetadata) -> None:
         """Add sub-agent task metadata to the accumulated state."""
@@ -73,21 +72,22 @@ class MetadataAccumulator:
 
     def finalize(self, task_duration_s: float) -> model.TaskMetadataItem:
         """Return the final accumulated metadata with computed throughput and duration."""
-        main = self._main
-        if main.usage is not None:
+        if self._main_agent.usage is not None:
             if self._throughput_tracked_tokens > 0:
-                main.usage.throughput_tps = self._throughput_weighted_sum / self._throughput_tracked_tokens
+                self._main_agent.usage.throughput_tps = self._throughput_weighted_sum / self._throughput_tracked_tokens
             else:
-                main.usage.throughput_tps = None
+                self._main_agent.usage.throughput_tps = None
 
             if self._first_token_latency_count > 0:
-                main.usage.first_token_latency_ms = self._first_token_latency_sum / self._first_token_latency_count
+                self._main_agent.usage.first_token_latency_ms = (
+                    self._first_token_latency_sum / self._first_token_latency_count
+                )
             else:
-                main.usage.first_token_latency_ms = None
+                self._main_agent.usage.first_token_latency_ms = None
 
-        main.task_duration_s = task_duration_s
-        main.turn_count = self._turn_count
-        return model.TaskMetadataItem(main=main, sub_agent_task_metadata=self._sub_agent_metadata)
+        self._main_agent.task_duration_s = task_duration_s
+        self._main_agent.turn_count = self._turn_count
+        return model.TaskMetadataItem(main_agent=self._main_agent, sub_agent_task_metadata=self._sub_agent_metadata)
 
 
 @dataclass
@@ -126,17 +126,28 @@ class TaskExecutor:
         self._context = context
         self._current_turn: TurnExecutor | None = None
         self._started_at: float = 0.0
+        self._metadata_accumulator: MetadataAccumulator | None = None
 
     @property
     def current_turn(self) -> TurnExecutor | None:
         return self._current_turn
 
     def cancel(self) -> list[events.Event]:
-        """Cancel the current turn and return any resulting events."""
+        """Cancel the current turn and return any resulting events including metadata."""
         ui_events: list[events.Event] = []
         if self._current_turn is not None:
             ui_events.extend(self._current_turn.cancel())
             self._current_turn = None
+
+        # Emit partial metadata on cancellation
+        if self._metadata_accumulator is not None and self._started_at > 0:
+            task_duration_s = time.perf_counter() - self._started_at
+            accumulated = self._metadata_accumulator.finalize(task_duration_s)
+            if accumulated.main_agent.usage is not None:
+                session_id = self._context.session_ctx.session_id
+                ui_events.append(events.TaskMetadataEvent(metadata=accumulated, session_id=session_id))
+                self._context.session_ctx.append_history([accumulated])
+
         return ui_events
 
     async def run(self, user_input: model.UserInputPayload) -> AsyncGenerator[events.Event]:
@@ -152,7 +163,8 @@ class TaskExecutor:
         del user_input  # Persisted by the operation handler before launching the task.
 
         profile = ctx.profile
-        metadata_accumulator = MetadataAccumulator(model_name=profile.llm_client.model_name)
+        self._metadata_accumulator = MetadataAccumulator(model_name=profile.llm_client.model_name)
+        metadata_accumulator = self._metadata_accumulator
 
         while True:
             # Process reminders at the start of each turn
@@ -226,6 +238,13 @@ class TaskExecutor:
                 return
 
             if turn is None or turn.task_finished:
+                # Sub-agent with empty result should retry instead of finishing
+                if ctx.sub_agent_state is not None and turn is not None and not turn.task_result.strip():
+                    yield events.ErrorEvent(
+                        error_message="Sub-agent returned empty result, retrying...",
+                        can_retry=True,
+                    )
+                    continue
                 break
 
         # Finalize metadata

klaude_code/core/tool/__init__.py

@@ -1,15 +1,12 @@
 from .file.apply_patch import DiffError, process_patch
 from .file.apply_patch_tool import ApplyPatchTool
 from .file.edit_tool import EditTool
-from .file.multi_edit_tool import MultiEditTool
 from .file.read_tool import ReadTool
 from .file.write_tool import WriteTool
-from .memory.memory_tool import MEMORY_DIR_NAME, MemoryTool
-from .memory.skill_loader import Skill, SkillLoader
-from .memory.skill_tool import SkillTool
 from .report_back_tool import ReportBackTool
 from .shell.bash_tool import BashTool
 from .shell.command_safety import SafetyCheckResult, is_safe_command
+from .skill.skill_tool import SkillTool
 from .sub_agent_tool import SubAgentTool
 from .todo.todo_write_tool import TodoWriteTool
 from .todo.update_plan_tool import UpdatePlanTool
@@ -32,21 +29,16 @@ from .web.web_fetch_tool import WebFetchTool
 from .web.web_search_tool import WebSearchTool
 
 __all__ = [
-    "MEMORY_DIR_NAME",
     "ApplyPatchTool",
     "BashTool",
     "DiffError",
     "EditTool",
     "FileTracker",
-    "MemoryTool",
     "MermaidTool",
-    "MultiEditTool",
     "ReadTool",
     "ReportBackTool",
     "SafetyCheckResult",
     "SimpleTruncationStrategy",
-    "Skill",
-    "SkillLoader",
     "SkillTool",
     "SubAgentTool",
     "TodoContext",

klaude_code/core/tool/file/_utils.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import hashlib
 import os
 from pathlib import Path
 
@@ -28,3 +29,8 @@ def write_text(path: str, content: str) -> None:
     parent.mkdir(parents=True, exist_ok=True)
     with open(path, "w", encoding="utf-8") as f:
         f.write(content)
+
+
+def hash_text_sha256(content: str) -> str:
+    """Return SHA-256 for the given text content encoded as UTF-8."""
+    return hashlib.sha256(content.encode("utf-8")).hexdigest()

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: