comate-cli 0.7.7__tar.gz → 0.7.9__tar.gz

{comate_cli-0.7.7 → comate_cli-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.7
+Version: 0.7.9
 Summary: Comate terminal CLI built on comate-agent-sdk
 Project-URL: Homepage, https://github.com/AndyLee1024/agent-sdk
 Project-URL: Repository, https://github.com/AndyLee1024/agent-sdk

{comate_cli-0.7.7 → comate_cli-0.7.9}/comate_cli/main.py

@@ -26,6 +26,15 @@ class _ArgumentError(ValueError):
     """Raised when CLI arguments are invalid."""
 
 
+PRINT_STDIN_IDLE_TIMEOUT_SECONDS = 3.0
+PRINT_OUTPUT_FORMAT_TEXT = "text"
+PRINT_OUTPUT_FORMAT_JSON = "json"
+PRINT_OUTPUT_FORMATS = frozenset({PRINT_OUTPUT_FORMAT_TEXT, PRINT_OUTPUT_FORMAT_JSON})
+PRINT_OUTPUT_FORMAT_UNSUPPORTED = frozenset({"stream-json"})
+
+ParsedArgs = tuple[bool, str | None, bool, str | None, str]
+
+
 class _TerminalStateGuard:
     """Best-effort tty restore guard for abnormal shutdown paths."""
 
@@ -200,37 +209,68 @@ def _usage_text() -> str:
     return (
         "Usage:\n"
         "  comate [--rpc-stdio]\n"
-        "  comate -p <prompt>\n"
+        "  comate -p [--output-format text|json] <prompt>\n"
         "  comate resume [<session_id>] [--rpc-stdio]\n"
         "  comate mcp <subcommand> [options]"
     )
 
 
-def _parse_args(argv: list[str]) -> tuple[bool, str | None, bool, str | None]:
+def _parse_args(argv: list[str]) -> ParsedArgs:
     rpc_stdio = False
     print_mode = False
+    output_format = PRINT_OUTPUT_FORMAT_TEXT
+    output_format_explicit = False
     positionals: list[str] = []
-    for arg in argv:
+
+    index = 0
+    while index < len(argv):
+        arg = argv[index]
         if arg == "--rpc-stdio":
             rpc_stdio = True
+            index += 1
             continue
         if arg in ("-p", "--print"):
             print_mode = True
+            index += 1
+            continue
+        if arg == "--output-format" or arg.startswith("--output-format="):
+            output_format_explicit = True
+            if arg == "--output-format":
+                index += 1
+                if index >= len(argv):
+                    raise _ArgumentError("--output-format requires one of: text, json")
+                value = argv[index]
+            else:
+                value = arg.partition("=")[2]
+                if not value:
+                    raise _ArgumentError("--output-format requires one of: text, json")
+            if value in PRINT_OUTPUT_FORMAT_UNSUPPORTED:
+                raise _ArgumentError(
+                    "--output-format stream-json is not supported in this release"
+                )
+            if value not in PRINT_OUTPUT_FORMATS:
+                raise _ArgumentError(f"Unsupported --output-format: {value}")
+            output_format = value
+            index += 1
             continue
         if arg.startswith("-"):
             raise _ArgumentError(f"Unknown option: {arg}")
         positionals.append(arg)
+        index += 1
+
+    if output_format_explicit and not print_mode:
+        raise _ArgumentError("--output-format can only be used with -p/--print")
 
     # -p mode: all positionals become the prompt
     if print_mode:
         if rpc_stdio:
             raise _ArgumentError("-p/--print and --rpc-stdio are mutually exclusive")
         print_prompt = " ".join(positionals) if positionals else ""
-        return rpc_stdio, None, False, print_prompt
+        return rpc_stdio, None, False, print_prompt, output_format
 
     # Non -p mode: original logic
     if not positionals:
-        return rpc_stdio, None, False, None
+        return rpc_stdio, None, False, None, output_format
 
     command = positionals[0]
     if command != "resume":
@@ -241,14 +281,75 @@ def _parse_args(argv: list[str]) -> tuple[bool, str | None, bool, str | None]:
             raise _ArgumentError(
                 "resume without <session_id> does not support --rpc-stdio"
             )
-        return rpc_stdio, None, True, None
+        return rpc_stdio, None, True, None, output_format
 
     if len(positionals) == 2:
-        return rpc_stdio, positionals[1], False, None
+        return rpc_stdio, positionals[1], False, None, output_format
 
     raise _ArgumentError("resume accepts at most one <session_id>")
 
 
+def _read_stdin_posix_idle_drain(
+    stdin: object,
+    *,
+    timeout_seconds: float,
+    chunk_size: int = 64 * 1024,
+) -> str:
+    import select
+
+    fileno = getattr(stdin, "fileno", None)
+    if not callable(fileno):
+        read = getattr(stdin, "read", None)
+        return str(read()) if callable(read) else ""
+
+    try:
+        fd = fileno()
+    except (AttributeError, OSError, ValueError):
+        read = getattr(stdin, "read", None)
+        return str(read()) if callable(read) else ""
+
+    chunks: list[bytes] = []
+    while True:
+        readable, _, _ = select.select([fd], [], [], timeout_seconds)
+        if not readable:
+            break
+        try:
+            chunk = os.read(fd, chunk_size)
+        except BlockingIOError:
+            break
+        except OSError:
+            break
+        if not chunk:
+            break
+        chunks.append(chunk)
+
+    encoding = str(getattr(stdin, "encoding", "") or "utf-8")
+    return b"".join(chunks).decode(encoding, errors="replace")
+
+
+def _read_stdin_if_ready(
+    stdin: object,
+    *,
+    timeout_seconds: float = PRINT_STDIN_IDLE_TIMEOUT_SECONDS,
+) -> str:
+    isatty = getattr(stdin, "isatty", None)
+    if callable(isatty) and isatty():
+        return ""
+
+    if os.name != "posix":
+        read = getattr(stdin, "read", None)
+        return str(read()) if callable(read) else ""
+
+    try:
+        return _read_stdin_posix_idle_drain(
+            stdin,
+            timeout_seconds=timeout_seconds,
+        )
+    except (OSError, ValueError):
+        read = getattr(stdin, "read", None)
+        return str(read()) if callable(read) else ""
+
+
 def main(argv: list[str] | None = None) -> None:
     run_argv = list(argv) if argv is not None else sys.argv[1:]
 
@@ -278,7 +379,9 @@ def main(argv: list[str] | None = None) -> None:
     _app_import_done_perf = time.perf_counter()
 
     try:
-        rpc_stdio, resume_session_id, resume_select, print_prompt = _parse_args(run_argv)
+        rpc_stdio, resume_session_id, resume_select, print_prompt, print_output_format = (
+            _parse_args(run_argv)
+        )
     except _ArgumentError as exc:
         sys.stderr.write(f"{exc}\n{_usage_text()}\n")
         raise SystemExit(2) from exc
@@ -286,9 +389,7 @@ def main(argv: list[str] | None = None) -> None:
     # Assemble print mode message
     print_message: str | None = None
     if print_prompt is not None:
-        stdin_text = ""
-        if not sys.stdin.isatty():
-            stdin_text = sys.stdin.read()
+        stdin_text = _read_stdin_if_ready(sys.stdin)
         parts = [p for p in (stdin_text.strip(), print_prompt.strip()) if p]
         if not parts:
             sys.stderr.write("Error: -p requires a prompt argument or stdin input\n")
@@ -302,6 +403,7 @@ def main(argv: list[str] | None = None) -> None:
                 resume_session_id=resume_session_id,
                 resume_select=resume_select,
                 print_message=print_message,
+                print_output_format=print_output_format,
                 process_start_perf=_PROCESS_START_PERF,
                 app_import_start_perf=_app_import_start_perf,
                 app_import_done_perf=_app_import_done_perf,

{comate_cli-0.7.7 → comate_cli-0.7.9}/comate_cli/terminal_agent/app.py

@@ -5,46 +5,44 @@ import logging
 import os
 import random  # noqa: F401 - tests patch this module-level import for deterministic startup tips.
 import signal
-import sys
 import threading
 import time
 from collections.abc import Iterator
 from contextlib import contextmanager, suppress
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from rich.console import Console
 
-from comate_agent_sdk.agent import Agent, AgentConfig, ChatSession, TextEvent
-from comate_agent_sdk.context import EnvOptions
-from comate_agent_sdk.tools import tool
-
-from comate_cli.terminal_agent.event_renderer import EventRenderer
-from comate_cli.terminal_agent.logo import print_logo
-from comate_cli.terminal_agent.preflight import run_preflight_if_needed
-from comate_cli.terminal_agent.resume_selector import select_resume_session_id
-from comate_cli.terminal_agent.rpc_stdio import StdioRPCBridge
 from comate_cli.terminal_agent.startup_profile import StartupProfiler
-from comate_cli.terminal_agent.status_bar import StatusBar
-from comate_cli.terminal_agent.tui import TerminalAgentTUI
-from comate_cli.terminal_agent.update_check import (
-    UpdateInfo,
-    UpdatePromptChoice,
-    UpdatePromptDecision,
-    check_update,
-    decide_update_prompt,
-    format_update_hint,
-    get_pending_update_prompt_info,
-    mark_update_seen,
-    record_skip_until_next_version,
-    record_update_check_attempt,
-    run_update_command,
-    should_check_for_update,
-    show_update_prompt,
-)
+
+if TYPE_CHECKING:
+    from comate_agent_sdk.agent.chat_session import ChatSession
+    from comate_agent_sdk.agent.core.template import AgentTemplate as Agent
+    from comate_cli.terminal_agent.event_renderer import EventRenderer
+    from comate_cli.terminal_agent.update_check import UpdateInfo
 
 console = Console()
 logger = logging.getLogger(__name__)
 _UPDATE_CHECK_DELAY_S = 1.0
+PRINT_MODE_DISALLOWED_TOOLS = (
+    "TeamCreate",
+    "TeamDelete",
+    "SendMessage",
+    "YieldTurn",
+)
+
+
+def _merge_disallowed_tools(*groups: tuple[str, ...] | None) -> tuple[str, ...] | None:
+    merged: list[str] = []
+    seen: set[str] = set()
+    for group in groups:
+        for name in group or ():
+            if name in seen:
+                continue
+            seen.add(name)
+            merged.append(name)
+    return tuple(merged) or None
 
 
 def _resolve_cli_project_root() -> Path:
@@ -56,6 +54,7 @@ async def _check_update(*, profiler: StartupProfiler | None = None) -> UpdateInf
     if profiler is not None:
         profiler.mark("impl.start")
     try:
+        check_update, _, _, _ = _import_update_check_core()
         return await check_update(log=logger, profiler=profiler)
     finally:
         if profiler is not None:
@@ -67,6 +66,16 @@ async def _handle_update_on_launch(info: UpdateInfo) -> bool:
 
     Returns True when launch should stop after a successful update.
     """
+    (
+        UpdatePromptChoice,
+        UpdatePromptDecision,
+        decide_update_prompt,
+        format_update_hint,
+        mark_update_seen,
+        record_skip_until_next_version,
+        run_update_command,
+        show_update_prompt,
+    ) = _import_update_prompt_components()
     try:
         decision = decide_update_prompt(info)
         if decision == UpdatePromptDecision.SKIP:
@@ -92,6 +101,16 @@ async def _handle_background_update_on_launch(
     renderer: EventRenderer,
     profiler: StartupProfiler,
 ) -> None:
+    (
+        _UpdatePromptChoice,
+        UpdatePromptDecision,
+        decide_update_prompt,
+        format_update_hint,
+        mark_update_seen,
+        _record_skip_until_next_version,
+        _run_update_command,
+        _show_update_prompt,
+    ) = _import_update_prompt_components()
     try:
         decision = decide_update_prompt(info)
         if decision == UpdatePromptDecision.SKIP:
@@ -198,6 +217,133 @@ def _sigint_guard() -> Iterator[None]:
             logger.warning(f"Failed to restore SIGINT handler: {exc}", exc_info=True)
 
 
+@contextmanager
+def _profile_section(
+    profiler: StartupProfiler | None,
+    phase: str,
+) -> Iterator[None]:
+    if profiler is not None:
+        profiler.mark(f"{phase}.start")
+    try:
+        yield
+    finally:
+        if profiler is not None:
+            profiler.mark(f"{phase}.done")
+
+
+def _import_preflight_runner():
+    from comate_cli.terminal_agent.preflight import run_preflight_if_needed
+
+    return run_preflight_if_needed
+
+
+def _import_print_mode_runner():
+    from comate_cli.terminal_agent.print_mode import run_print_mode
+
+    return run_print_mode
+
+
+def _import_print_mode_json_error_writer():
+    from comate_cli.terminal_agent.print_mode import write_json_error_result
+
+    return write_json_error_result
+
+
+def print_logo(*args, **kwargs) -> None:
+    from comate_cli.terminal_agent.logo import print_logo as _print_logo
+
+    _print_logo(*args, **kwargs)
+
+
+def _import_sdk_agent_components(
+    profiler: StartupProfiler | None = None,
+) -> tuple[type, type, type, type]:
+    with _profile_section(profiler, "main.import.sdk_agent"):
+        from comate_agent_sdk.agent.compaction import CompactionConfig
+        from comate_agent_sdk.agent.options import AgentConfig
+        from comate_agent_sdk.agent.service import Agent
+        from comate_agent_sdk.context import EnvOptions
+
+    return Agent, AgentConfig, CompactionConfig, EnvOptions
+
+
+def _import_chat_session() -> type:
+    from comate_agent_sdk.agent.chat_session import ChatSession
+
+    return ChatSession
+
+
+def _import_print_mode_components() -> tuple[type, type]:
+    from comate_agent_sdk.agent.chat_session import ChatSession
+    from comate_agent_sdk.agent.events import TextEvent
+
+    return ChatSession, TextEvent
+
+
+def _import_rpc_bridge() -> type:
+    from comate_cli.terminal_agent.rpc_stdio import StdioRPCBridge
+
+    return StdioRPCBridge
+
+
+def _import_resume_selector():
+    from comate_cli.terminal_agent.resume_selector import select_resume_session_id
+
+    return select_resume_session_id
+
+
+def _import_interactive_tui_components(
+    profiler: StartupProfiler | None = None,
+):
+    with _profile_section(profiler, "main.import.tui"):
+        from comate_cli.terminal_agent.event_renderer import EventRenderer
+        from comate_cli.terminal_agent.logging_adapter import setup_tui_logging
+        from comate_cli.terminal_agent.status_bar import StatusBar
+        from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+    return EventRenderer, setup_tui_logging, StatusBar, TerminalAgentTUI
+
+
+def _import_update_check_core():
+    from comate_cli.terminal_agent.update_check import (
+        check_update,
+        get_pending_update_prompt_info,
+        record_update_check_attempt,
+        should_check_for_update,
+    )
+
+    return (
+        check_update,
+        get_pending_update_prompt_info,
+        record_update_check_attempt,
+        should_check_for_update,
+    )
+
+
+def _import_update_prompt_components():
+    from comate_cli.terminal_agent.update_check import (
+        UpdatePromptChoice,
+        UpdatePromptDecision,
+        decide_update_prompt,
+        format_update_hint,
+        mark_update_seen,
+        record_skip_until_next_version,
+        run_update_command,
+        show_update_prompt,
+    )
+
+    return (
+        UpdatePromptChoice,
+        UpdatePromptDecision,
+        decide_update_prompt,
+        format_update_hint,
+        mark_update_seen,
+        record_skip_until_next_version,
+        run_update_command,
+        show_update_prompt,
+    )
+
+
 async def _shutdown_session(session: ChatSession, *, label: str) -> None:
     start = time.monotonic()
     try:
@@ -235,17 +381,13 @@ async def _graceful_shutdown(*sessions: ChatSession) -> None:
     logger.info(f"Graceful shutdown completed in {elapsed:.3f}s")
 
 
-@tool("Add two numbers 涉及到加法运算 必须使用这个工具")
-async def add(a: int, b: int) -> int:
-    return a + b
-
-
 def _build_agent(
     *,
     project_root: Path | None = None,
     profiler: StartupProfiler | None = None,
+    extra_disallowed_tools: tuple[str, ...] | None = None,
 ) -> Agent:
-    from comate_agent_sdk.agent.compaction import CompactionConfig
+    Agent, AgentConfig, CompactionConfig, EnvOptions = _import_sdk_agent_components(profiler)
     from comate_cli.terminal_agent.config import store
 
     resolved_project_root = project_root or _resolve_cli_project_root()
@@ -254,6 +396,7 @@ def _build_agent(
     snapshot = store.load()
     if profiler is not None:
         profiler.mark("agent.config.load.done")
+    disallowed_tools = _merge_disallowed_tools(extra_disallowed_tools)
 
     agent_config = AgentConfig(
         role="software_engineering",
@@ -261,11 +404,13 @@ def _build_agent(
         env_options=EnvOptions(system_env=True, git_env=True),
         use_streaming_task=True,
         include_cost=bool(getattr(snapshot, "token_cost_enabled", False)),
+        strict_hook_settings=False,
         memory_background_enabled=snapshot.memory_background_enabled,
         memory_dreaming_enabled=snapshot.memory_dreaming_enabled,
         compaction=CompactionConfig(
             threshold_ratio=snapshot.compaction_threshold_ratio,
         ),
+        disallowed_tools=disallowed_tools,
     )
     if profiler is not None:
         profiler.mark("agent.construct.start")
@@ -283,6 +428,7 @@ def _resolve_session(
     cwd: Path | None = None,
     profiler: StartupProfiler | None = None,
 ) -> tuple[ChatSession, str]:
+    ChatSession = _import_chat_session()
     if resume_session_id:
         if profiler is not None:
             profiler.mark("session.resume.construct.start")
@@ -388,27 +534,17 @@ async def _run_print_mode(
     message: str,
     *,
     project_root: Path,
+    output_format: str = "text",
 ) -> None:
-    session = ChatSession(agent, cwd=project_root, persistent=False)
-    try:
-        await _preload_mcp_in_tui(session)
-
-        final_text = ""
-        async for event in session.query_stream(message):
-            if isinstance(event, TextEvent):
-                final_text = event.content
-
-        if final_text:
-            sys.stdout.write(final_text)
-            if not final_text.endswith("\n"):
-                sys.stdout.write("\n")
-            sys.stdout.flush()
-    except Exception as exc:
-        logger.error(f"Print mode failed: {exc}", exc_info=True)
-        sys.stderr.write(f"Error: {exc}\n")
-        raise SystemExit(1) from exc
-    finally:
-        await _graceful_shutdown(session)
+    run_print_mode = _import_print_mode_runner()
+    await run_print_mode(
+        agent,
+        message,
+        project_root=project_root,
+        output_format=output_format,
+        preload_mcp=_preload_mcp_in_tui,
+        graceful_shutdown=_graceful_shutdown,
+    )
 
 
 def _install_event_loop_exception_handler() -> None:
@@ -442,6 +578,7 @@ async def run(
     resume_session_id: str | None = None,
     resume_select: bool = False,
     print_message: str | None = None,
+    print_output_format: str = "text",
     process_start_perf: float | None = None,
     app_import_start_perf: float | None = None,
     app_import_done_perf: float | None = None,
@@ -452,20 +589,34 @@ async def run(
     profiler = StartupProfiler.from_env(logger=logger, started_at=process_start_perf)
     if app_import_start_perf is not None:
         profiler.mark_at("main.app_import.start", app_import_start_perf)
+        profiler.mark_at("main.import.app.start", app_import_start_perf)
     if app_import_done_perf is not None:
         profiler.mark_at("main.app_import.done", app_import_done_perf)
+        profiler.mark_at("main.import.app.done", app_import_done_perf)
     profiler.mark("cli_project_root.start")
     project_root = _resolve_cli_project_root()
     profiler.mark("cli_project_root.done")
     profiler.mark("preflight.start")
+    run_preflight_if_needed = _import_preflight_runner()
+    preflight_console = console
+    if print_message is not None and print_output_format == "json":
+        preflight_console = Console(stderr=True)
     preflight_result = await run_preflight_if_needed(
-        console=console,
+        console=preflight_console,
         project_root=project_root,
         interactive=not rpc_stdio and print_message is None,
     )
     profiler.mark("preflight.done")
     if preflight_result.should_abort_launch:
         if print_message is not None:
+            if print_output_format == "json":
+                write_json_error_result = _import_print_mode_json_error_writer()
+                detail = preflight_result.detail or preflight_result.status
+                write_json_error_result(
+                    error=f"Preflight failed: {detail}",
+                    stop_reason=None,
+                    session_id=None,
+                )
             raise SystemExit(1)
         return
 
@@ -473,6 +624,12 @@ async def run(
         print_logo(console, project_root=project_root)
         profiler.mark("logo.printed")
 
+        (
+            _check_update_func,
+            get_pending_update_prompt_info,
+            _record_update_check_attempt,
+            _should_check_for_update,
+        ) = _import_update_check_core()
         pending_info = get_pending_update_prompt_info()
         if pending_info is not None:
             should_stop = await _handle_update_on_launch(pending_info)
@@ -480,7 +637,13 @@ async def run(
                 return
 
     profiler.mark("agent.build.start")
-    agent = _build_agent(project_root=project_root, profiler=profiler)
+    agent = _build_agent(
+        project_root=project_root,
+        profiler=profiler,
+        extra_disallowed_tools=(
+            PRINT_MODE_DISALLOWED_TOOLS if print_message is not None else None
+        ),
+    )
     profiler.mark("agent.build.done")
 
     if rpc_stdio and resume_select and not resume_session_id:
@@ -494,6 +657,7 @@ async def run(
             cwd=project_root,
             profiler=profiler,
         )
+        StdioRPCBridge = _import_rpc_bridge()
         bridge = StdioRPCBridge(session)
         try:
             await bridge.run()
@@ -503,10 +667,16 @@ async def run(
 
     # --- Print mode branch ---
     if print_message is not None:
-        await _run_print_mode(agent, print_message, project_root=project_root)
+        await _run_print_mode(
+            agent,
+            print_message,
+            project_root=project_root,
+            output_format=print_output_format,
+        )
         return
 
     if resume_select and not resume_session_id:
+        select_resume_session_id = _import_resume_selector()
         selected_session_id = await select_resume_session_id(console, cwd=project_root)
         if not selected_session_id:
             return
@@ -515,8 +685,8 @@ async def run(
     # 在 _resolve_session 前安装 TUILoggingHandler，确保 session 初始化期间
     # 的 logger.warning()（如 user_instruction token 超限）能被 TUI 系统捕获，
     # 而非 fallthrough 到 Python lastResort StreamHandler 以原始文本输出到 stderr。
+    EventRenderer, setup_tui_logging, StatusBar, TerminalAgentTUI = _import_interactive_tui_components(profiler)
     renderer = EventRenderer(project_root=project_root)
-    from comate_cli.terminal_agent.logging_adapter import setup_tui_logging
     profiler.mark("logging.setup.start")
     logging_session = setup_tui_logging(renderer, project_root=project_root)
     profiler.mark("logging.setup.done")
@@ -550,6 +720,12 @@ async def run(
     profiler.mark("tui.init.done")
     tui.add_resume_history(mode)
     update_check_task: asyncio.Task[None] | None = None
+    (
+        _check_update_func,
+        _get_pending_update_prompt_info,
+        record_update_check_attempt,
+        should_check_for_update,
+    ) = _import_update_check_core()
     if should_check_for_update():
         # attempt 语义：先记录尝试时间，确保 interval 内最多发起一次网络检查
         record_update_check_attempt()

{comate_cli-0.7.7 → comate_cli-0.7.9}/comate_cli/terminal_agent/event_renderer.py

@@ -1128,15 +1128,17 @@ class EventRenderer:
         diff_lines: list[str] | None = None,
         model_name: str = "",
         subtitle: str | None = None,
+        file_path: str | None = None,
     ) -> None:
         """Append a tool result to history as a static entry (no timer).
 
         Args:
             signature: 工具签名，例如 "Read(path=xxx)"
             is_error: 是否为错误结果
-            diff_lines: optional diff lines for Edit
+            diff_lines: optional diff lines for Edit/Write
             model_name: model name for Agent tools (rendered dim)
             subtitle: optional subtitle rendered as `⎿ ...`
+            file_path: optional source path used for syntax highlighting diff body
         """
         sev: Literal["info", "warning", "error"] = "error" if is_error else "info"
         sub_sty: Literal["error", "warning", "dim"] = "dim"
@@ -1145,7 +1147,7 @@ class EventRenderer:
             if model_name:
                 text_obj.append(f" {BULLET_OPERATOR} {model_name}", style="dim")
             text_obj.append("\n")
-            text_obj.append(render_diff_text(diff_lines))
+            text_obj.append(render_diff_text(diff_lines, file_path=file_path))
             self._append_history_entry(
                 HistoryEntry(entry_type="tool_result", text=text_obj, severity="info", subtitle=subtitle)
             )