comate-cli 0.1.0__py3-none-any.whl

comate_cli/terminal_agent/session_view.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+from comate_agent_sdk.agent import ChatSession
+from comate_agent_sdk.context.items import ItemType
+
+from comate_cli.terminal_agent.message_style import print_assistant_gap, print_assistant_prefix_line
+
+
+def _truncate(content: str, max_len: int = 1400) -> str:
+    if len(content) <= max_len:
+        return content
+    return f"{content[:max_len]}..."
+
+
+def _extract_assistant_text(item) -> str:
+    """从 ContextItem 提取用于显示的文本（不含 tool_calls JSON）"""
+    message = getattr(item, "message", None)
+    if message is None:
+        return ""
+
+    # 优先使用 message.text（纯文本，不含 tool_calls）
+    if hasattr(message, "text"):
+        text = message.text
+        if isinstance(text, str):
+            return text
+
+    # 回退：处理非标准 content
+    msg_content = getattr(message, "content", "")
+    if isinstance(msg_content, str):
+        return msg_content
+    if isinstance(msg_content, list):
+        text_parts: list[str] = []
+        for part in msg_content:
+            if isinstance(part, dict) and part.get("type") == "text":
+                text_parts.append(str(part.get("text", "")))
+        return "".join(text_parts)
+
+    return ""
+
+
+def _split_first_visible_line(content: str) -> tuple[str, str]:
+    lines = content.splitlines()
+    if not lines:
+        return "", ""
+
+    idx = 0
+    while idx < len(lines) and not lines[idx].strip():
+        idx += 1
+
+    if idx >= len(lines):
+        return "", ""
+
+    first = lines[idx].strip()
+    remainder = "\n".join(lines[idx + 1 :]).lstrip("\r\n")
+    return first, remainder
+
+
+def render_session_header(console: Console, session_id: str, mode: str) -> None:
+    console.print(f"[dim]session({mode}): [cyan]{session_id}[/][/]")
+
+
+def render_user_message(console: Console, content: str) -> None:
+    console.print(f"[green]>[/] {_truncate(content, 1000)}")
+
+
+def render_resume_timeline(console: Console, session: ChatSession) -> None:
+    items = session._agent._context.get_conversation_items_snapshot()
+    history = [
+        item
+        for item in items
+        if item.item_type in (ItemType.USER_MESSAGE, ItemType.ASSISTANT_MESSAGE)
+    ]
+    if not history:
+        console.print("[dim]no previous messages[/]")
+        return
+
+    console.print(f"[dim]history loaded: {len(history)} messages[/]")
+
+    for item in history:
+        if item.item_type == ItemType.USER_MESSAGE:
+            content = item.content_text or ""
+            render_user_message(console, str(content))
+            continue
+        assistant_text = _extract_assistant_text(item).strip()
+        if not assistant_text:
+            console.print("[dim]⏺ (tool call only message)[/]")
+            continue
+        trimmed = _truncate(assistant_text)
+        first, remainder = _split_first_visible_line(trimmed)
+        if not first:
+            console.print("[dim]⏺ (tool call only message)[/]")
+            continue
+        print_assistant_prefix_line(console, first)
+        if remainder:
+            console.print(Markdown(remainder, code_theme="monokai", hyperlinks=True))
+        print_assistant_gap(console)

