comate-cli 0.1.0__tar.gz

comate_cli-0.1.0/.gitignore

@@ -0,0 +1,221 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+.agent
+.agents
+set_env.sh
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+.env
+./tmp/

comate_cli-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: comate-cli
+Version: 0.1.0
+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
+Author-email: Andy <andy.dev@aliyun.com>
+Keywords: agent,cli,comate,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+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-Dist: comate-agent-sdk<1.0.0,>=0.0.1
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: rich>=14.0
+Description-Content-Type: text/markdown
+
+# comate-cli
+
+Comate terminal CLI package.
+
+## Usage
+
+```bash
+uvx comate-cli
+```
+
+Or install globally:
+
+```bash
+uv tool install comate-cli
+comate
+```

comate_cli-0.1.0/README.md

@@ -0,0 +1,16 @@
+# comate-cli
+
+Comate terminal CLI package.
+
+## Usage
+
+```bash
+uvx comate-cli
+```
+
+Or install globally:
+
+```bash
+uv tool install comate-cli
+comate
+```

comate_cli-0.1.0/comate_cli/__init__.py

@@ -0,0 +1,5 @@
+"""Comate CLI package."""
+
+from comate_cli.main import main
+
+__all__ = ["main"]

comate_cli-0.1.0/comate_cli/__main__.py

@@ -0,0 +1,5 @@
+from comate_cli.main import main
+
+
+if __name__ == "__main__":
+    main()

comate_cli-0.1.0/comate_cli/main.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import atexit
+import asyncio
+import logging
+import signal
+import subprocess
+import sys
+import termios
+import threading
+
+logger = logging.getLogger(__name__)
+
+
+class _TerminalStateGuard:
+    """Best-effort tty restore guard for abnormal shutdown paths."""
+
+    def __init__(self) -> None:
+        self._fd: int | None = None
+        self._attrs: list[int | list[int | bytes]] | None = None
+        self._enabled = False
+
+        stdin = sys.__stdin__
+        if stdin is None:
+            return
+        if not stdin.isatty():
+            return
+        try:
+            self._fd = stdin.fileno()
+            self._attrs = termios.tcgetattr(self._fd)
+            self._enabled = True
+        except Exception as exc:
+            logger.debug(f"Terminal guard disabled: failed to snapshot tty attrs: {exc}")
+
+    def restore(self, *, reason: str) -> None:
+        if not self._enabled or self._fd is None or self._attrs is None:
+            return
+
+        try:
+            termios.tcsetattr(self._fd, termios.TCSANOW, self._attrs)
+            return
+        except Exception as exc:
+            logger.warning(f"tty restore failed ({reason}): {exc}", exc_info=True)
+
+        try:
+            subprocess.run(
+                ["stty", "sane"],
+                stdin=sys.__stdin__,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                check=False,
+            )
+        except Exception as exc:
+            logger.warning(f"stty sane fallback failed ({reason}): {exc}", exc_info=True)
+
+
+class _ShutdownNoiseGuard:
+    """Suppress KeyboardInterrupt noise in interpreter shutdown phase."""
+
+    def __init__(self) -> None:
+        self._shutdown_armed = False
+        self._orig_unraisablehook = sys.unraisablehook
+
+    def install(self) -> None:
+        sys.unraisablehook = self._unraisablehook
+
+    def begin_shutdown(self) -> None:
+        if self._shutdown_armed:
+            return
+        self._shutdown_armed = True
+        self._ignore_sigint_until_exit()
+
+    def _ignore_sigint_until_exit(self) -> None:
+        if threading.current_thread() is not threading.main_thread():
+            return
+        try:
+            signal.signal(signal.SIGINT, signal.SIG_IGN)
+            logger.debug("SIGINT is now ignored for final shutdown")
+        except Exception as exc:
+            logger.debug(f"Failed to switch SIGINT to SIG_IGN during shutdown: {exc}")
+
+    def _unraisablehook(self, unraisable: object) -> None:
+        exc_value = getattr(unraisable, "exc_value", None)
+        if self._shutdown_armed and isinstance(exc_value, KeyboardInterrupt):
+            logger.debug("Suppressed unraisable KeyboardInterrupt during shutdown")
+            return
+
+        self._orig_unraisablehook(unraisable)
+
+
+def _parse_args(argv: list[str]) -> tuple[bool, str | None]:
+    rpc_stdio = False
+    session_id: str | None = None
+    for arg in argv:
+        if arg == "--rpc-stdio":
+            rpc_stdio = True
+            continue
+        if arg.startswith("-"):
+            continue
+        if session_id is None:
+            session_id = arg
+    return rpc_stdio, session_id
+
+
+def main(argv: list[str] | None = None) -> None:
+    run_argv = list(argv) if argv is not None else sys.argv[1:]
+
+    noise_guard = _ShutdownNoiseGuard()
+    noise_guard.install()
+
+    term_guard = _TerminalStateGuard()
+    atexit.register(term_guard.restore, reason="atexit")
+    atexit.register(noise_guard.begin_shutdown)
+
+    from comate_cli.terminal_agent.app import run
+
+    rpc_stdio, session_id = _parse_args(run_argv)
+    try:
+        asyncio.run(run(rpc_stdio=rpc_stdio, session_id=session_id))
+    except KeyboardInterrupt:
+        noise_guard.begin_shutdown()
+    finally:
+        noise_guard.begin_shutdown()
+        term_guard.restore(reason="main-finally")
+
+
+if __name__ == "__main__":
+    main()

