comate-cli 0.2.9__tar.gz → 0.3.1__tar.gz

{comate_cli-0.2.9 → comate_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.2.9
+Version: 0.3.1
 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.2.9 → comate_cli-0.3.1}/comate_cli/main.py

@@ -101,24 +101,37 @@ def _usage_text() -> str:
     return (
         "Usage:\n"
         "  comate [--rpc-stdio]\n"
+        "  comate -p <prompt>\n"
         "  comate resume [<session_id>] [--rpc-stdio]\n"
         "  comate mcp <subcommand> [options]"
     )
 
 
-def _parse_args(argv: list[str]) -> tuple[bool, str | None, bool]:
+def _parse_args(argv: list[str]) -> tuple[bool, str | None, bool, str | None]:
     rpc_stdio = False
+    print_mode = False
     positionals: list[str] = []
     for arg in argv:
         if arg == "--rpc-stdio":
             rpc_stdio = True
             continue
+        if arg in ("-p", "--print"):
+            print_mode = True
+            continue
         if arg.startswith("-"):
             raise _ArgumentError(f"Unknown option: {arg}")
         positionals.append(arg)
 
+    # -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
+
+    # Non -p mode: original logic
     if not positionals:
-        return rpc_stdio, None, False
+        return rpc_stdio, None, False, None
 
     command = positionals[0]
     if command != "resume":
@@ -129,10 +142,10 @@ def _parse_args(argv: list[str]) -> tuple[bool, str | None, bool]:
             raise _ArgumentError(
                 "resume without <session_id> does not support --rpc-stdio"
             )
-        return rpc_stdio, None, True
+        return rpc_stdio, None, True, None
 
     if len(positionals) == 2:
-        return rpc_stdio, positionals[1], False
+        return rpc_stdio, positionals[1], False, None
 
     raise _ArgumentError("resume accepts at most one <session_id>")
 
@@ -160,17 +173,30 @@ def main(argv: list[str] | None = None) -> None:
     from comate_cli.terminal_agent.app import run
 
     try:
-        rpc_stdio, resume_session_id, resume_select = _parse_args(run_argv)
+        rpc_stdio, resume_session_id, resume_select, print_prompt = _parse_args(run_argv)
     except _ArgumentError as exc:
         sys.stderr.write(f"{exc}\n{_usage_text()}\n")
         raise SystemExit(2) from exc
 
+    # 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()
+        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")
+            raise SystemExit(1)
+        print_message = "\n\n".join(parts)
+
     try:
         asyncio.run(
             run(
                 rpc_stdio=rpc_stdio,
                 resume_session_id=resume_session_id,
                 resume_select=resume_select,
+                print_message=print_message,
             )
         )
     except KeyboardInterrupt:

{comate_cli-0.2.9 → comate_cli-0.3.1}/comate_cli/terminal_agent/app.py

@@ -7,6 +7,7 @@ import logging
 import os
 import random
 import signal
+import sys
 import threading
 import time
 from collections.abc import Iterator
@@ -15,7 +16,7 @@ from pathlib import Path
 
 from rich.console import Console
 
-from comate_agent_sdk.agent import Agent, AgentConfig, ChatSession
+from comate_agent_sdk.agent import Agent, AgentConfig, ChatSession, TextEvent
 from comate_agent_sdk.context import EnvOptions
 from comate_agent_sdk.tools import tool
 
@@ -100,6 +101,8 @@ async def _check_update() -> str | None:
 
 def _flush_langfuse_if_configured() -> None:
     """Flush Langfuse pending events synchronously to prevent atexit thread-join errors on Ctrl+C."""
+    if not os.environ.get("LANGFUSE_PUBLIC_KEY"):
+        return
     try:
         from langfuse import get_client
         get_client().flush()
@@ -239,7 +242,7 @@ async def _preload_mcp_in_tui(session: ChatSession) -> None:
             return
         await preload_task
     except Exception as e:
-        logger.warning(f"MCP init failed: {e}", exc_info=True)
+        logger.debug(f"MCP init failed: {e}", exc_info=True)
         return
 
     mgr = runtime._mcp_manager
