comate-cli 0.7.3__tar.gz → 0.7.5__tar.gz

{comate_cli-0.7.3 → comate_cli-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.3
+Version: 0.7.5
 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.3 → comate_cli-0.7.5}/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
@@ -49,8 +49,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:
@@ -109,7 +115,7 @@ def _schedule_update_check_on_launch(
     async def _run() -> None:
         try:
             profiler.mark("update_check.start")
-            update_info = await _check_update()
+            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 +234,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 +322,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 +373,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 +465,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 +473,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 +507,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 +540,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.3 → comate_cli-0.7.5}/comate_cli/terminal_agent/status_bar.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 import subprocess
 import time
@@ -40,7 +41,7 @@ class StatusBar:
         self._session = session
         self._model_name: str = self._resolve_model_name(session)
         self._mode: str = "act"
-        self._git_branch: str = self._resolve_git_branch()
+        self._git_branch: str = "N/A"
         self._context_used_pct: float = 0.0
         self._context_left_pct: float = 100.0
         self._git_diff_stats: GitDiffStats | None = None
@@ -205,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:
@@ -259,23 +279,36 @@ 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)
-
-        self._git_branch = self._resolve_git_branch()
-        self._ensure_git_diff_stats()
+        branch_task = asyncio.to_thread(self._resolve_git_branch)
+        now = time.monotonic()
+        diff_is_stale = (
+            self._git_diff_stats is None
+            or now - self._git_diff_cache_time >= self._GIT_DIFF_CACHE_SECONDS
+        )
+        if diff_is_stale:
+            diff_task = asyncio.to_thread(self._resolve_git_diff_stats)
+            branch, diff_stats = await asyncio.gather(branch_task, diff_task)
+            self._git_diff_stats = diff_stats
+            self._git_diff_cache_time = time.monotonic()
+        else:
+            branch = await branch_task
+        self._git_branch = branch
 
         # Refresh token usage cache if any token-related items are enabled.
         cfg = self._config
@@ -325,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.3 → comate_cli-0.7.5}/comate_cli/terminal_agent/tui.py

@@ -139,6 +139,16 @@ def _truncate_file_history(path: Path, max_entries: int = 200) -> None:
     path.write_bytes(rewritten_bytes)
 
 
