comate-cli 0.3.2__tar.gz → 0.3.4__tar.gz

{comate_cli-0.3.2 → comate_cli-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.3.2
+Version: 0.3.4
 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.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/app.py

@@ -334,6 +334,13 @@ async def run(
             return
         resume_session_id = selected_session_id
 
+    # 在 _resolve_session 前安装 TUILoggingHandler，确保 session 初始化期间
+    # 的 logger.warning()（如 user_instruction token 超限）能被 TUI 系统捕获，
+    # 而非 fallthrough 到 Python lastResort StreamHandler 以原始文本输出到 stderr。
+    renderer = EventRenderer(project_root=project_root)
+    from comate_cli.terminal_agent.logging_adapter import setup_tui_logging
+    logging_session = setup_tui_logging(renderer)
+
     session, mode = _resolve_session(agent, resume_session_id, cwd=project_root)
 
     # 版本检查：带超时，不阻塞启动
@@ -349,12 +356,6 @@ async def run(
     if mode == "resume":
         await status_bar.refresh()
 
-    renderer = EventRenderer(project_root=project_root)
-
-    # 配置 TUI logging handler（将 SDK 日志输出到 TUI）
-    from comate_cli.terminal_agent.logging_adapter import setup_tui_logging
-    logging_session = setup_tui_logging(renderer)
-
     tui = TerminalAgentTUI(session, status_bar, renderer)
     tui.add_resume_history(mode)
 

comate_cli-0.3.4/comate_cli/terminal_agent/codenames.py

@@ -0,0 +1,15 @@
+"""Version codenames — one entry per memorable release."""
+
+from __future__ import annotations
+
+CODENAMES: dict[str, str] = {
+    "0.3.4": "",
+    "0.3.3": "Update for My Brothers",
+    "0.3.2": "We are with Ukraine",
+}
+
+
+def get_codename(ver: str) -> str | None:
+    """Return codename for a version string like '0.3.2' or 'v0.3.2'."""
+    stripped = ver.lstrip("v")
+    return CODENAMES.get(stripped)

{comate_cli-0.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/custom_slash_commands.py

@@ -21,7 +21,7 @@ DEFAULT_BASH_TIMEOUT_SECONDS = 10.0
 _COMMAND_NAME_PATTERN = re.compile(r"^[a-zA-Z0-9_-]+$")
 _ARG_PLACEHOLDER_PATTERN = re.compile(r"\$ARGUMENTS\[(\d+)\]|\$(\d+)|\$ARGUMENTS")
 _BASH_PATTERN = re.compile(r"!\`([^`\n]+)\`")
-_FILE_REF_PATTERN = re.compile(r"(?<!\S)@([^\s]+)")
+FILE_REF_PATTERN = re.compile(r"(?<!\S)@([^\s]+)")
 _MARKER_PREFIX = "<<__COMATE_CUSTOM_BLOCK_"
 _MARKER_SUFFIX = "__>>"
 
@@ -354,7 +354,7 @@ def _replace_file_reference_markers(
     cursor = 0
     marker_index = len(marker_map)
 
-    for match in _FILE_REF_PATTERN.finditer(text):
+    for match in FILE_REF_PATTERN.finditer(text):
         parts.append(text[cursor : match.start()])
         raw_path = match.group(1).strip()
         if not raw_path:

comate_cli-0.3.4/comate_cli/terminal_agent/error_display.py

@@ -0,0 +1,83 @@
+"""Unified error formatter for terminal agent."""
+from __future__ import annotations
+
+import re
+
+
+def format_error(exc: Exception) -> tuple[str, str, str]:
+    """Convert exception to user-friendly (message, transient_summary, severity).
+
+    - message: full error text for scrollback (plain English, no icons)
+    - transient_summary: short text for status bar transient notification
+    - severity: "error" or "warning"
+    """
+    exc_type = type(exc).__name__
+    exc_msg = str(exc)
+
+    # LLM Provider errors
+    if exc_type == "ModelRateLimitError":
+        return "Rate limit exceeded", "Rate limited", "warning"
+
+    if exc_type == "ModelProviderError":
+        code = getattr(exc, "status_code", None)
+
+        # Context size exceeded (400 with specific body pattern)
+        if code == 400:
+            ctx = _parse_context_size_error(exc_msg)
+            if ctx:
+                return (
+                    f"Request ({ctx[0]} tokens) exceeds context limit ({ctx[1]})",
+                    "Context limit exceeded",
+                    "error",
+                )
+            return f"API error: {_truncate(exc_msg, 80)}", "API error", "error"
+
+        if code == 401:
+            return "Invalid or expired API key", "Auth failed", "error"
+        if code == 403:
+            return "Access denied to this model", "Access denied", "error"
+        if code == 404:
+            return "Model not found or invalid API path", "Model not found", "error"
+        if code and code >= 500:
+            return f"Server error ({code})", "Server error", "warning"
+        return f"API error: {_truncate(exc_msg, 80)}", "API error", "error"
+
+    # Session errors
+    if exc_type == "ChatSessionClosedError":
+        return "Session closed", "Session closed", "error"
+
+    # Network errors (heuristic)
+    lower_msg = exc_msg.lower()
+    if "timeout" in lower_msg or "timed out" in lower_msg:
+        return "Request timed out", "Timed out", "warning"
+    if "connection" in lower_msg:
+        return "Connection failed", "Connection failed", "error"
+
+    # Generic fallback
+    return f"Error: {_truncate(exc_msg, 80)}", "Error occurred", "error"
+
+
+def _parse_context_size_error(msg: str) -> tuple[str, str] | None:
+    """Extract (prompt_tokens, ctx_limit) from context size error body.
+
+    Matches patterns like 'n_prompt_tokens': 35099, 'n_ctx': 32768
+    or 'request (35099 tokens) exceeds the available context size (32768 tokens)'.
+    """
+    m = re.search(r"n_prompt_tokens['\"]?:\s*(\d+)", msg)
+    n = re.search(r"n_ctx['\"]?:\s*(\d+)", msg)
+    if m and n:
+        return m.group(1), n.group(1)
+
+    m2 = re.search(r"request\s*\((\d+)\s*tokens?\)", msg, re.IGNORECASE)
+    n2 = re.search(r"context\s*size\s*\((\d+)\s*tokens?\)", msg, re.IGNORECASE)
+    if m2 and n2:
+        return m2.group(1), n2.group(1)
+
+    if "exceed_context_size_error" in msg:
+        return None  # Type matches but can't parse numbers — fall through to generic 400
+
+    return None
+
+
+def _truncate(s: str, max_len: int) -> str:
+    return s[:max_len] + "..." if len(s) > max_len else s

{comate_cli-0.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/event_renderer.py

@@ -34,6 +34,7 @@ from rich.text import Text
 from comate_cli.terminal_agent.models import HistoryEntry, LoadingState
 from comate_cli.terminal_agent.tool_view import summarize_tool_args, resolve_display_tool_name, should_show_tool_in_scrollback
 from comate_cli.terminal_agent.env_utils import read_env_int
+from comate_cli.terminal_agent.custom_slash_commands import FILE_REF_PATTERN
 
 logger = logging.getLogger(__name__)
 
@@ -41,6 +42,7 @@ _DEFAULT_TOOL_ERROR_SUMMARY_MAX_LEN = 160
 _DEFAULT_TOOL_PANEL_MAX_LINES = 4
 _DEFAULT_TASK_PANEL_MAX_LINES = 6
 _RECENT_TEAM_EVENT_CACHE_SIZE = 128
+_FILE_REF_MAX_COUNT_BYTES = 10 * 1024 * 1024  # 10 MB
 
 
 def _truncate(content: str, max_len: int = 120) -> str:
@@ -205,6 +207,32 @@ class EventRenderer:
             return
         self._flush_assistant_segment()
         self._history.append(HistoryEntry(entry_type="user", text=normalized))
+        self._maybe_append_file_ref_hint(normalized)
+
+    def _maybe_append_file_ref_hint(self, text: str) -> None:
+        """Append a dim ⎿ hint for the first valid @path reference."""
+        if self._project_root is None:
+            return
+        for match in FILE_REF_PATTERN.finditer(text):
+            raw_path = match.group(1)
+            candidate = self._project_root / raw_path
+            try:
+                if candidate.is_dir():
+                    self._history.append(HistoryEntry(entry_type="file_ref", text=f"Listed directory {raw_path}"))
+                    return
+                if candidate.is_file():
+                    hint = f"Read {raw_path}"
+                    if candidate.stat().st_size <= _FILE_REF_MAX_COUNT_BYTES:
+                        try:
+                            with open(candidate, "rb") as fh:
+                                line_count = sum(1 for _ in fh)
+                            hint += f"  ({line_count} lines)"
+                        except OSError:
+                            pass
+                    self._history.append(HistoryEntry(entry_type="file_ref", text=hint))
+                    return
+            except OSError:
+                continue
 
     def close(self) -> None:
         return

{comate_cli-0.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/history_printer.py

@@ -13,7 +13,7 @@ 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")
+    line.append("  ⎿ ", style="#555555")
     if error:
         line.append(f" {subtitle}", style="bold red")
     else:
@@ -85,21 +85,25 @@ def render_history_group(
         # System entries: 按 severity 区分视觉样式
         if entry.entry_type == "system":
             if entry.severity == "error":
-                prefix_char = "✖"
-                prefix_style = "#FF9FC6"
+                text_style = "bold #FF6B6B"
             elif entry.severity == "warning":
-                prefix_char = "⚠"
-                prefix_style = "#B8B630"
+                text_style = "#E8B830"
             else:
-                prefix_char = "•"
-                prefix_style = "dim"
+                text_style = "dim"
             line_text = Text()
-            line_text.append(f"{prefix_char} ", style=prefix_style)
-            line_text.append(str(entry.text), style=prefix_style)
+            line_text.append(str(entry.text), style=text_style)
             renderables.append(line_text)
             renderables.append(Text(""))
             continue
 
+        # File reference hint: reuse subtitle style, attached to preceding user message
+        if entry.entry_type == "file_ref":
+            if renderables and isinstance(renderables[-1], Text) and not renderables[-1].plain:
+                renderables.pop()
+            renderables.append(_render_subtitle_line(str(entry.text)))
+            renderables.append(Text(""))
+            continue
+
         if entry.entry_type == "tool_result":
             prefix_char = "✖" if entry.severity == "error" else "●"
             prefix_style = "bold red" if entry.severity == "error" else "bold green"

{comate_cli-0.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/logo.py

@@ -8,6 +8,8 @@ from rich.text import Text
 
 from comate_agent_sdk.utils.paths import PathInput, normalize_path_input
 
+from .codenames import get_codename
+
 _LOGO_LINES: tuple[str, ...] = (
     "",
     "  ██████╗ ██████╗ ███╗   ███╗ █████╗ ████████╗███████╗",
@@ -59,6 +61,7 @@ def print_logo(console: Console, *, project_root: PathInput | None = None) -> No
     line_count = len(_LOGO_LINES)
 
     ver = _resolve_version()
+    codename = get_codename(ver)
     logo_text = Text()
     for idx, line in enumerate(_LOGO_LINES):
         ratio = idx / max(line_count - 1, 1)
@@ -66,6 +69,13 @@ def print_logo(console: Console, *, project_root: PathInput | None = None) -> No
         logo_text.append(line, style=f"bold rgb({r},{g},{b})")
         if idx == line_count - 1:
             logo_text.append(f"  {ver}", style="dim")
+            if codename:
+                er, eg, eb = end_rgb
+                logo_text.append(": ", style="dim")
+                logo_text.append(
+                    codename,
+                    style=f"italic rgb({er},{eg},{eb})",
+                )
         if idx < line_count - 1:
             logo_text.append("\n")
 

{comate_cli-0.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/models.py

@@ -8,7 +8,7 @@ if TYPE_CHECKING:
     from rich.text import Text
 
 ToolStatus = Literal["running", "success", "error"]
-HistoryEntryType = Literal["user", "assistant", "tool_call", "tool_result", "system", "thinking", "elapsed"]
+HistoryEntryType = Literal["user", "assistant", "tool_call", "tool_result", "system", "thinking", "elapsed", "file_ref"]
 
 
 class LoadingStateType(Enum):

comate_cli-0.3.4/comate_cli/terminal_agent/path_context_hint.py

@@ -0,0 +1,88 @@
+"""Generate lightweight path-context hints for @path mentions in user messages."""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from comate_cli.terminal_agent.custom_slash_commands import FILE_REF_PATTERN
+
+logger = logging.getLogger(__name__)
+
+_MAX_MENTIONS = 10
+_LINE_COUNT_MAX_BYTES = 256 * 1024  # 256KB
+
+
+def build_path_context_hint(text: str, project_root: Path) -> str | None:
+    """Parse @path mentions from text and return a hint string, or None if no valid paths."""
+    resolved_root = project_root.expanduser().resolve()
+    matches = list(FILE_REF_PATTERN.finditer(text))
+    if not matches:
+        return None
+
+    hint_lines: list[str] = []
+    for match in matches[:_MAX_MENTIONS]:
+        raw_path = match.group(1).strip()
+        if not raw_path:
+            continue
+
+        candidate = (resolved_root / raw_path).resolve()
+        # Safety: skip paths that escape project root
+        try:
+            candidate.relative_to(resolved_root)
+        except ValueError:
+            continue
+
+        try:
+            if candidate.is_dir():
+                hint_lines.append(_describe_dir(raw_path, candidate))
+            elif candidate.is_file():
+                hint_lines.append(_describe_file(raw_path, candidate))
+            else:
+                # Not found — only include if path looks like a filesystem path
+                if "/" in raw_path or "." in raw_path:
+                    hint_lines.append(f"- @{raw_path} → not found")
+        except OSError:
+            continue
+
+    if not hint_lines:
+        return None
+
+    return "<system_reminder>\n" + "\n".join(hint_lines) + "\n</system_reminder>"
+
+
+def _describe_dir(raw_path: str, candidate: Path) -> str:
+    try:
+        entries = list(candidate.iterdir())
+    except OSError:
+        return f"- @{raw_path} → directory (unreadable)"
+
+    if not entries:
+        return f"- @{raw_path} → directory (empty)"
+
+    files = sum(1 for e in entries if e.is_file())
+    subdirs = sum(1 for e in entries if e.is_dir())
+
+    parts: list[str] = []
+    if files > 0:
+        parts.append(f"{files} file{'s' if files != 1 else ''}")
+    if subdirs > 0:
+        parts.append(f"{subdirs} subdir{'s' if subdirs != 1 else ''}")
+    return f"- @{raw_path} → directory ({', '.join(parts)})" if parts else f"- @{raw_path} → directory ({len(entries)} entries)"
+
+
+def _describe_file(raw_path: str, candidate: Path) -> str:
+    suffix = candidate.suffix or "no ext"
+    try:
+        size = candidate.stat().st_size
+    except OSError:
+        return f"- @{raw_path} → file ({suffix})"
+
+    if size > _LINE_COUNT_MAX_BYTES:
+        return f"- @{raw_path} → file ({suffix}, ~large)"
+
+    try:
+        with open(candidate, "rb") as fh:
+            line_count = sum(1 for _ in fh)
+        return f"- @{raw_path} → file ({suffix}, {line_count} lines)"
+    except OSError:
+        return f"- @{raw_path} → file ({suffix})"

{comate_cli-0.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/preflight.py

@@ -162,9 +162,9 @@ PROVIDER_PRESETS: tuple[ProviderPreset, ...] = (
         provider="minimax",
         base_url="https://api.minimaxi.com/anthropic",
         models={
-            "LOW": "MiniMax-M2.5",
-            "MID": "MiniMax-M2.5",
-            "HIGH": "MiniMax-M2.5",
+            "LOW": "MiniMax-M2.7",
+            "MID": "MiniMax-M2.7",
+            "HIGH": "MiniMax-M2.7",
         },
     ),
     ProviderPreset(

{comate_cli-0.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/status_bar.py

@@ -30,6 +30,7 @@ class StatusBar:
         self._git_diff_stats: GitDiffStats | None = None
         self._git_diff_cache_time: float = 0.0
         self._transient_message: str | None = None
+        self._transient_severity: str = "info"
         self._transient_until: float | None = None
 
     @staticmethod
@@ -258,9 +259,11 @@ class StatusBar:
         fragments.append(("", " "))
         return fragments
 
-    def show_transient(self, message: str, duration_s: float = 5.0) -> None:
+    def show_transient(self, message: str, duration_s: float = 5.0,
+                       severity: str = "info") -> None:
         """Set a transient message that auto-clears after *duration_s* seconds."""
         self._transient_message = message
+        self._transient_severity = severity
         self._transient_until = time.monotonic() + duration_s
 
     def clear_transient_if_expired(self) -> bool:
@@ -271,6 +274,7 @@ class StatusBar:
         """
         if self._transient_until is not None and time.monotonic() >= self._transient_until:
             self._transient_message = None
+            self._transient_severity = "info"
             self._transient_until = None
             return True
         return False
@@ -283,5 +287,9 @@ class StatusBar:
     def has_transient(self) -> bool:
         return self._transient_message is not None
 
+    @property
+    def transient_severity(self) -> str:
+        return self._transient_severity if self._transient_message else "info"
+
     def helper_toolbar(self) -> list[tuple[str, str]]:
         return []

{comate_cli-0.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/tui.py

@@ -47,6 +47,7 @@ from comate_cli.terminal_agent.animations import (
 from comate_cli.terminal_agent.env_utils import read_env_float, read_env_int
 from comate_cli.terminal_agent.event_renderer import EventRenderer
 from comate_cli.terminal_agent.mention_completer import LocalFileMentionCompleter
+from comate_cli.terminal_agent.path_context_hint import build_path_context_hint
 from comate_cli.terminal_agent.custom_slash_commands import (
     CustomSlashCommand,
     discover_custom_slash_commands,
@@ -450,10 +451,18 @@ class TerminalAgentTUI(
 
         self._main_container = HSplit(
             [
-                self._todo_container,
                 self._loading_container,
+                ConditionalContainer(
+                    content=Window(height=1, style="class:loading"),
+                    filter=Condition(
+                        lambda: self._renderer.has_running_tools()
+                        and self._renderer.has_active_todos()
+                    ),
+                ),
+                self._todo_container,
                 Window(height=1, style="class:loading"),
                 self._diff_panel_container,
+                Window(height=1, style="class:input.separator"),
                 self._queue_container,
                 Window(height=1, char="─", style="class:input.separator"),
                 self._input_container,
@@ -485,6 +494,8 @@ class TerminalAgentTUI(
                 "status.mode.plan": "bg:default #7AC9CA bold",
                 "status.hint": "bg:default #6B7280",
                 "status.transient": "bg:default italic fg:ansiyellow",
+                "status.transient.error": "bg:default bold fg:ansired",
+                "status.transient.warning": "bg:default italic fg:ansiyellow",
                 "input.placeholder": "bg:default #9CA3AF",
                 "auto-suggestion": "bg:default #94a3b8",
                 "queue": "bg:#1d222a #d8dee9",
@@ -732,6 +743,24 @@ class TerminalAgentTUI(
         self._render_dirty = True
         self._invalidate()
 
+    async def _handle_error(self, exc: Exception) -> None:
+        """Unified error cleanup: format → display → stop animation → reset state."""
+        from comate_cli.terminal_agent.error_display import format_error
+
+        message, transient_summary, severity = format_error(exc)
+
+        self._renderer.append_system_message(message, severity=severity)
+        self._renderer.interrupt_turn()
+        await self._animation_controller.shutdown()
+        self._status_bar.show_transient(transient_summary, severity=severity)
+        self._last_turn_user_preview = None
+        self._append_run_elapsed_to_history(stop_reason="error")
+        self._run_start_time = None
+        self._interrupt_requested_at = None
+        self._set_busy(False)
+        await self._status_bar.refresh()
+        self._refresh_layers()
+
     async def _submit_user_message(
         self,
         text: str,
@@ -771,25 +800,20 @@ class TerminalAgentTUI(
 
         # 启动提交动画
         await self._animation_controller.start()
+
+        # @path context hint injection
+        try:
+            hint = build_path_context_hint(text, Path.cwd())
+            if hint is not None:
+                self._session._agent._context.add_system_reminder_message(hint)
+        except Exception:
+            logger.debug("path context hint injection failed", exc_info=True)
+
         try:
             await self._session.send(text)
         except Exception as exc:
             logger.exception("send failed")
-            from comate_cli.terminal_agent.error_display import format_error
-
-            error_msg, suggestion = format_error(exc)
-            self._renderer.append_system_message(error_msg, severity="error")
-            if suggestion:
-                self._renderer.append_system_message(f"💡 {suggestion}")
-            self._renderer.interrupt_turn()
-            await self._animation_controller.shutdown()
-            self._last_turn_user_preview = None
-            self._append_run_elapsed_to_history(stop_reason="error")
-            self._run_start_time = None
-            self._interrupt_requested_at = None
-            self._set_busy(False)
-            await self._status_bar.refresh()
-            self._refresh_layers()
+            await self._handle_error(exc)
 
     async def _consume_event_stream(self) -> None:
         waiting_for_input = False
@@ -899,12 +923,7 @@ class TerminalAgentTUI(
             raise
         except Exception as exc:
             logger.exception("session event pump failed")
-            self._renderer.append_system_message(
-                f"会话事件流异常终止: {exc}",
-                severity="error",
-            )
-            self._set_busy(False)
-            self._refresh_layers()
+            await self._handle_error(exc)
 
     def _open_plan_approval_menu(self, approval: dict[str, str]) -> None:
         plan_path = str(approval.get("plan_path", "")).strip()

{comate_cli-0.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/tui_parts/input_behavior.py

@@ -322,7 +322,7 @@ class InputBehaviorMixin:
         # busy 或 initializing 时：非斜杠命令 → 入队，斜杠命令 → 交由命令分发决定
         is_busy = self._busy or self._initializing
         if is_busy:
-            if display_text.lstrip().startswith("/"):
+            if raw_text.startswith("/"):
                 normalized_slash = display_text.strip()
                 parsed = parse_slash_command_call(normalized_slash)
                 registry = getattr(self, "_slash_registry", None)
@@ -351,7 +351,7 @@ class InputBehaviorMixin:
                 self._schedule_background(self._execute_command(normalized_slash))
                 return
 
-            if not display_text.lstrip().startswith("/"):
+            if not raw_text.startswith("/"):
                 queue_size = len(self._queued_messages)
                 if queue_size >= int(self._message_queue_max_size):
                     self._renderer.append_system_message(
@@ -364,7 +364,7 @@ class InputBehaviorMixin:
                 self._invalidate()
                 return
 
-        if display_text.lstrip().startswith("/"):
+        if raw_text.startswith("/"):
             self._schedule_background(self._execute_command(display_text.strip()))
             return
 

{comate_cli-0.3.2 → comate_cli-0.3.4}/comate_cli/terminal_agent/tui_parts/render_panels.py

@@ -67,7 +67,13 @@ class RenderPanelsMixin:
             padding = max(1, width - left_w - right_w - 2)
 
             frags: list[tuple[str, str]] = [
-                ("class:status.transient", transient),
+                (
+                    {
+                        "error": "class:status.transient.error",
+                        "warning": "class:status.transient.warning",
+                    }.get(self._status_bar.transient_severity, "class:status.transient"),
+                    transient,
+                ),
                 ("class:status", " " * padding),
                 ("class:status", right_text),
             ]

{comate_cli-0.3.2 → comate_cli-0.3.4}/pyproject.toml

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