comate_cli/terminal_agent/slash_commands.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from prompt_toolkit.completion import (
+    Completer,
+    Completion,
+    FuzzyCompleter,
+    WordCompleter,
+)
+from prompt_toolkit.document import Document
+
+
+@dataclass(frozen=True, slots=True)
+class SlashCommandSpec:
+    name: str
+    description: str
+    aliases: tuple[str, ...] = ()
+
+    def slash_name(self) -> str:
+        if self.aliases:
+            return f"/{self.name} ({', '.join(self.aliases)})"
+        return f"/{self.name}"
+
+
+@dataclass(frozen=True, slots=True)
+class _SlashCommandCall:
+    name: str
+    args: str
+    raw_input: str
+
+
+def parse_slash_command_call(user_input: str) -> _SlashCommandCall | None:
+    text = user_input.strip()
+    if not text or not text.startswith("/"):
+        return None
+
+    match = re.match(r"^\/([a-zA-Z0-9_-]+(?::[a-zA-Z0-9_-]+)*)", text)
+    if match is None:
+        return None
+    if len(text) > match.end() and not text[match.end()].isspace():
+        return None
+
+    return _SlashCommandCall(
+        name=match.group(1),
+        args=text[match.end() :].lstrip(),
+        raw_input=text,
+    )
+
+
+SLASH_COMMAND_SPECS: tuple[SlashCommandSpec, ...] = (
+    SlashCommandSpec(
+        name="help",
+        description="Show available slash commands",
+        aliases=("h",),
+    ),
+    SlashCommandSpec(
+        name="model",
+        description="Switch model level (LOW/MID/HIGH)",
+        aliases=("m",),
+    ),
+    SlashCommandSpec(name="session", description="Show current session ID"),
+    SlashCommandSpec(name="usage", description="Show token usage summary"),
+    SlashCommandSpec(name="context", description="Show context usage summary"),
+    SlashCommandSpec(name="compact", description="Trigger manual context compaction"),
+    SlashCommandSpec(name="rewind", description="Rewind to a checkpoint"),
+    SlashCommandSpec(name="exit", description="Exit terminal agent", aliases=("quit",)),
+)
+SLASH_COMMANDS: tuple[str, ...] = tuple(f"/{cmd.name}" for cmd in SLASH_COMMAND_SPECS)
+
+
+class SlashCommandCompleter(Completer):
+    def __init__(self, commands: tuple[SlashCommandSpec, ...]) -> None:
+        self._commands = commands
+        self._command_lookup: dict[str, list[SlashCommandSpec]] = {}
+        words: list[str] = []
+
+        for cmd in sorted(self._commands, key=lambda item: item.name):
+            if cmd.name not in self._command_lookup:
+                self._command_lookup[cmd.name] = []
+                words.append(cmd.name)
+            self._command_lookup[cmd.name].append(cmd)
+            for alias in cmd.aliases:
+                if alias in self._command_lookup:
+                    self._command_lookup[alias].append(cmd)
+                else:
+                    self._command_lookup[alias] = [cmd]
+                    words.append(alias)
+
+        self._word_pattern = re.compile(r"[^\s]+")
+        self._fuzzy_pattern = r"^[^\s]*"
+        self._word_completer = WordCompleter(
+            words,
+            WORD=False,
+            pattern=self._word_pattern,
+        )
+        self._fuzzy = FuzzyCompleter(
+            self._word_completer,
+            WORD=False,
+            pattern=self._fuzzy_pattern,
+        )
+
+    def get_completions(self, document: Document, complete_event):
+        text = document.text_before_cursor
+        if document.text_after_cursor.strip():
+            return
+
+        last_space = text.rfind(" ")
+        token = text[last_space + 1 :]
+        prefix = text[: last_space + 1] if last_space != -1 else ""
+        if prefix:
+            return
+        if not token.startswith("/"):
+            return
+
+        typed = token[1:]
+        if typed:
+            commands = self._command_lookup.get(typed, [])
+            if commands and any(
+                typed == cmd.name or typed in cmd.aliases for cmd in commands
+            ):
+                return
+
+        typed_doc = Document(text=typed, cursor_position=len(typed))
+        candidates = list(self._fuzzy.get_completions(typed_doc, complete_event))
+        seen: set[str] = set()
+
+        for candidate in candidates:
+            commands = self._command_lookup.get(candidate.text)
+            if not commands:
+                continue
+            for cmd in commands:
+                if cmd.name in seen:
+                    continue
+                seen.add(cmd.name)
+                yield Completion(
+                    text=f"/{cmd.name}",
+                    start_position=-len(token),
+                    display=cmd.slash_name(),
+                    display_meta=cmd.description,
+                )