@@ -247,7 +250,7 @@ async def _preload_mcp_in_tui(session: ChatSession) -> None:
         return
 
     for alias, reason in mgr.failed_servers:
-        logger.warning(f"MCP server '{alias}' skipped: {reason}")
+        logger.debug(f"MCP server '{alias}' skipped: {reason}")
 
     loaded = mgr.tool_infos
     if loaded:
@@ -256,19 +259,50 @@ async def _preload_mcp_in_tui(session: ChatSession) -> None:
         logger.info(f"MCP Server loaded: {', '.join(aliases)} ({count} tools)")
 
 
+async def _run_print_mode(
+    agent: Agent,
+    message: str,
+    *,
+    project_root: Path,
+) -> 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)
+
+
 async def run(
     *,
     rpc_stdio: bool = False,
     resume_session_id: str | None = None,
     resume_select: bool = False,
+    print_message: str | None = None,
 ) -> None:
     project_root = _resolve_cli_project_root()
     preflight_result = await run_preflight_if_needed(
         console=console,
         project_root=project_root,
-        interactive=not rpc_stdio,
+        interactive=not rpc_stdio and print_message is None,
     )
     if preflight_result.should_abort_launch:
+        if print_message is not None:
+            raise SystemExit(1)
         return
 
     agent = _build_agent(project_root=project_root)