comate_cli-0.1.0/comate_cli/terminal_agent/__init__.py

@@ -0,0 +1,2 @@
+"""Terminal agent example package."""
+

comate_cli-0.1.0/comate_cli/terminal_agent/animations.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from collections.abc import Sequence
+from enum import Enum
+
+from rich.console import RenderableType
+from rich.text import Text
+
+from comate_agent_sdk.agent.events import StopEvent, TextEvent, ToolCallEvent, ToolResultEvent, UserQuestionEvent
+
+DEFAULT_STATUS_PHRASES: tuple[str, ...] = (
+    "Vibing...",
+    "Thinking...",
+    "Reasoning...",
+    "Planning next move...",
+    "Reading context...",
+    "Connecting dots...",
+    "Synthesizing signal...",
+    "Spotting edge cases...",
+    "Checking assumptions...",
+    "Tracing dependencies...",
+    "Drafting response...",
+    "Polishing details...",
+    "Validating flow...",
+    "Cross-checking facts...",
+    "Refining intent...",
+    "Mapping tools...",
+    "Building confidence...",
+    "Stitching answer...",
+    "Finalizing output...",
+    "Almost there...",
+)
+
+BREATH_DOT_COLORS: tuple[str, ...] = (
+    "#4B5563",  # 暗灰
+    "#6B7280",  # 灰
+    "#9CA3AF",  # 浅灰
+    "#D1D5DB",  # 极浅灰
+    "#9CA3AF",  # 回退
+    "#6B7280",  # 回退
+)
+BREATH_DOT_GLYPHS: tuple[str, ...] = (
+    "○",
+    "●",
+)
+
+
+def breathing_dot_color(frame: int) -> str:
+    """Return the breathing dot color for a given animation frame."""
+    phase = (frame // 4) % len(BREATH_DOT_COLORS)
+    return BREATH_DOT_COLORS[phase]
+
+
+def breathing_dot_glyph(now_monotonic: float | None = None) -> str:
+    """Return the breathing dot glyph that switches once per second."""
+    now = time.monotonic() if now_monotonic is None else now_monotonic
+    phase = int(now) % len(BREATH_DOT_GLYPHS)
+    return BREATH_DOT_GLYPHS[phase]
+
+
+def _lerp_rgb(
+    start_rgb: tuple[int, int, int],
+    end_rgb: tuple[int, int, int],
+    ratio: float,
+) -> tuple[int, int, int]:
+    clamped = max(0.0, min(1.0, ratio))
+    r = int(start_rgb[0] + (end_rgb[0] - start_rgb[0]) * clamped)
+    g = int(start_rgb[1] + (end_rgb[1] - start_rgb[1]) * clamped)
+    b = int(start_rgb[2] + (end_rgb[2] - start_rgb[2]) * clamped)
+    return r, g, b
+
+
+def _cyan_sweep_text(
+    content: str,
+    frame: int,
+) -> Text:
+    """Create a cyan sweep (moving highlight) effect over text."""
+    text = Text()
+    if not content:
+        return text
+    total = len(content)
+    base_rgb = (95, 155, 190)
+    mid_rgb = (120, 200, 235)
+    high_rgb = (210, 245, 255)
+
+    window = max(3, total // 5)
+    cycle = max(total + window * 2, 16)
+    center = (frame % cycle) - window
+
+    for idx, ch in enumerate(content):
+        distance = abs(idx - center)
+        if distance <= window:
+            glow = 1.0 - (distance / window)
+            if glow >= 0.6:
+                r, g, b = _lerp_rgb(mid_rgb, high_rgb, (glow - 0.6) / 0.4)
+            else:
+                r, g, b = _lerp_rgb(base_rgb, mid_rgb, glow / 0.6)
+        else:
+            r, g, b = base_rgb
+        text.append(ch, style=f"bold rgb({r},{g},{b})")
+    return text
+
+
+class SubmissionAnimator:
+    """Animated status line shown after user submits a message."""
+
+    def __init__(
+        self,
+        console: object | None = None,
+        phrases: Sequence[str] | None = None,
+        refresh_interval: float = 0.12,
+        min_phrase_seconds: float = 2.4,
+        max_phrase_seconds: float = 3.0,
+    ) -> None:
+        del console
+        self._phrases = tuple(phrases) if phrases else DEFAULT_STATUS_PHRASES
+        self._refresh_interval = refresh_interval
+        self._min_phrase_seconds = max(0.6, min_phrase_seconds)
+        self._max_phrase_seconds = max(self._min_phrase_seconds, max_phrase_seconds)
+        self._status_hint: str | None = None
+        self._task: asyncio.Task[None] | None = None
+        self._stop_event: asyncio.Event | None = None
+        self._frame = 0
+        self._phrase_idx = 0
+        self._phrase_started_at_monotonic = 0.0
+        self._phrase_duration_seconds = 0.0
+        self._dirty = False
+        self._is_active = False
+
+    def _compute_phrase_duration(self, phrase_idx: int) -> float:
+        # Deterministic per phrase, bounded by [min, max], and never exceeds 3s by default.
+        span = self._max_phrase_seconds - self._min_phrase_seconds
+        if span <= 0:
+            return self._max_phrase_seconds
+        step = (phrase_idx * 17 + 11) % 100
+        ratio = step / 100.0
+        return self._min_phrase_seconds + span * ratio
+
+    async def start(self) -> None:
+        if self._task is not None:
+            return
+        self._frame = 0
+        self._phrase_idx = 0
+        self._phrase_started_at_monotonic = time.monotonic()
+        self._phrase_duration_seconds = self._phrase_duration_for_idx(0)
+        self._is_active = True
+        self._dirty = True
+        self._stop_event = asyncio.Event()
+        self._task = asyncio.create_task(self._run(), name="submission-animator")
+
+    def set_status_hint(self, hint: str | None) -> None:
+        if hint is None:
+            if self._status_hint is not None:
+                self._dirty = True
+            self._status_hint = None
+            return
+        normalized = hint.strip()
+        new_value = normalized or None
+        if new_value != self._status_hint:
+            self._dirty = True
+        self._status_hint = new_value
+
+    async def stop(self) -> None:
+        if self._task is None:
+            return
+        assert self._stop_event is not None
+        self._stop_event.set()
+        try:
+            await self._task
+        finally:
+            self._task = None
+            self._stop_event = None
+            self._is_active = False
+            self._dirty = True
+
+    @property
+    def is_active(self) -> bool:
+        return self._is_active
+
+    def consume_dirty(self) -> bool:
+        dirty = self._dirty
+        self._dirty = False
+        return dirty
+
+    def renderable(self) -> RenderableType:
+        if not self._is_active:
+            return Text("")
+
+        phrase = self._status_hint if self._status_hint else self._phrases[self._phrase_idx]
+        dot_color = breathing_dot_color(self._frame)
+        now_monotonic = time.monotonic()
+        dot = Text(
+            f"{breathing_dot_glyph(now_monotonic)} ",
+            style=f"bold {dot_color}",
+        )
+        sweep = _cyan_sweep_text(phrase, frame=self._frame)
+        return Text.assemble(dot, sweep)
+
+    async def _run(self) -> None:
+        assert self._stop_event is not None
+        while not self._stop_event.is_set():
+            now = time.monotonic()
+            if now - self._phrase_started_at_monotonic >= self._phrase_duration_seconds:
+                self._phrase_idx = (self._phrase_idx + 1) % len(self._phrases)
+                self._phrase_started_at_monotonic = now
+                self._phrase_duration_seconds = self._phrase_duration_for_idx(self._phrase_idx)
+            self._frame += 1
+            self._dirty = True
+            try:
+                await asyncio.wait_for(self._stop_event.wait(), timeout=self._refresh_interval)
+            except TimeoutError:
+                continue
+
+    def _phrase_duration_for_idx(self, phrase_idx: int) -> float:
+        return self._compute_phrase_duration(phrase_idx)
+
+
+class AnimationPhase(str, Enum):
+    IDLE = "idle"
+    SUBMITTING = "submitting"
+    TOOL_RUNNING = "tool_running"
+    ASSISTANT_STREAMING = "assistant_streaming"
+    DONE = "done"
+
+
+class StreamAnimationController:
+    """Controls submission animation lifecycle across stream events."""
+
+    def __init__(
+        self,
+        animator: SubmissionAnimator,
+        *,
+        min_visible_seconds: float = 0.35,
+    ) -> None:
+        self._animator = animator
+        self._min_visible_seconds = max(0.0, float(min_visible_seconds))
+        self._phase = AnimationPhase.IDLE
+        self._started_at_monotonic = 0.0
+        self._stopped = True
+        self._active_tool_call_ids: set[str] = set()
+
+    @property
+    def phase(self) -> AnimationPhase:
+        return self._phase
+
+    async def start(self) -> None:
+        self._active_tool_call_ids.clear()
+        self._animator.set_status_hint(None)
+        self._started_at_monotonic = time.monotonic()
+        self._phase = AnimationPhase.SUBMITTING
+        self._stopped = False
+        await self._animator.start()
+
+    async def shutdown(self) -> None:
+        await self._stop_if_needed(AnimationPhase.DONE)
+
+    async def on_event(self, event: object) -> None:
+        if self._stopped:
+            return
+
+        if isinstance(event, ToolCallEvent):
+            self._active_tool_call_ids.add(event.tool_call_id)
+            return
+
+        if isinstance(event, ToolResultEvent):
+            self._active_tool_call_ids.discard(event.tool_call_id)
+            return
+
+        if isinstance(event, UserQuestionEvent) or isinstance(event, StopEvent):
+            await self._stop_if_needed(AnimationPhase.DONE)
+
+    async def _stop_if_needed(self, next_phase: AnimationPhase) -> None:
+        if self._stopped:
+            return
+        elapsed = time.monotonic() - self._started_at_monotonic
+        if elapsed < self._min_visible_seconds:
+            await asyncio.sleep(self._min_visible_seconds - elapsed)
+        self._animator.set_status_hint(None)
+        await self._animator.stop()
+        self._stopped = True
+        self._phase = next_phase