comate_cli/terminal_agent/startup.py

@@ -0,0 +1,77 @@
+"""Generic startup status display utilities for CLI applications.
+
+Usage:
+    from comate_cli.terminal_agent.startup import print_warning, print_success, print_error
+
+    print_warning(console, "MCP server 'ctx7' skipped: header is null")
+    print_success(console, "MCP loaded: exa_search (4 tools)")
+    print_error(console, "Failed to initialize config")
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+
+from rich.console import Console
+from rich.text import Text
+
+from comate_cli.terminal_agent.animations import _cyan_sweep_text, breathing_dot_color, breathing_dot_glyph
+
+
+def print_status(console: Console, icon: str, style: str, message: str) -> None:
+    """Print a styled status line to the console."""
+    console.print(f"[{style}]{icon} {message}[/]")
+
+
+def print_warning(console: Console, message: str) -> None:
+    """Print a yellow warning line (⚠)."""
+    print_status(console, "⚠", "yellow", message)
+
+
+def print_success(console: Console, message: str) -> None:
+    """Print a dim success line (✓)."""
+    print_status(console, "✓", "dim", message)
+
+
+def print_error(console: Console, message: str) -> None:
+    """Print a red error line (✗)."""
+    print_status(console, "✗", "red", message)
+
+
+async def _run_mcp_animation(console: Console, server_names: list[str]) -> None:
+    """Background task: render sweep animation until cancelled."""
+    names = server_names if server_names else ["mcp"]
+    servers_str = ", ".join(names)
+    frame = 0
+    while True:
+        msg = f"Starting up mcp servers: {servers_str} "
+        sweep = _cyan_sweep_text(msg, frame)
+        now_monotonic = time.monotonic()
+        dot = Text(
+            f"{breathing_dot_glyph(now_monotonic)} ",
+            style=f"bold {breathing_dot_color(frame)}",
+        )
+        console.print(Text.assemble(dot, sweep), end="\r")
+        frame += 1
+        await asyncio.sleep(0.1)
+
+
+@asynccontextmanager
+async def mcp_connecting_animation(
+    console: Console, server_names: list[str]
+) -> AsyncGenerator[None, None]:
+    """Async context manager that shows a sweep animation while MCP connects."""
+    task = asyncio.create_task(_run_mcp_animation(console, server_names))
+    try:
+        yield
+    finally:
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+        # Clear the animation line
+        console.print(Text(" " * 60), end="\r")

comate_cli/terminal_agent/status_bar.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+import time
+from typing import NamedTuple
+
+from prompt_toolkit.application.current import get_app_or_none
+
+from comate_agent_sdk.agent import ChatSession
+
+logger = logging.getLogger(__name__)
+
+
+class GitDiffStats(NamedTuple):
+    added: int
+    removed: int
+
+
+class StatusBar:
+    _DEFAULT_TERMINAL_WIDTH: int = 100
+    _MIN_TERMINAL_WIDTH: int = 40
+    _GIT_DIFF_CACHE_SECONDS: float = 5.0
+
+    def __init__(self, session: ChatSession):
+        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._context_used_pct: float = 0.0
+        self._context_left_pct: float = 100.0
+        self._git_diff_stats: GitDiffStats | None = None
+        self._git_diff_cache_time: float = 0.0
+
+    @staticmethod
+    def _resolve_model_name(session: ChatSession) -> str:
+        agent = getattr(session, "_agent", None)
+        llm = getattr(agent, "llm", None)
+        model = getattr(llm, "model", "")
+        normalized = str(model).strip()
+        return normalized or "unknown-model"
+
+    def set_model_name(self, model_name: str) -> None:
+        normalized = str(model_name).strip()
+        self._model_name = normalized or "unknown-model"
+
+    def set_session(self, session: ChatSession) -> None:
+        self._session = session
+        self._model_name = self._resolve_model_name(session)
+        try:
+            self._mode = str(session.get_mode()).strip().lower() or "act"
+        except Exception:
+            self._mode = "act"
+
+    def set_mode(self, mode: str) -> None:
+        normalized = str(mode).strip().lower()
+        self._mode = normalized or "act"
+
+    @staticmethod
+    def _resolve_git_branch() -> str:
+        try:
+            completed = subprocess.run(
+                ["git", "branch", "--show-current"],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+        except Exception:
+            return "N/A"
+
+        if completed.returncode != 0:
+            return "N/A"
+        branch = completed.stdout.strip()
+        return branch or "N/A"
+
+    @staticmethod
+    def _resolve_git_diff_stats() -> GitDiffStats | None:
+        try:
+            completed = subprocess.run(
+                ["git", "diff", "--shortstat", "--no-color"],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+        except Exception:
+            return None
+
+        if completed.returncode != 0:
+            return None
+
+        output = completed.stdout.strip()
+        if not output:
+            return None
+
+        # Parse output like "3 files changed, 12 insertions(+), 5 deletions(-)"
+        # or just "12 insertions(+), 5 deletions(-)"
+        added, removed = 0, 0
+        for part in output.split(","):
+            part = part.strip()
+            if "+" in part and "insertion" in part:
+                # e.g., "12 insertions(+)"
+                num_str = part.split()[0]
+                added = int(num_str)
+            elif "-" in part and "deletion" in part:
+                # e.g., "5 deletions(-)"
+                num_str = part.split()[0]
+                removed = int(num_str)
+
+        return GitDiffStats(added=added, removed=removed)
+
+    def _ensure_git_diff_stats(self) -> None:
+        now = time.monotonic()
+        if (
+            self._git_diff_stats is not None
+            and now - self._git_diff_cache_time < self._GIT_DIFF_CACHE_SECONDS
+        ):
+            return
+        self._git_diff_stats = self._resolve_git_diff_stats()
+        self._git_diff_cache_time = now
+        logger.debug(
+            f"Git diff stats refreshed: {self._git_diff_stats}"
+        )
+
+    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
+
+        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)
+
+        # Refresh git diff stats to keep them up-to-date
+        self._ensure_git_diff_stats()
+
+    @classmethod
+    def _resolve_terminal_width(cls) -> int:
+        app = get_app_or_none()
+        if app is None:
+            return cls._DEFAULT_TERMINAL_WIDTH
+
+        try:
+            width = int(app.output.get_size().columns)
+        except Exception:
+            return cls._DEFAULT_TERMINAL_WIDTH
+        return max(width, cls._MIN_TERMINAL_WIDTH)
+
+    @staticmethod
+    def _truncate_text(text: str, max_len: int) -> str:
+        if max_len <= 0:
+            return ""
+        if len(text) <= max_len:
+            return text
+        if max_len <= 3:
+            return text[:max_len]
+        return f"{text[: max_len - 3]}..."
+
+    def _right_prompt_budget(self) -> int:
+        width = self._resolve_terminal_width()
+        return max(24, min(width - 6, 72))
+
+    def context_left_text(self) -> str:
+        return f"{self._context_left_pct:.0f}% context left"
+
+    def _status_text_for_width(self, width: int) -> str:
+        mode_text = f"[{self._mode}]"
+        branch_text = f"~{self._git_branch}"
+        context_text = self.context_left_text()
+        full_text = f"{mode_text} {self._model_name} | {branch_text} / {context_text}"
+        budget = max(len(context_text), width)
+        if len(full_text) <= budget:
+            return full_text
+
+        prefix = f"{mode_text} {self._model_name} | {branch_text} / "
+        prefix_budget = max(0, budget - len(context_text))
+        trimmed_prefix = self._truncate_text(prefix, prefix_budget)
+        return f"{trimmed_prefix}{context_text}"
+
+    def get_mode(self) -> str:
+        return self._mode
+
+    def info_status_text(self) -> str:
+        """仅返回 model | ~branch / X% context left（不含 mode 前缀）."""
+        branch_text = f"~{self._git_branch}"
+        context_text = self.context_left_text()
+        full_text = f"{self._model_name} | {branch_text} / {context_text}"
+        width = self._resolve_terminal_width()
+        budget = max(len(context_text), width - 2)
+        if len(full_text) <= budget:
+            return full_text
+        prefix = f"{self._model_name} | {branch_text} / "
+        prefix_budget = max(0, budget - len(context_text))
+        return f"{self._truncate_text(prefix, prefix_budget)}{context_text}"
+
+    def right_prompt_text(self) -> str:
+        return self._status_text_for_width(self._right_prompt_budget())
+
+    def right_prompt_fragments(self) -> list[tuple[str, str]]:
+        return [("class:prompt.rprompt", self.right_prompt_text())]
+
+    def footer_status_text(self) -> str:
+        width = self._resolve_terminal_width()
+        content_budget = max(16, width - 2)
+        return self._status_text_for_width(content_budget)
+
+    def _git_diff_fragments(self) -> list[tuple[str, str]]:
+        self._ensure_git_diff_stats()
+        if self._git_diff_stats is None or (
+            self._git_diff_stats.added == 0 and self._git_diff_stats.removed == 0
+        ):
+            return []
+
+        parts: list[tuple[str, str]] = []
+        if self._git_diff_stats.added > 0:
+            parts.append(("class:git-diff.added", f"+{self._git_diff_stats.added}"))
+        if self._git_diff_stats.removed > 0:
+            parts.append(("class:git-diff.removed", f"-{self._git_diff_stats.removed}"))
+        return parts
+
+    def git_diff_fragments(self) -> list[tuple[str, str]]:
+        """Prompt-toolkit fragments for git diff stats.
+
+        Working tree only (unstaged): `git diff --shortstat`.
+        """
+        return self._git_diff_fragments()
+
+    def footer_toolbar(self) -> list[tuple[str, str]]:
+        width = self._resolve_terminal_width()
+        status_text = self.footer_status_text()
+        git_fragments = self._git_diff_fragments()
+
+        # Calculate total length: status_text + git diff parts
+        git_len = sum(len(text) + 1 for _, text in git_fragments)  # +1 for space
+        left_padding = max(0, width - len(status_text) - git_len - 1)
+
+        fragments: list[tuple[str, str]] = [
+            ("", " " * left_padding),
+            ("", status_text),
+        ]
+
+        # Add git diff stats with colors
+        if git_fragments:
+            fragments.append(("", " "))  # Separator
+            for class_name, text in git_fragments:
+                fragments.append((class_name, text))
+
+        fragments.append(("", " "))
+        return fragments
+
+    def helper_toolbar(self) -> list[tuple[str, str]]:
+        return []

comate_cli/terminal_agent/text_effects.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from prompt_toolkit.utils import get_cwidth
+
+_ELLIPSIS = "…"
+
+
+def fit_single_line(content: str, width: int) -> str:
+    """Truncate string by terminal display width, handling wide chars correctly."""
+    max_width = max(width, 8)
+    if get_cwidth(content) <= max_width:
+        return content
+    if max_width <= 1:
+        return _ELLIPSIS
+
+    result: list[str] = []
+    used_width = 0
+    ellipsis_width = get_cwidth(_ELLIPSIS)
+    target_width = max_width - ellipsis_width
+
+    for char in content:
+        char_width = get_cwidth(char)
+        if used_width + char_width > target_width:
+            break
+        result.append(char)
+        used_width += char_width
+
+    return "".join(result) + _ELLIPSIS
+
+