@@ -286,6 +320,11 @@ async def run(
             await _graceful_shutdown(session)
         return
 
+    # --- Print mode branch ---
+    if print_message is not None:
+        await _run_print_mode(agent, print_message, project_root=project_root)
+        return
+
     print_logo(console, project_root=project_root)
     console.print(f"[dim]💡 Tip: {random.choice(TIPS)}[/dim]")
 
@@ -321,6 +360,13 @@ async def run(
 
     async def _mcp_loader() -> None:
         await _preload_mcp_in_tui(session)
+        mgr = session.runtime._mcp_manager
+        if mgr and mgr.failed_servers:
+            aliases = [alias for alias, _ in mgr.failed_servers]
+            status_bar.show_transient(
+                f"⚠ MCP: {', '.join(aliases)} unavailable",
+                duration_s=5.0,
+            )
 
     usage_line: str | None = None
     active_session = session

{comate_cli-0.2.9 → comate_cli-0.3.1}/comate_cli/terminal_agent/event_renderer.py

@@ -508,6 +508,60 @@ class EventRenderer:
     def _append_tool_call(self, tool_name: str, args: dict[str, Any], tool_call_id: str) -> None:
         self._running_tools[tool_call_id] = self._make_running_tool(tool_name, args)
 
+    def _build_tool_subtitle(
+        self, tool_name: str, result: str, metadata: dict[str, Any] | None = None
+    ) -> str | None:
+        """Build a subtitle string for tool result display.
+
+        Returns None for tools that don't need a subtitle line.
+        """
+        import re
+
+        lowered = tool_name.lower()
+
+        if lowered == "skill":
+            return "Successfully loaded skill"
+
+        if lowered == "read":
+            lines = result.split("\n") if result else []
+            if lines and lines[-1] == "":
+                lines = lines[:-1]
+            return f"Read {len(lines)} lines"
+
+        if lowered == "write":
+            lines = result.split("\n") if result else []
+            if lines and lines[-1] == "":
+                lines = lines[:-1]
+            return f"Wrote {len(lines)} lines"
+
+        if lowered in ("edit", "multiedit"):
+            if not metadata:
+                return None
+            diff_lines = metadata.get("diff")
+            if not isinstance(diff_lines, list) or not diff_lines:
+                return None
+            added = sum(1 for line in diff_lines if line.startswith("+") and not line.startswith("+++"))
+            removed = sum(1 for line in diff_lines if line.startswith("-") and not line.startswith("---"))
+            a_unit = "line" if added == 1 else "lines"
+            r_unit = "line" if removed == 1 else "lines"
+            return f"Added {added} {a_unit}, removed {removed} {r_unit}"
+
+        if lowered == "bash":
+            match = re.search(r"Exit code (\d+)", result or "")
+            if match:
+                return f"Exit code {match.group(1)}"
+            return "Completed"
+
+        if lowered in ("glob", "ls"):
+            lines = [line for line in (result or "").splitlines() if line.strip()]
+            return f"Found {len(lines)} files"
+
+        if lowered == "grep":
+            lines = [line for line in (result or "").splitlines() if line.strip()]
+            return f"Found matches in {len(lines)} files"
+
+        return None
+
     def append_static_tool_result(
         self,
         signature: str,
@@ -585,14 +639,15 @@ class EventRenderer:
         metadata: dict[str, Any] | None = None,
     ) -> None:
         sev: Literal["info", "warning", "error"] = "error" if is_error else "info"
+        if is_error:
+            subtitle = _truncate(_one_line(result), self._tool_error_summary_max_len)
+        else:
+            subtitle = self._build_tool_subtitle(tool_name, str(result), metadata)
         state = self._running_tools.pop(tool_call_id, None)
         if state is None:
             display_name = resolve_display_tool_name(tool_name, {})
             signature = _tool_signature(display_name, "")
-            error_suffix = ""
-            if is_error:
-                error_suffix = f" · {_truncate(_one_line(result), self._tool_error_summary_max_len)}"
-            self._history.append(HistoryEntry(entry_type="tool_result", text=f"{signature}{error_suffix}", severity=sev))
+            self._history.append(HistoryEntry(entry_type="tool_result", text=signature, severity=sev, subtitle=subtitle))
             return
 
         if state.is_task:
@@ -628,10 +683,6 @@ class EventRenderer:
             signature = _tool_signature(display_name, summary)
             base = f"{signature}"
 
-        error_suffix = ""
-        if is_error:
-            error_suffix = f" · {_truncate(_one_line(result), self._tool_error_summary_max_len)}"
-
         # Render diff for Edit/MultiEdit if metadata contains diff lines
         if not is_error and metadata:
             diff_lines = metadata.get("diff")
@@ -640,20 +691,18 @@ class EventRenderer:
                 if isinstance(base, Text):
                     text_obj = base
                 else:
-                    text_obj = Text(f"{base}{error_suffix}")
+                    text_obj = Text(base)
                 text_obj.append("\n")
                 text_obj.append(self._render_diff_text(diff_lines, max_lines=self._diff_max_lines))
                 self._history.append(
-                    HistoryEntry(entry_type="tool_result", text=text_obj, severity="info")
+                    HistoryEntry(entry_type="tool_result", text=text_obj, severity="info", subtitle=subtitle)
                 )
                 return
 
         if isinstance(base, Text):
-            if error_suffix:
-                base.append(error_suffix)
-            self._history.append(HistoryEntry(entry_type="tool_result", text=base, severity=sev))
+            self._history.append(HistoryEntry(entry_type="tool_result", text=base, severity=sev, subtitle=subtitle))
         else:
-            self._history.append(HistoryEntry(entry_type="tool_result", text=f"{base}{error_suffix}", severity=sev))
+            self._history.append(HistoryEntry(entry_type="tool_result", text=base, severity=sev, subtitle=subtitle))
 
     @staticmethod
     def _render_diff_text(diff_lines: list[str], max_lines: int = 50) -> Text:

{comate_cli-0.2.9 → comate_cli-0.3.1}/comate_cli/terminal_agent/history_printer.py

@@ -10,6 +10,17 @@ from comate_cli.terminal_agent.message_style import ASSISTANT_PREFIX
 from comate_cli.terminal_agent.models import HistoryEntry
 
 
+def _render_subtitle_line(subtitle: str, *, error: bool = False) -> Text:
+    """Render a ⎿ subtitle line for tool results."""
+    line = Text()
+    line.append("  ⎿", style="#555555")
+    if error:
+        line.append(f" {subtitle}", style="bold red")
+    else:
+        line.append(f" {subtitle}", style="dim")
+    return line
+
+
 def _entry_prefix(entry: HistoryEntry) -> str:
     if entry.entry_type == "user":
         return ">"
@@ -93,12 +104,16 @@ def render_history_group(
             prefix_char = "✖" if entry.severity == "error" else "●"
             prefix_style = "bold red" if entry.severity == "error" else "bold green"
 
+            is_error = entry.severity == "error"
+
             if isinstance(entry.text, Text):
                 # Rich Text object — preserve styled content (e.g. colored diff)
                 line_text = Text()
                 line_text.append(f"{prefix_char} ", style=prefix_style)
                 line_text.append_text(entry.text)
                 renderables.append(line_text)
+                if entry.subtitle:
+                    renderables.append(_render_subtitle_line(entry.subtitle, error=is_error))
                 renderables.append(Text(""))
                 continue
 
@@ -114,6 +129,8 @@ def render_history_group(
                 line_text.append(line)
 
             renderables.append(line_text)
+            if entry.subtitle:
+                renderables.append(_render_subtitle_line(entry.subtitle, error=is_error))
             renderables.append(Text(""))
             continue
 

{comate_cli-0.2.9 → comate_cli-0.3.1}/comate_cli/terminal_agent/models.py

@@ -80,6 +80,7 @@ class HistoryEntry:
     entry_type: HistoryEntryType
     text: str | Text  # 支持普通字符串或 Rich Text 对象
     severity: Literal["info", "warning", "error"] = "info"
+    subtitle: str | None = None
 
 
 @dataclass(frozen=True)

{comate_cli-0.2.9 → comate_cli-0.3.1}/comate_cli/terminal_agent/status_bar.py

@@ -29,6 +29,8 @@ class StatusBar:
         self._context_left_pct: float = 100.0
         self._git_diff_stats: GitDiffStats | None = None
         self._git_diff_cache_time: float = 0.0
+        self._transient_message: str | None = None
+        self._transient_until: float | None = None
 
     @staticmethod
     def _resolve_model_name(session: ChatSession) -> str:
@@ -254,5 +256,30 @@ class StatusBar:
         fragments.append(("", " "))
         return fragments
 
+    def show_transient(self, message: str, duration_s: float = 5.0) -> None:
+        """Set a transient message that auto-clears after *duration_s* seconds."""
+        self._transient_message = message
+        self._transient_until = time.monotonic() + duration_s
+
+    def clear_transient_if_expired(self) -> bool:
+        """Check and clear expired transient message.
+
+        Returns True if the message was just cleared (state changed, needs repaint).
+        Returns False otherwise (no message, or message still active).
+        """
+        if self._transient_until is not None and time.monotonic() >= self._transient_until:
+            self._transient_message = None
+            self._transient_until = None
+            return True
+        return False
+
+    @property
+    def transient_message(self) -> str | None:
+        return self._transient_message
+
+    @property
+    def has_transient(self) -> bool:
+        return self._transient_message is not None
+
     def helper_toolbar(self) -> list[tuple[str, str]]:
         return []

{comate_cli-0.2.9 → comate_cli-0.3.1}/comate_cli/terminal_agent/tui.py

@@ -21,7 +21,7 @@ from prompt_toolkit.completion import (
     merge_completers,
 )
 from prompt_toolkit.filters import Condition, has_completions, has_focus
-from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.history import FileHistory, InMemoryHistory
 from prompt_toolkit.layout import FloatContainer, HSplit, Layout, Window
 from prompt_toolkit.layout.containers import ConditionalContainer
 from prompt_toolkit.layout.controls import FormattedTextControl
@@ -76,6 +76,38 @@ from comate_cli.terminal_agent.tui_parts import (
 logger = logging.getLogger(__name__)
 
 _TASK_POLL_INTERVAL_S = 2.0
+_INPUT_HISTORY_DIR = Path.home() / ".agent" / "history"
+_INPUT_HISTORY_MAX_ENTRIES = 200
+
+
+def _get_input_history_path(cwd: str) -> Path:
+    """Compute FileHistory path for a given cwd, ensuring parent dir exists."""
+    import hashlib
+    import re
+
+    slug = re.sub(r'[^a-zA-Z0-9_.\-]', '_', cwd).lstrip("_")
+    if len(slug) > 200:
+        hash_suffix = hashlib.sha1(cwd.encode()).hexdigest()[:8]
+        slug = f"{slug[:100]}_{hash_suffix}"
+    _INPUT_HISTORY_DIR.mkdir(parents=True, exist_ok=True)
+    return _INPUT_HISTORY_DIR / f"{slug}.txt"
+
+
+def _truncate_file_history(path: Path, max_entries: int = 200) -> None:
+    """Truncate a prompt_toolkit FileHistory file to at most max_entries."""
+    if not path.exists():
+        return
+    content = path.read_text()
+    if not content.strip():
+        return
+    # FileHistory format: entries are +prefixed line blocks separated by blank lines
+    blocks = content.split("\n\n")
+    # Filter out empty blocks
+    blocks = [b for b in blocks if b.strip()]
+    if len(blocks) <= max_entries:
+        return
+    kept = blocks[-max_entries:]
+    path.write_text("\n\n".join(kept) + "\n\n")
 
 
 class TerminalAgentTUI(
@@ -289,7 +321,7 @@ class TerminalAgentTUI(
             completer=self._input_completer,
             auto_suggest=self._slash_argument_hint,
             complete_while_typing=False,  # 通过 Tab/上下键手动触发补全
-            history=InMemoryHistory(),
+            history=self._create_input_history(),
             style="class:input.line",
             get_line_prefix=_input_line_prefix,
         )
@@ -452,6 +484,7 @@ class TerminalAgentTUI(
                 "status.mode.act": "bg:default #60a5fa bold",
                 "status.mode.plan": "bg:default #7AC9CA bold",
                 "status.hint": "bg:default #6B7280",
+                "status.transient": "bg:default italic fg:ansiyellow",
                 "input.placeholder": "bg:default #9CA3AF",
                 "auto-suggestion": "bg:default #94a3b8",
                 "queue": "bg:#1d222a #d8dee9",
@@ -609,6 +642,18 @@ class TerminalAgentTUI(
             return
         self._schedule_background(self._submit_user_message(queued))
 
+    def _create_input_history(self) -> FileHistory | InMemoryHistory:
+        """Create persistent FileHistory based on cwd, with fallback to InMemoryHistory."""
+        try:
+            session_cwd = getattr(self._session, "_cwd", None)
+            cwd = str(Path(session_cwd).expanduser().resolve()) if session_cwd else str(Path.cwd().resolve())
+            history_path = _get_input_history_path(cwd)
+            _truncate_file_history(history_path, _INPUT_HISTORY_MAX_ENTRIES)
+            return FileHistory(str(history_path))
+        except Exception:
+            logger.debug("Failed to create FileHistory, falling back to InMemoryHistory", exc_info=True)
+            return InMemoryHistory()
+
     def _input_placeholder_hint(self) -> str | None:
         if self._ui_mode != UIMode.NORMAL:
             return None
@@ -1098,6 +1143,12 @@ class TerminalAgentTUI(
                     else:
                         self._render_dirty = True
 
+                # 瞬态消息过期检查
+                if self._status_bar.clear_transient_if_expired():
+                    self._render_dirty = True
+                elif self._status_bar.has_transient:
+                    self._render_dirty = True
+
                 loading_line = self._renderer.loading_line().strip()
                 loading_changed = loading_line != self._last_loading_line
                 if loading_changed:
@@ -1233,10 +1284,13 @@ class TerminalAgentTUI(
                         timeout=self._mcp_init_gate_timeout_s,
                     )
                 except asyncio.TimeoutError:
-                    logger.warning(
+                    logger.debug(
                         "MCP init timed out after "
                         f"{self._mcp_init_gate_timeout_s:.1f}s; degrade and continue",
                     )
+                    self._status_bar.show_transient(
+                        "⚠ MCP: init timed out", duration_s=5.0,
+                    )
                     await self._cancel_task_with_timeout(
                         init_task,
                         timeout_s=self._mcp_init_cancel_timeout_s,
@@ -1250,7 +1304,7 @@ class TerminalAgentTUI(
                     )
                     return
                 except Exception as exc:
-                    logger.warning(f"MCP init failed in TUI bootstrap: {exc}", exc_info=True)
+                    logger.debug(f"MCP init failed in TUI bootstrap: {exc}", exc_info=True)
                 finally:
                     self._initializing = False
                     if self._queued_messages and not self._busy:

{comate_cli-0.2.9 → comate_cli-0.3.1}/comate_cli/terminal_agent/tui_parts/input_behavior.py

@@ -149,7 +149,7 @@ class InputBehaviorMixin:
         self._refresh_layers()
         self._schedule_background(self._submit_user_message(normalized))
 
-    def _clear_input_area(self) -> None:
+    def _clear_input_area(self, *, save_to_history: bool = False) -> None:
         self._clear_paste_state()
         self._last_input_len = 0
         self._last_input_text = ""
@@ -158,7 +158,14 @@ class InputBehaviorMixin:
         buffer.cancel_completion()
         self._suppress_input_change_hook = True
         try:
-            buffer.set_document(Document("", cursor_position=0), bypass_readonly=True)
+            if save_to_history:
+                buffer.reset(
+                    Document("", cursor_position=0), append_to_history=True
+                )
+            else:
+                buffer.set_document(
+                    Document("", cursor_position=0), bypass_readonly=True
+                )
         finally:
             self._suppress_input_change_hook = False
 
@@ -310,7 +317,7 @@ class InputBehaviorMixin:
 
         if self._input_area.buffer.complete_state is not None:
             self._input_area.buffer.cancel_completion()
-        self._clear_input_area()
+        self._clear_input_area(save_to_history=True)
 
         # busy 或 initializing 时：非斜杠命令 → 入队，斜杠命令 → 交由命令分发决定
         is_busy = self._busy or self._initializing

{comate_cli-0.2.9 → comate_cli-0.3.1}/comate_cli/terminal_agent/tui_parts/render_panels.py

@@ -49,6 +49,33 @@ class RenderPanelsMixin:
     def _status_text(self) -> list[tuple[str, str]]:
         width = self._terminal_width()
 
+        # 瞬态消息优先于 mode 显示
+        transient = self._status_bar.transient_message
+        if transient:
+            # 右栏：model | ~branch / X% left (不变)
+            right_text = self._status_bar.info_status_text()
+            if self._busy or self._initializing:
+                git_frags = []
+            else:
+                git_frags = self._status_bar.git_diff_fragments()
+
+            right_w = sum(get_cwidth(c) for c in right_text)
+            if git_frags:
+                right_w += 2 + sum(get_cwidth(c) for _, t in git_frags for c in t)
+
+            left_w = sum(get_cwidth(c) for c in transient)
+            padding = max(1, width - left_w - right_w - 2)
+
+            frags: list[tuple[str, str]] = [
+                ("class:status.transient", transient),
+                ("class:status", " " * padding),
+                ("class:status", right_text),
+            ]
+            if git_frags:
+                frags.append(("class:status", "  "))
+                frags.extend(git_frags)
+            return frags
+
         # 左栏：mode 图标 + 提示文字
         mode = self._status_bar.get_mode()
         hint_text = "(shift+tab to cycle)"
@@ -576,7 +603,7 @@ class RenderPanelsMixin:
                 if clipped.startswith("✓ "):
                     symbol, text = "✓", clipped[2:]
                     symbol_style = "fg:#86EFAC"
-                    text_style = "fg:#6B7280 strike"
+                    text_style = "fg:#4B5563 strike"
                 elif clipped.startswith("◼ "):
                     symbol, text = "◼", clipped[2:]
                     symbol_style = "fg:#F97316"

{comate_cli-0.2.9 → comate_cli-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.2.9"
+version = "0.3.1"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
 requires-python = ">=3.11"

{comate_cli-0.2.9 → comate_cli-0.3.1}/tests/test_app_mcp_preload.py

@@ -9,7 +9,7 @@ from comate_cli.terminal_agent.app import _preload_mcp_in_tui
 
 class _FakeRuntime:
     def __init__(self) -> None:
-        self.options = types.SimpleNamespace(mcp_enabled=True)
+        self.config = types.SimpleNamespace(mcp_enabled=True)
         self._mcp_manager = types.SimpleNamespace(
             failed_servers=[],
             tool_infos=[types.SimpleNamespace(server_alias="ctx7")],