comate-cli 0.7.4__tar.gz → 0.7.6__tar.gz

{comate_cli-0.7.4 → comate_cli-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.4
+Version: 0.7.6
 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
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.11
+Requires-Python: <3.14,>=3.11
 Requires-Dist: charset-normalizer==3.4.7
 Requires-Dist: comate-agent-sdk<0.9.0,>=0.8.0a1
 Requires-Dist: concurrent-log-handler>=0.9.25

{comate_cli-0.7.4 → comate_cli-0.7.6}/comate_cli/terminal_agent/app.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
-import random
+import random  # noqa: F401 - tests patch this module-level import for deterministic startup tips.
 import signal
 import sys
 import threading
@@ -42,6 +42,7 @@ from comate_cli.terminal_agent.update_check import (
 
 console = Console()
 logger = logging.getLogger(__name__)
+_UPDATE_CHECK_DELAY_S = 1.0
 
 
 def _resolve_cli_project_root() -> Path:
@@ -49,8 +50,14 @@ def _resolve_cli_project_root() -> Path:
     return Path.cwd().expanduser().resolve()
 
 
-async def _check_update() -> UpdateInfo | None:
-    return await check_update(log=logger)
+async def _check_update(*, profiler: StartupProfiler | None = None) -> UpdateInfo | None:
+    if profiler is not None:
+        profiler.mark("impl.start")
+    try:
+        return await check_update(log=logger, profiler=profiler)
+    finally:
+        if profiler is not None:
+            profiler.mark("impl.done")
 
 
 async def _handle_update_on_launch(info: UpdateInfo) -> bool:
@@ -63,7 +70,7 @@ async def _handle_update_on_launch(info: UpdateInfo) -> bool:
         if decision == UpdatePromptDecision.SKIP:
             return False
         if decision == UpdatePromptDecision.SHOW_HINT:
-            console.print(format_update_hint(info))
+            console.print(f"[dim]{format_update_hint(info)}[/]")
             mark_update_seen(info)
             return False
 
@@ -109,7 +116,10 @@ def _schedule_update_check_on_launch(
     async def _run() -> None:
         try:
             profiler.mark("update_check.start")
-            update_info = await _check_update()
+            profiler.mark("update_check.delay.start")
+            await asyncio.sleep(_UPDATE_CHECK_DELAY_S)
+            profiler.mark("update_check.delay.done")
+            update_info = await _check_update(profiler=profiler.child("update_check"))
             profiler.mark("update_check.done")
             if update_info is not None:
                 await _handle_background_update_on_launch(
@@ -228,35 +238,64 @@ async def add(a: int, b: int) -> int:
     return a + b
 
 
-def _build_agent(*, project_root: Path | None = None) -> Agent:
+def _build_agent(
+    *,
+    project_root: Path | None = None,
+    profiler: StartupProfiler | None = None,
+) -> Agent:
     from comate_agent_sdk.agent.compaction import CompactionConfig
     from comate_cli.terminal_agent.config import store
 
     resolved_project_root = project_root or _resolve_cli_project_root()
+    if profiler is not None:
+        profiler.mark("agent.config.load.start")
     snapshot = store.load()
-
-    return Agent(
-        config=AgentConfig(
-            role="software_engineering",
-            cwd=resolved_project_root,
-            env_options=EnvOptions(system_env=True, git_env=True),
-            use_streaming_task=True,
-            include_cost=bool(getattr(snapshot, "token_cost_enabled", False)),
-            memory_background_enabled=snapshot.memory_background_enabled,
-            memory_dreaming_enabled=snapshot.memory_dreaming_enabled,
-            compaction=CompactionConfig(
-                threshold_ratio=snapshot.compaction_threshold_ratio,
-            ),
-        )
+    if profiler is not None:
+        profiler.mark("agent.config.load.done")
+
+    agent_config = AgentConfig(
+        role="software_engineering",
+        cwd=resolved_project_root,
+        env_options=EnvOptions(system_env=True, git_env=True),
+        use_streaming_task=True,
+        include_cost=bool(getattr(snapshot, "token_cost_enabled", False)),
+        memory_background_enabled=snapshot.memory_background_enabled,
+        memory_dreaming_enabled=snapshot.memory_dreaming_enabled,
+        compaction=CompactionConfig(
+            threshold_ratio=snapshot.compaction_threshold_ratio,
+        ),
     )
+    if profiler is not None:
+        profiler.mark("agent.construct.start")
+    try:
+        return Agent(config=agent_config)
+    finally:
+        if profiler is not None:
+            profiler.mark("agent.construct.done")
 
 
 def _resolve_session(
-    agent: Agent, resume_session_id: str | None, *, cwd: Path | None = None
+    agent: Agent,
+    resume_session_id: str | None,
+    *,
+    cwd: Path | None = None,
+    profiler: StartupProfiler | None = None,
 ) -> tuple[ChatSession, str]:
     if resume_session_id:
-        return ChatSession.resume(agent, session_id=resume_session_id, cwd=cwd), "resume"
-    return ChatSession(agent, cwd=cwd), "new"
+        if profiler is not None:
+            profiler.mark("session.resume.construct.start")
+        try:
+            return ChatSession.resume(agent, session_id=resume_session_id, cwd=cwd), "resume"
+        finally:
+            if profiler is not None:
+                profiler.mark("session.resume.construct.done")
+    if profiler is not None:
+        profiler.mark("session.new.construct.start")
+    try:
+        return ChatSession(agent, cwd=cwd), "new"
+    finally:
+        if profiler is not None:
+            profiler.mark("session.new.construct.done")
 
 
 def _format_exit_usage_line(usage: object) -> str:
@@ -287,23 +326,47 @@ def _format_resume_hint(session_id: str | None) -> str | None:
     )
 
 
-async def _preload_mcp_in_tui(session: ChatSession) -> None:
+async def _preload_mcp_in_tui(
+    session: ChatSession,
+    *,
+    profiler: StartupProfiler | None = None,
+) -> None:
     """在 TUI 内异步加载 MCP，初始化阶段不输出 scrollback 文案。"""
+    if profiler is not None:
+        profiler.mark("preload.start")
     runtime = session.runtime
     if not bool(runtime.config.mcp_enabled):
+        if profiler is not None:
+            profiler.mark("preload.skip_disabled")
         return
 
     try:
+        if profiler is not None:
+            profiler.mark("start_preload.start")
         preload_task = runtime.start_mcp_preload()
+        if profiler is not None:
+            profiler.mark("start_preload.done")
         if preload_task is None:
+            if profiler is not None:
+                profiler.mark("preload.no_task")
             return
+        if profiler is not None:
+            profiler.mark("await_preload.start")
         await preload_task
+        if profiler is not None:
+            profiler.mark("await_preload.done")
     except Exception as e:
         logger.debug(f"MCP init failed: {e}", exc_info=True)
+        if profiler is not None:
+            profiler.mark("preload.failed")
         return
 
+    if profiler is not None:
+        profiler.mark("inspect_manager.start")
     mgr = runtime._mcp_manager
     if mgr is None:
+        if profiler is not None:
+            profiler.mark("inspect_manager.no_manager")
         return
 
     for alias, reason in mgr.failed_servers:
@@ -314,6 +377,8 @@ async def _preload_mcp_in_tui(session: ChatSession) -> None:
         count = len(loaded)
         aliases = sorted({i.server_alias for i in loaded})
         logger.info(f"MCP Server loaded: {', '.join(aliases)} ({count} tools)")
+    if profiler is not None:
+        profiler.mark("inspect_manager.done")
 
 
 async def _run_print_mode(
@@ -404,7 +469,7 @@ async def run(
                 return
 
     profiler.mark("agent.build.start")
-    agent = _build_agent(project_root=project_root)
+    agent = _build_agent(project_root=project_root, profiler=profiler)
     profiler.mark("agent.build.done")
 
     if rpc_stdio and resume_select and not resume_session_id:
@@ -412,7 +477,12 @@ async def run(
         return
 
     if rpc_stdio:
-        session, _mode = _resolve_session(agent, resume_session_id, cwd=project_root)
+        session, _mode = _resolve_session(
+            agent,
+            resume_session_id,
+            cwd=project_root,
+            profiler=profiler,
+        )
         bridge = StdioRPCBridge(session)
         try:
             await bridge.run()
@@ -441,7 +511,12 @@ async def run(
     profiler.mark("logging.setup.done")
 
     profiler.mark("session.resolve.start")
-    session, mode = _resolve_session(agent, resume_session_id, cwd=project_root)
+    session, mode = _resolve_session(
+        agent,
+        resume_session_id,
+        cwd=project_root,
+        profiler=profiler,
+    )
     profiler.mark("session.resolve.done")
     # setup_tui_logging 在 _resolve_session 前安装，用于捕获 session 初始化期 warning/error。
     # 这些日志没有交互 anchor，需在恢复历史或首次用户输入前落为 standalone log。
@@ -469,7 +544,7 @@ async def run(
     )
 
     async def _mcp_loader() -> None:
-        await _preload_mcp_in_tui(session)
+        await _preload_mcp_in_tui(session, profiler=profiler.child("mcp"))
         mgr = session.runtime._mcp_manager
         if mgr and mgr.failed_servers:
             aliases = [alias for alias, _ in mgr.failed_servers]

{comate_cli-0.7.4 → comate_cli-0.7.6}/comate_cli/terminal_agent/startup_profile.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 import os
+import threading
 import time
 
 
@@ -17,12 +18,14 @@ class StartupProfiler:
         started_at: float | None = None,
         prefix: str = "",
         pending_messages: list[str] | None = None,
+        lock: threading.Lock | None = None,
     ) -> None:
         self._logger = logger
         self._enabled = enabled
         self._started_at = started_at if started_at is not None else time.perf_counter()
         self._prefix = prefix.strip(".")
         self._pending_messages = pending_messages if pending_messages is not None else []
+        self._lock = lock if lock is not None else threading.Lock()
 
     @classmethod
     def from_env(cls, *, logger: logging.Logger) -> "StartupProfiler":
@@ -37,20 +40,30 @@ class StartupProfiler:
         if self._prefix:
             normalized_phase = f"{self._prefix}.{normalized_phase}"
         elapsed_ms = (time.perf_counter() - self._started_at) * 1000
-        self._pending_messages.append(
-            f"startup_profile phase={normalized_phase} elapsed_ms={elapsed_ms:.3f}"
-        )
-        self.flush()
+        with self._lock:
+            self._pending_messages.append(
+                f"startup_profile phase={normalized_phase} elapsed_ms={elapsed_ms:.3f}"
+            )
+            pending = self._drain_pending_locked()
+        for message in pending:
+            self._logger.info(message)
 
     def flush(self) -> None:
-        if not self._enabled or not self._pending_messages:
+        if not self._enabled:
             return
+        with self._lock:
+            pending = self._drain_pending_locked()
+        for message in pending:
+            self._logger.info(message)
+
+    def _drain_pending_locked(self) -> list[str]:
+        if not self._pending_messages:
+            return []
         if not self._logger.isEnabledFor(logging.INFO):
-            return
+            return []
         pending = list(self._pending_messages)
         self._pending_messages.clear()
-        for message in pending:
-            self._logger.info(message)
+        return pending
 
     def child(self, prefix: str) -> "StartupProfiler":
         normalized_prefix = prefix.strip(".")
@@ -64,4 +77,5 @@ class StartupProfiler:
             started_at=self._started_at,
             prefix=normalized_prefix,
             pending_messages=self._pending_messages,
+            lock=self._lock,
         )

{comate_cli-0.7.4 → comate_cli-0.7.6}/comate_cli/terminal_agent/status_bar.py

@@ -206,6 +206,25 @@ class StatusBar:
         turn = getattr(agent, "_turn_number", None)
         return f"#{turn}" if turn is not None else "-"
 
+    def _context_percent_refresh_started(self) -> bool:
+        for owner in (
+            self._session,
+            getattr(self._session, "_agent", None),
+            getattr(getattr(self._session, "_agent", None), "_context", None),
+        ):
+            if owner is None:
+                continue
+            turn = getattr(owner, "_turn_number", None)
+            if turn is None:
+                turn = getattr(owner, "turn_number", None)
+            if turn is None:
+                continue
+            try:
+                return int(turn) > 0
+            except (TypeError, ValueError):
+                continue
+        return True
+
     def _resolve_project_cwd(self) -> str:
         cwd = getattr(self._session, "_cwd", None)
         if cwd is None:
@@ -260,21 +279,22 @@ class StatusBar:
         return " ".join(parts) if parts else "-"
 
     async def refresh(self) -> None:
-        try:
-            ctx_info = await self._session.get_context_info()
-            utilization = float(getattr(ctx_info, "utilization_percent", 0.0))
-        except Exception:
-            return
+        if self._context_percent_refresh_started():
+            try:
+                ctx_info = await self._session.get_context_info()
+                utilization = float(getattr(ctx_info, "utilization_percent", 0.0))
+            except Exception:
+                return
+
+            normalized = max(0.0, min(utilization, 100.0))
+            self._context_used_pct = normalized
+            self._context_left_pct = max(0.0, 100.0 - normalized)
 
         try:
             self._mode = str(self._session.get_mode()).strip().lower() or "act"
         except Exception:
             pass
 
-        normalized = max(0.0, min(utilization, 100.0))
-        self._context_used_pct = normalized
-        self._context_left_pct = max(0.0, 100.0 - normalized)
-
         branch_task = asyncio.to_thread(self._resolve_git_branch)
         now = time.monotonic()
         diff_is_stale = (
@@ -338,7 +358,7 @@ class StatusBar:
         return max(24, min(width - 6, 72))
 
     def context_left_text(self) -> str:
-        return f"{self._context_left_pct:.0f}%  left"
+        return f"Context {self._context_left_pct:.0f}% left"
 
     def _status_text_for_width(self, width: int) -> str:
         mode_text = f"[{self._mode}]"

{comate_cli-0.7.4 → comate_cli-0.7.6}/comate_cli/terminal_agent/tui.py

@@ -1770,7 +1770,7 @@ class TerminalAgentTUI(
             try:
                 if profiler is not None:
                     profiler.mark("plugins.init.start")
-                await self._init_plugins()
+                await self._init_plugins(profiler=profiler.child("plugins") if profiler is not None else None)
                 if profiler is not None:
                     profiler.mark("plugins.init.done")
             except asyncio.CancelledError:
@@ -1784,6 +1784,8 @@ class TerminalAgentTUI(
             finally:
                 self._refresh_layers()
 
+        if profiler is not None:
+            profiler.mark("plugins.task.create")
         self._plugin_init_task = asyncio.create_task(
             _do_plugin_init(),
             name="terminal-plugin-init",
@@ -1803,11 +1805,15 @@ class TerminalAgentTUI(
                 finally:
                     self._refresh_layers()
 
+            if profiler is not None:
+                profiler.mark("mcp.task.create")
             self._mcp_init_task = asyncio.create_task(
                 _do_init(),
                 name="terminal-mcp-init",
             )
 
+        if profiler is not None:
+            profiler.mark("ui_tick.task.create")
         self._ui_tick_task = asyncio.create_task(
             self._ui_tick(),
             name="terminal-ui-tick",
@@ -1826,11 +1832,15 @@ class TerminalAgentTUI(
                         self._refresh_layers()
                         self._invalidate()
 
+            if profiler is not None:
+                profiler.mark("status_bar.refresh.task.create")
             self._startup_status_refresh_task = asyncio.create_task(
                 _do_startup_status_refresh(),
                 name="terminal-startup-status-refresh",
             )
         if hasattr(self, "_session") and self._session is not None:
+            if profiler is not None:
+                profiler.mark("event_pump.task.create")
             self._event_pump_task = asyncio.create_task(
                 self._consume_event_stream(),
                 name="terminal-session-event-pump",
@@ -1894,12 +1904,16 @@ class TerminalAgentTUI(
             return Path(session_cwd).expanduser().resolve()
         return Path.cwd().expanduser().resolve()
 
-    async def _init_plugins(self) -> None:
+    async def _init_plugins(self, *, profiler: Any | None = None) -> None:
         """Load and inject plugin resources at startup."""
+        if profiler is not None:
+            profiler.mark("load_thread.start")
         loaded_plugins, plugin_errors = await asyncio.to_thread(
             _load_plugins_blocking,
             self._plugin_project_path(),
         )
+        if profiler is not None:
+            profiler.mark("load_thread.done")
         if self._closing:
             logger.debug("Plugin load completed after TUI close; discarding results")
             return
@@ -1907,7 +1921,11 @@ class TerminalAgentTUI(
         self._loaded_plugins = loaded_plugins
         self._plugin_errors = plugin_errors
         self._plugin_command_names: set[str] = set()
+        if profiler is not None:
+            profiler.mark("inject.start")
         self._inject_plugin_resources(self._loaded_plugins)
+        if profiler is not None:
+            profiler.mark("inject.done")
         logger.info(
             "Loaded %d plugins (%d errors)",
             len(self._loaded_plugins),

{comate_cli-0.7.4 → comate_cli-0.7.6}/comate_cli/terminal_agent/update_check.py

@@ -24,6 +24,8 @@ PACKAGE_NAME = "comate-cli"
 RELEASE_NOTES_URL = "https://github.com/AndyLee1024/agent-sdk/releases/latest"
 UPDATE_COMMAND = ("uv", "tool", "update", PACKAGE_NAME)
 _SETTINGS_SECTION = "updates"
+_UPDATE_CHECK_TRUST_ENV = "COMATE_CLI_UPDATE_CHECK_TRUST_ENV"
+_TRUTHY_ENV_VALUES = {"1", "true", "yes", "on"}
 
 
 class UpdatePromptDecision(Enum):
@@ -65,62 +67,149 @@ def _is_chinese_locale() -> bool:
     return False
 
 
+def _update_check_trust_env() -> bool:
+    raw = os.environ.get(_UPDATE_CHECK_TRUST_ENV, "")
+    return raw.strip().lower() in _TRUTHY_ENV_VALUES
+
+
 async def check_update(
     *,
     package: str = PACKAGE_NAME,
     release_notes_url: str = RELEASE_NOTES_URL,
     log: logging.Logger | None = None,
+    profiler: Any | None = None,
 ) -> UpdateInfo | None:
     """异步检查 comate-cli 是否有新版本，返回结构化版本信息或 None。"""
-    active_logger = log or logger
-    try:
-        current = importlib.metadata.version(package)
-    except importlib.metadata.PackageNotFoundError:
-        return None
-
-    if _is_chinese_locale():
-        url = f"https://mirrors.tuna.tsinghua.edu.cn/pypi/{package}/json"
-        source_label = "tuna"
-    else:
-        url = f"https://pypi.org/pypi/{package}/json"
-        source_label = "pypi"
-
+    if profiler is not None:
+        profiler.mark("thread.await.start")
     try:
-        import httpx
-
-        async with httpx.AsyncClient(timeout=3.0) as client:
-            resp = await client.get(url)
-            resp.raise_for_status()
-            latest = resp.json()["info"]["version"]
+        return await asyncio.to_thread(
+            check_update_blocking,
+            package=package,
+            release_notes_url=release_notes_url,
+            log=log,
+            profiler=profiler,
+        )
+    except asyncio.CancelledError:
+        if profiler is not None:
+            profiler.mark("thread.await.cancelled")
+        raise
     except Exception:
-        active_logger.debug(f"update check failed (source={source_label})", exc_info=True)
+        if profiler is not None:
+            profiler.mark("thread.await.failed")
+        active_logger = log or logger
+        active_logger.debug("update check worker failed", exc_info=True)
         return None
+    finally:
+        if profiler is not None:
+            profiler.mark("thread.await.done")
 
-    try:
-        from packaging.version import Version
 
-        if Version(latest) > Version(current):
-            return UpdateInfo(
-                package=package,
-                current_version=current,
-                latest_version=latest,
-                release_notes_url=release_notes_url,
+def check_update_blocking(
+    *,
+    package: str = PACKAGE_NAME,
+    release_notes_url: str = RELEASE_NOTES_URL,
+    log: logging.Logger | None = None,
+    profiler: Any | None = None,
+) -> UpdateInfo | None:
+    """同步执行版本检查；由 async wrapper 放入 worker thread，避免阻塞 TUI event loop。"""
+    active_logger = log or logger
+    try:
+        if profiler is not None:
+            profiler.mark("thread.run.start")
+
+        try:
+            if profiler is not None:
+                profiler.mark("current_version.start")
+            current = importlib.metadata.version(package)
+        except importlib.metadata.PackageNotFoundError:
+            return None
+        finally:
+            if profiler is not None:
+                profiler.mark("current_version.done")
+
+        if profiler is not None:
+            profiler.mark("locale.start")
+        if _is_chinese_locale():
+            url = f"https://mirrors.tuna.tsinghua.edu.cn/pypi/{package}/json"
+            source_label = "tuna"
+        else:
+            url = f"https://pypi.org/pypi/{package}/json"
+            source_label = "pypi"
+        if profiler is not None:
+            profiler.mark("locale.done")
+
+        try:
+            if profiler is not None:
+                profiler.mark("httpx_import.start")
+            import httpx
+            if profiler is not None:
+                profiler.mark("httpx_import.done")
+
+            trust_env = _update_check_trust_env()
+            if profiler is not None:
+                profiler.mark(
+                    "http_client.trust_env.enabled"
+                    if trust_env
+                    else "http_client.trust_env.disabled"
+                )
+                profiler.mark("http_client.construct.start")
+            client = httpx.Client(timeout=3.0, trust_env=trust_env)
+            if profiler is not None:
+                profiler.mark("http_client.construct.done")
+
+            if profiler is not None:
+                profiler.mark("http_client.enter.start")
+            with client:
+                if profiler is not None:
+                    profiler.mark("http_client.enter.done")
+                    profiler.mark("http_get.start")
+                resp = client.get(url)
+                resp.raise_for_status()
+                latest = resp.json()["info"]["version"]
+                if profiler is not None:
+                    profiler.mark("http_get.done")
+        except Exception:
+            if profiler is not None:
+                profiler.mark("http_client.failed")
+            active_logger.debug(f"update check failed (source={source_label})", exc_info=True)
+            return None
+
+        try:
+            if profiler is not None:
+                profiler.mark("version_compare.start")
+            from packaging.version import Version
+
+            if Version(latest) > Version(current):
+                return UpdateInfo(
+                    package=package,
+                    current_version=current,
+                    latest_version=latest,
+                    release_notes_url=release_notes_url,
+                )
+        except Exception:
+            active_logger.debug(
+                "update comparison failed (current=%s, latest=%s)",
+                current,
+                latest,
+                exc_info=True,
             )
-    except Exception:
-        active_logger.debug(
-            "update comparison failed (current=%s, latest=%s)",
-            current,
-            latest,
-            exc_info=True,
-        )
-    return None
+        finally:
+            if profiler is not None:
+                profiler.mark("version_compare.done")
+        return None
+    finally:
+        if profiler is not None:
+            profiler.mark("thread.run.done")
 
 
 def format_update_hint(info: UpdateInfo) -> str:
+    # Returns plain text only. Callers are responsible for adding markup
+    # appropriate to their render target (Rich Console vs prompt_toolkit).
     return (
-        f"[dim] New version available: [bold cyan]{info.latest_version}[/] "
+        f"New version available: {info.latest_version} "
         f"(current: {info.current_version})  "
-        f"Run [bold green]uv tool update {info.package}[/] to update.[/]"
+        f"Run `uv tool update {info.package}` to update."
     )
 
 

{comate_cli-0.7.4 → comate_cli-0.7.6}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.7.4"
+version = "0.7.6"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.11,<3.14"
 authors = [
     { name = "Andy", email = "andy.dev@aliyun.com" }
 ]