+def _load_plugins_blocking(project_path: Path) -> tuple[list[Any], list[Any]]:
+    from comate_agent_sdk.plugins import PluginLoader, create_plugin_registry
+
+    loader = PluginLoader()
+    registry = create_plugin_registry()
+    data_dir = registry.base_dir / "data"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return loader.load_all(registry=registry, project_path=project_path)
+
+
 class TerminalAgentTUI(
     KeyBindingsMixin,
     InputBehaviorMixin,
@@ -266,6 +276,7 @@ class TerminalAgentTUI(
         self._ui_tick_task: asyncio.Task[None] | None = None
         self._mcp_init_task: asyncio.Task[None] | None = None
         self._plugin_init_task: asyncio.Task[None] | None = None
+        self._startup_status_refresh_task: asyncio.Task[None] | None = None
         self._plugin_init_cancel_timeout_s = 1.0
         self._interrupt_requested_at: float | None = None
         self._interrupt_force_window_seconds = 1.5
@@ -1759,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:
@@ -1773,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",
@@ -1792,16 +1805,42 @@ 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",
         )
+        status_bar = getattr(self, "_status_bar", None)
+        if status_bar is not None:
+            async def _do_startup_status_refresh() -> None:
+                try:
+                    await status_bar.refresh()
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    logger.debug("startup status refresh failed", exc_info=True)
+                finally:
+                    if not self._closing:
+                        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",
@@ -1841,6 +1880,16 @@ class TerminalAgentTUI(
                 self._ui_tick_task.cancel()
                 with suppress(asyncio.CancelledError):
                     await self._ui_tick_task
+            startup_status_refresh_task = getattr(
+                self,
+                "_startup_status_refresh_task",
+                None,
+            )
+            if startup_status_refresh_task is not None:
+                startup_status_refresh_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await startup_status_refresh_task
+                self._startup_status_refresh_task = None
             event_pump_task = getattr(self, "_event_pump_task", None)
             if event_pump_task is not None:
                 event_pump_task.cancel()
@@ -1848,21 +1897,35 @@ class TerminalAgentTUI(
                     await event_pump_task
             self._renderer.close()
 
-    async def _init_plugins(self) -> None:
+    def _plugin_project_path(self) -> Path:
+        session = getattr(self, "_session", None)
+        session_cwd = getattr(session, "_cwd", None)
+        if session_cwd:
+            return Path(session_cwd).expanduser().resolve()
+        return Path.cwd().expanduser().resolve()
+
+    async def _init_plugins(self, *, profiler: Any | None = None) -> None:
         """Load and inject plugin resources at startup."""
-        from comate_agent_sdk.plugins import create_plugin_registry, PluginLoader
-
-        loader = PluginLoader()
-        registry = create_plugin_registry()
-        # Ensure plugin data directory exists
-        data_dir = registry.base_dir / "data"
-        data_dir.mkdir(parents=True, exist_ok=True)
-        self._loaded_plugins, self._plugin_errors = loader.load_all(
-            registry=registry,
-            project_path=Path.cwd(),
+        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
+
+        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.3 → comate_cli-0.7.5}/comate_cli/terminal_agent/update_check.py

@@ -70,33 +70,53 @@ 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:
+        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")
 
         async with httpx.AsyncClient(timeout=3.0) as client:
+            if profiler is not None:
+                profiler.mark("http_get.start")
             resp = await client.get(url)
             resp.raise_for_status()
             latest = resp.json()["info"]["version"]
+            if profiler is not None:
+                profiler.mark("http_get.done")
     except Exception:
         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):
@@ -113,6 +133,9 @@ async def check_update(
             latest,
             exc_info=True,
         )
+    finally:
+        if profiler is not None:
+            profiler.mark("version_compare.done")
     return None
 
 

{comate_cli-0.7.3 → comate_cli-0.7.5}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.7.3"
+version = "0.7.5"
 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" }
 ]

{comate_cli-0.7.3 → comate_cli-0.7.5}/tests/test_app_startup_latency.py

@@ -64,7 +64,11 @@ class TestAppStartupLatency(unittest.IsolatedAsyncioTestCase):
                 "run_preflight_if_needed",
                 AsyncMock(return_value=PreflightResult(status="configured")),
             ),
-            patch.object(app_module, "_build_agent", side_effect=lambda *, project_root: order.append("build_agent") or object()),
+            patch.object(
+                app_module,
+                "_build_agent",
+                side_effect=lambda *, project_root, profiler=None: order.append("build_agent") or object(),
+            ),
             patch.object(app_module, "print_logo", side_effect=lambda *args, **kwargs: order.append("print_logo")),
             patch.object(app_module, "_check_update", AsyncMock(return_value=None)),
             patch.object(app_module, "EventRenderer", return_value=MagicMock()),
@@ -149,7 +153,8 @@ class TestAppStartupLatency(unittest.IsolatedAsyncioTestCase):
                 await asyncio.wait_for(update_started.wait(), timeout=0.1)
                 self.run_called.set()
 
-        async def _never_finishes() -> UpdateInfo | None:
+        async def _never_finishes(*, profiler=None) -> UpdateInfo | None:
+            del profiler
             update_started.set()
             try:
                 await asyncio.Event().wait()
@@ -190,7 +195,8 @@ class TestAppStartupLatency(unittest.IsolatedAsyncioTestCase):
                 super().__init__(session, status_bar, renderer)
                 created_tuis.append(self)
 
-        async def _raises() -> UpdateInfo | None:
+        async def _raises(*, profiler=None) -> UpdateInfo | None:
+            del profiler
             raise RuntimeError("network down")
 
         with (

{comate_cli-0.7.3 → comate_cli-0.7.5}/tests/test_completion_status_panel.py

@@ -34,7 +34,7 @@ class _FakeStatusBar:
         return "act"
 
     def info_status_text(self) -> str:
-        return "model | ~main / 100%  left"
+        return "model | ~main / Context 100% left"
 
     def info_status_fragments(self) -> list[tuple[str, str]]:
         return [("class:status", self.info_status_text())]