comate-cli 0.1.0__py3-none-any.whl

comate_cli/terminal_agent/tui_parts/render_panels.py

@@ -0,0 +1,537 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from prompt_toolkit.utils import get_cwidth
+from rich.console import Console
+
+from comate_cli.terminal_agent.animations import _cyan_sweep_text, breathing_dot_color, breathing_dot_glyph
+from comate_cli.terminal_agent.text_effects import fit_single_line
+
+console = Console()
+
+
+class RenderPanelsMixin:
+    _COMPLETION_PANEL_MAX_LINES = 8
+
+    def _terminal_width(self) -> int:
+        if self._app is None:
+            return 100
+        try:
+            return max(int(self._app.output.get_size().columns), 40)
+        except Exception:
+            return 100
+
+    def _queue_text(self) -> list[tuple[str, str]]:
+        queued_messages = list(self._queued_messages)
+        if not queued_messages:
+            return [("", " ")]
+
+        width = self._terminal_width()
+        fragments: list[tuple[str, str]] = []
+        for idx, message in enumerate(queued_messages):
+            preview = " ".join(message.split())
+            line = fit_single_line(f"     > {preview}", width)
+            if idx > 0:
+                fragments.append(("", "\n"))
+            fragments.append(("class:queue.item", line))
+        return fragments
+
+    def _queue_height(self) -> int:
+        return max(1, len(self._queued_messages))
+
+    def _status_text(self) -> list[tuple[str, str]]:
+        width = self._terminal_width()
+
+        # 左栏：mode 图标 + 提示文字
+        mode = self._status_bar.get_mode()
+        hint_text = "(shift+tab to cycle)"
+        if mode == "plan":
+            left_main = "⏸ Plan mode on "
+            left_style = "class:status.mode.plan"
+        else:
+            left_main = "⏵⏵ Act mode on "
+            left_style = "class:status.mode.act"
+
+        # 右栏：model | ~branch / X% left
+        right_text = self._status_bar.info_status_text()
+        git_frags = self._status_bar.git_diff_fragments()
+
+        left_w = sum(get_cwidth(c) for c in left_main + hint_text)
+        right_w = sum(get_cwidth(c) for c in right_text)
+        if git_frags:
+            right_w += 2 + sum(get_cwidth(c) for _, t in git_frags for c in t)
+
+        padding = max(1, width - left_w - right_w - 2)
+
+        frags: list[tuple[str, str]] = [
+            (left_style, left_main),
+            ("class:status.hint", hint_text),
+            ("class:status", " " * padding),
+            ("class:status", right_text),
+        ]
+        if git_frags:
+            frags.append(("class:status", "  "))
+            frags.extend(git_frags)
+        return frags
+
+    def _completion_panel_state(self) -> tuple[list[Any], int] | None:
+        input_area = getattr(self, "_input_area", None)
+        if input_area is None:
+            return None
+        buffer = getattr(input_area, "buffer", None)
+        if buffer is None:
+            return None
+        complete_state = getattr(buffer, "complete_state", None)
+        if complete_state is None:
+            return None
+
+        completions = list(getattr(complete_state, "completions", []) or [])
+        if not completions:
+            return None
+
+        selected_index: int | None = None
+        current_completion = getattr(complete_state, "current_completion", None)
+        if current_completion is not None:
+            for idx, completion in enumerate(completions):
+                if completion is current_completion:
+                    selected_index = idx
+                    break
+        if selected_index is None:
+            raw_index = getattr(complete_state, "complete_index", None)
+            if isinstance(raw_index, int) and 0 <= raw_index < len(completions):
+                selected_index = raw_index
+        if selected_index is None:
+            selected_index = 0
+        return completions, selected_index
+
+    def _completion_panel_text(self) -> list[tuple[str, str]]:
+        state = self._completion_panel_state()
+        if state is None:
+            return self._status_text()
+
+        completions, selected_index = state
+        width = self._terminal_width()
+        max_lines = max(1, int(self._COMPLETION_PANEL_MAX_LINES))
+        visible_slots = max_lines
+        hidden_below_count = 0
+        start = 0
+        end = len(completions)
+        if len(completions) > max_lines:
+            visible_slots = max(1, max_lines - 1)
+            start = max(0, selected_index - (visible_slots // 2))
+            end = min(len(completions), start + visible_slots)
+            start = max(0, end - visible_slots)
+            hidden_below_count = len(completions) - end
+
+        fragments: list[tuple[str, str]] = []
+        visible = completions[start:end]
+        for idx, completion in enumerate(visible):
+            absolute_idx = start + idx
+            is_selected = absolute_idx == selected_index
+            line_style = (
+                "class:completion.status.current"
+                if is_selected
+                else "class:completion.status.item"
+            )
+
+            display_text = str(getattr(completion, "display_text", completion.text))
+            meta_text = str(getattr(completion, "display_meta_text", "")).strip()
+            line_prefix = "› " if is_selected else "  "
+            row_text = f"{line_prefix}{display_text}"
+            if meta_text:
+                row_text = f"{row_text}  —  {meta_text}"
+
+            clipped = fit_single_line(row_text, width)
+            padding = " " * max(0, width - get_cwidth(clipped))
+            fragments.append((line_style, f"{clipped}{padding}"))
+            if idx != len(visible) - 1 or hidden_below_count > 0:
+                fragments.append(("", "\n"))
+
+        if hidden_below_count > 0:
+            more_text = fit_single_line(f"… and {hidden_below_count} more", width)
+            padding = " " * max(0, width - get_cwidth(more_text))
+            fragments.append(("class:completion.status.more", f"{more_text}{padding}"))
+
+        return fragments if fragments else [("", " ")]
+
+    def _completion_panel_height(self) -> int:
+        state = self._completion_panel_state()
+        if state is None:
+            return 1
+        completions, _ = state
+        max_lines = max(1, int(self._COMPLETION_PANEL_MAX_LINES))
+        if len(completions) <= max_lines:
+            return max(1, len(completions))
+        return max_lines
+
+    def _should_hide_loading_panel(self) -> bool:
+        """统一 loading 显隐逻辑：仅当 Todo 面板出现时隐藏 loading 区域。"""
+        return self._renderer.has_active_todos()
+
+    def _loading_text(self) -> list[tuple[str, str]]:
+        if self._should_hide_loading_panel():
+            return [("", " ")]
+
+        # MCP 初始化阶段：显示连接动画
+        initializing = getattr(self, "_initializing", False)
+        if initializing and not self._renderer.has_running_tools() and not self._busy:
+            return self._animated_loading_fragments("Connecting to MCP tools…")
+
+        # Running tools: multi-line tool panel with breathing dot.
+        if self._renderer.has_running_tools():
+            width = self._terminal_width()
+            show_flash_line = (
+                self._tool_result_flash_active and self._tool_panel_max_lines >= 2
+            )
+            # 动态计算所需行数，但至少保留配置值作为最小值
+            required_lines = self._renderer.compute_required_tool_panel_lines()
+            base_max = self._tool_panel_max_lines
+            tool_max = max(required_lines, base_max)
+            if show_flash_line:
+                tool_max = max(tool_max + 1, self._tool_panel_max_lines)
+            entries = self._renderer.tool_panel_entries(max_lines=max(1, tool_max))
+            if not entries:
+                return [("", " ")]
+
+            dot_color = breathing_dot_color(self._loading_frame)
+            now_monotonic = time.monotonic()
+            dot_glyph = breathing_dot_glyph(now_monotonic)
+            dot_style = f"fg:{dot_color} bold"
+            primary_style = "fg:#D1D5DB"
+            nested_style = "fg:#9CA3AF"
+
+            fragments: list[tuple[str, str]] = []
+            if show_flash_line and self._tool_result_animator.is_active:
+                renderable = self._tool_result_animator.renderable()
+                fragments.extend(self._rich_text_to_pt_fragments(renderable))
+                fragments.append(("", "\n"))
+
+            last_index = len(entries) - 1
+            for idx, (indent, line) in enumerate(entries):
+                if indent < 0:
+                    clipped = fit_single_line(line, width - 1)
+                    fragments.append((nested_style, clipped))
+                elif indent == 0:
+                    clipped = fit_single_line(line, max(width - 2, 8))
+                    fragments.append((dot_style, f"{dot_glyph} "))
+                    fragments.append((primary_style, clipped))
+                else:
+                    padding = "  " * indent
+                    clipped = fit_single_line(line, max(width - get_cwidth(padding), 8))
+                    fragments.append((nested_style, padding))
+                    fragments.append((nested_style, clipped))
+
+                if idx != last_index:
+                    fragments.append(("", "\n"))
+
+            return fragments
+
+        # 优先使用动画器的渲染（流光走字 + 随机 geek 术语）
+        if self._tool_result_animator.is_active:
+            renderable = self._tool_result_animator.renderable()
+            frags = self._rich_text_to_pt_fragments(renderable)
+            return self._append_run_elapsed_fragment(frags)
+
+        if self._animator.is_active:
+            renderable = self._animator.renderable()
+            frags = self._rich_text_to_pt_fragments(renderable)
+            return self._append_run_elapsed_fragment(frags)
+
+        # 获取语义化的 loading 状态
+        loading_state = self._renderer.loading_state()
+        text = loading_state.text.strip()
+
+        # --- DEBUG: 写入临时日志，排查 _run_start_time 和 _busy 的值 ---
+        import logging as _logging
+
+        _dbg = _logging.getLogger("_loading_text_debug")
+        _dbg.debug(
+            f"branch=fallback busy={getattr(self,'_busy',None)} "
+            f"run_start={getattr(self,'_run_start_time',None)} "
+            f"text={text!r}"
+        )
+        # --- END DEBUG ---
+
+        if not text:
+            if self._busy:
+                return self._animated_loading_fragments(self._fallback_loading_phrase)
+            return [("", " ")]
+
+        return self._animated_loading_fragments(text)
+
+    def _animated_loading_fragments(self, phrase: str) -> list[tuple[str, str]]:
+        """用与工具调用一致的呼吸圆点 + 流光走字渲染 loading 文案."""
+        width = self._terminal_width()
+
+        # 若正在计时，预先计算时间后缀宽度，给 phrase 预留空间
+        run_start: float | None = getattr(self, "_run_start_time", None)
+        elapsed_suffix = ""
+        if run_start is not None:
+            elapsed = time.monotonic() - run_start
+            elapsed_suffix = (
+                f"  ({self._format_run_elapsed(elapsed)} • ctrl+c to interrupt)"
+            )
+
+        # glyph(1) + space(1) = 2，再减去时间后缀宽度
+        phrase_budget = width - 4 - get_cwidth(elapsed_suffix)
+        clipped = fit_single_line(phrase, max(phrase_budget, 8))
+
+        frame = self._loading_frame
+        dot_color = breathing_dot_color(frame)
+        now_monotonic = time.monotonic()
+
+        # 构建 Rich Text（与 SubmissionAnimator.renderable 相同结构）
+        from rich.text import Text as RichText
+
+        dot = RichText(f"{breathing_dot_glyph(now_monotonic)} ", style=f"bold {dot_color}")
+        sweep = _cyan_sweep_text(clipped, frame=frame)
+        combined = RichText.assemble(dot, sweep)
+        frags = self._rich_text_to_pt_fragments(combined)
+        if elapsed_suffix:
+            frags = frags + [("fg:#6B7280", elapsed_suffix)]
+        return frags
+
+    def _append_run_elapsed_fragment(
+        self,
+        frags: list[tuple[str, str]],
+    ) -> list[tuple[str, str]]:
+        """若当前正在计时，在 fragments 末尾追加 '  ·  Xs' 时间后缀."""
+        run_start: float | None = getattr(self, "_run_start_time", None)
+        if run_start is None:
+            return frags
+        elapsed = time.monotonic() - run_start
+        duration_str = self._format_run_elapsed(elapsed)
+        # Rich __rich_console__ 末尾会输出一个 "\n" segment，需要先剥掉再追加，
+        # 否则时间后缀会落在换行符之后，在单行 Window 里不可见。
+        tail: list[tuple[str, str]] = []
+        trimmed = list(frags)
+        while trimmed and trimmed[-1][1] == "\n":
+            tail.insert(0, trimmed.pop())
+        return (
+            trimmed
+            + [("fg:#6B7280", f"  ({duration_str} • ctrl+c to interrupt)")]
+            + tail
+        )
+
+    def _loading_height(self) -> int:
+        if self._should_hide_loading_panel():
+            return 1
+
+        # 工具面板优先：即使 animator 仍活跃，也需要为多行工具面板分配正确高度，
+        # 否则在 Task subagent 执行期间嵌套工具行会被 Window 裁剪为 1 行。
+        if self._renderer.has_running_tools():
+            show_flash_line = (
+                self._tool_result_flash_active and self._tool_panel_max_lines >= 2
+            )
+            # 动态计算所需行数，但至少保留配置值作为最小值
+            required_lines = self._renderer.compute_required_tool_panel_lines()
+            base_max = self._tool_panel_max_lines
+            tool_max = max(required_lines, base_max)
+            if show_flash_line:
+                tool_max = max(tool_max + 1, self._tool_panel_max_lines)
+            tool_lines = self._renderer.tool_panel_entries(max_lines=max(1, tool_max))
+            total = len(tool_lines) + (1 if show_flash_line else 0)
+            return max(1, total)
+        if self._animator.is_active:
+            return 1
+        if self._tool_result_animator.is_active:
+            return 1
+        if self._renderer.loading_state().text.strip():
+            return 1
+        return 1
+
+    _DIFF_PANEL_MAX_VISIBLE = 20
+
+    def _todo_title_shimmer_fragments(self, title: str) -> list[tuple[str, str]]:
+        """Todo 标题流光走字：文字不位移，仅高亮带扫过。"""
+        if not title:
+            return [("fg:#7DD3FC bold", title)]
+
+        sweep_center = (self._loading_frame % (len(title) + 8)) - 4
+        fragments: list[tuple[str, str]] = []
+        for idx, char in enumerate(title):
+            distance = abs(idx - sweep_center)
+            if distance <= 1:
+                style = "fg:#F8FAFC bold"
+            elif distance <= 3:
+                style = "fg:#CFFAFE bold"
+            elif distance <= 5:
+                style = "fg:#A7F3D0 bold"
+            else:
+                style = "fg:#7DD3FC bold"
+            fragments.append((style, char))
+        return fragments
+
+    def _diff_panel_text(self) -> list[tuple[str, str]]:
+        import re
+
+        diff_lines = self._renderer.latest_diff_lines
+        if not diff_lines:
+            return [("", " ")]
+
+        width = self._terminal_width()
+        total = len(diff_lines)
+        viewport = self._DIFF_PANEL_MAX_VISIBLE - 1  # reserve 1 for header
+        offset = self._diff_panel_scroll
+        max_scroll = max(0, total - viewport)
+        scroll_info = ""
+        if total > viewport:
+            scroll_info = f" [{offset + 1}-{min(offset + viewport, total)}/{total}] ↑↓"
+
+        title = (
+            " Diff Preview (Ctrl+O to close, use arrow keys (↑↓) to scroll) "
+            f"{scroll_info} "
+        )
+        pad_len = max(width - len(title) - 2, 0)
+        left_pad = pad_len // 2
+        right_pad = pad_len - left_pad
+        header = f"{'─' * left_pad}{title}{'─' * right_pad}"
+
+        fragments: list[tuple[str, str]] = [("fg:#6B7280", header)]
+
+        hunk_pattern = re.compile(r"^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@")
+        # To track line numbers correctly, we must parse from the beginning
+        old_line = 0
+        new_line = 0
+        visible_start = offset
+        visible_end = offset + viewport
+
+        for idx, line in enumerate(diff_lines):
+            # Always parse hunk headers and file headers to track line numbers
+            if line.startswith("---") or line.startswith("+++"):
+                if visible_start <= idx < visible_end:
+                    fragments.append(("", "\n"))
+                    fragments.append(("fg:#6B7280", line))
+                continue
+
+            m = hunk_pattern.match(line)
+            if m:
+                old_line = int(m.group(1))
+                new_line = int(m.group(2))
+                if visible_start <= idx < visible_end:
+                    fragments.append(("", "\n"))
+                    fragments.append(("fg:#00BCD4", line))
+                continue
+
+            if visible_start <= idx < visible_end:
+                fragments.append(("", "\n"))
+                if line.startswith("-"):
+                    prefix = f"{old_line:>4} "
+                    prefix_width = get_cwidth(prefix)
+                    content_width = max(0, width - prefix_width)
+                    fitted = fit_single_line(line, content_width)
+                    padding = " " * (content_width - get_cwidth(fitted))
+
+                    fragments.append(("fg:#ffffff bg:#4a0202", prefix))
+                    fragments.append(("fg:#ffffff bg:#4a0202", fitted + padding))
+                elif line.startswith("+"):
+                    prefix = f"{new_line:>4} "
+                    prefix_width = get_cwidth(prefix)
+                    content_width = max(0, width - prefix_width)
+                    fitted = fit_single_line(line, content_width)
+                    padding = " " * (content_width - get_cwidth(fitted))
+
+                    fragments.append(("fg:#c6c6c6 bg:#2e502e", prefix))
+                    fragments.append(("fg:#ffffff bg:#2e502e", fitted + padding))
+                else:
+                    fragments.append(("fg:#6B7280", f"{new_line:>4} "))
+                    fragments.append(("fg:#6B7280", line))
+
+            # Always update line counters
+            if line.startswith("-"):
+                old_line += 1
+            elif line.startswith("+"):
+                new_line += 1
+            else:
+                old_line += 1
+                new_line += 1
+
+        return fragments
+
+    def _diff_panel_height(self) -> int:
+        diff_lines = self._renderer.latest_diff_lines
+        if not diff_lines:
+            return 0
+        viewport = self._DIFF_PANEL_MAX_VISIBLE - 1
+        content_lines = min(len(diff_lines), viewport)
+        return content_lines + 1  # +1 for header
+
+    def _todo_text(self) -> list[tuple[str, str]]:
+        lines = self._renderer.todo_panel_lines(max_lines=self._todo_panel_max_lines)
+        if not lines:
+            return [("", " ")]
+
+        width = self._terminal_width()
+        fragments: list[tuple[str, str]] = []
+        last_index = len(lines) - 1
+        for idx, line in enumerate(lines):
+            clipped = fit_single_line(line, width - 1)
+            if idx == 0:
+                fragments.extend(self._todo_title_shimmer_fragments(clipped))
+            else:
+                style = "fg:#CBD5E1"
+                if "✓" in line:
+                    style = "fg:#86EFAC"
+                elif "◉" in line:
+                    style = "fg:#FDE68A"
+                fragments.append((style, clipped))
+            if idx != last_index:
+                fragments.append(("", "\n"))
+        return fragments
+
+    def _todo_height(self) -> int:
+        lines = self._renderer.todo_panel_lines(max_lines=self._todo_panel_max_lines)
+        return max(1, len(lines))
+
+    def _rich_text_to_pt_fragments(self, renderable: Any) -> list[tuple[str, str]]:
+        """将 Rich Text 转换为 prompt_toolkit 的 fragments 格式."""
+        from rich.segment import Segment
+
+        fragments: list[tuple[str, str]] = []
+        for segment in renderable.__rich_console__(console, console.options):
+            if isinstance(segment, Segment):
+                text = segment.text
+                style = segment.style
+                if style:
+                    # 将 Rich style 转换为 prompt_toolkit style
+                    pt_style = self._rich_style_to_pt(style)
+                    fragments.append((pt_style, text))
+                else:
+                    fragments.append(("", text))
+        while fragments and fragments[-1][1] == "\n":
+            fragments.pop()
+        return fragments if fragments else [("", " ")]
+
+    def _rich_style_to_pt(self, rich_style: Any) -> str:
+        """将 Rich style 转换为 prompt_toolkit style 字符串."""
+        parts: list[str] = []
+        if rich_style.bold:
+            parts.append("bold")
+        if rich_style.italic:
+            parts.append("italic")
+        if rich_style.underline:
+            parts.append("underline")
+        if rich_style.strike:
+            parts.append("strike")
+        if rich_style.dim:
+            parts.append("dim")
+
+        # 前景色
+        if rich_style.color and rich_style.color.triplet:
+            parts.append(f"fg:{rich_style.color.triplet.hex}")
+        elif rich_style.color and rich_style.color.type.name == "STANDARD":
+            parts.append(f"fg:ansi{rich_style.color.number}")
+        elif rich_style.color and rich_style.color.type.name == "EIGHT_BIT":
+            parts.append(f"fg:ansi{rich_style.color.number}")
+
+        # 背景色
+        if rich_style.bgcolor and rich_style.bgcolor.triplet:
+            parts.append(f"bg:{rich_style.bgcolor.triplet.hex}")
+        elif rich_style.bgcolor and rich_style.bgcolor.type.name == "STANDARD":
+            parts.append(f"bg:ansi{rich_style.bgcolor.number}")
+        elif rich_style.bgcolor and rich_style.bgcolor.type.name == "EIGHT_BIT":
+            parts.append(f"bg:ansi{rich_style.bgcolor.number}")
+
+        return " ".join(parts) if parts else ""

comate_cli/terminal_agent/tui_parts/slash_command_registry.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from comate_cli.terminal_agent.slash_commands import SlashCommandSpec
+
+
+@dataclass(frozen=True, slots=True)
+class RegisteredSlashCommand:
+    spec: SlashCommandSpec
+    handler: Callable[[str], Any]
+    allow_when_busy: bool = False
+
+
+class SlashCommandRegistry:
+    def __init__(self) -> None:
+        self._entries_by_name: dict[str, RegisteredSlashCommand] = {}
+        self._entries_by_spec_name: dict[str, RegisteredSlashCommand] = {}
+
+    def register(
+        self,
+        *,
+        spec: SlashCommandSpec,
+        handler: Callable[[str], Any],
+        allow_when_busy: bool = False,
+    ) -> None:
+        entry = RegisteredSlashCommand(
+            spec=spec,
+            handler=handler,
+            allow_when_busy=allow_when_busy,
+        )
+        names = (spec.name, *spec.aliases)
+        for name in names:
+            if name in self._entries_by_name:
+                raise ValueError(f"Duplicate slash command registration: {name}")
+        for name in names:
+            self._entries_by_name[name] = entry
+        self._entries_by_spec_name[spec.name] = entry
+
+    def resolve(self, name: str) -> RegisteredSlashCommand | None:
+        return self._entries_by_name.get(name)
+
+    def command_specs(self) -> tuple[SlashCommandSpec, ...]:
+        return tuple(entry.spec for entry in self._entries_by_spec_name.values())

comate_cli/terminal_agent/tui_parts/ui_mode.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class UIMode(Enum):
+    NORMAL = "normal"
+    QUESTION = "question"
+    SELECTION = "selection"

comate_cli-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,44 @@
+comate_cli/__init__.py,sha256=g5VQTNVmtnM8U14p48MU_MgXfxtzNbi0xyDLtIWI_8c,80
+comate_cli/__main__.py,sha256=LplHEjaIDUbAAG727_IZuywS-N_1XHwQeH8Cdr2vMV8,73
+comate_cli/main.py,sha256=lfSJW978je8Goq8CffxQylEb9g2P2NMO1WxZ7HkwZkM,3872
+comate_cli/terminal_agent/__init__.py,sha256=Q_NrCEsDymkK6sIjHyv7EqeJupjTCsnPKURkfzWieGM,39
+comate_cli/terminal_agent/animations.py,sha256=nG6WG-2PomsobjFByrGhQTottdl8WGXBdy_gIqSRVAU,9207
+comate_cli/terminal_agent/app.py,sha256=SUJjteV93sqImBUVq5dH6sUm3OPPdEtQnlITfaMVTrE,8416
+comate_cli/terminal_agent/assistant_render.py,sha256=Bwkkf7GJX1SQn-mjYoolMXvKa9cIhDDNx8a4DOdDKcI,8168
+comate_cli/terminal_agent/env_utils.py,sha256=YU9HUSYl9A3NkA-LX7aopze-GB3_3Jx_Zua5z7F5gEg,1018
+comate_cli/terminal_agent/error_display.py,sha256=m7xbxpDRMct_svOt3vrdh-Zo_SKppi1LW-gwDENAS-A,1782
+comate_cli/terminal_agent/event_renderer.py,sha256=Fbnp9pSF1-noEGnpAfPWs2RxjJeH0YJCw_7RJkwxQJg,34734
+comate_cli/terminal_agent/fragment_utils.py,sha256=ZAtPXBzRKRdODsLtHWc31YLmHyWW-s9r8OctYKL1hHw,570
+comate_cli/terminal_agent/history_printer.py,sha256=q7JN7warwru6aA26o_BLVttgJBVjhU_mfJ84HdngSSs,4981
+comate_cli/terminal_agent/input_geometry.py,sha256=EQDCMBL0ch9-8jSpXC-eAfZw9FIT9glu8FqqhwqOwdU,2060
+comate_cli/terminal_agent/layout_coordinator.py,sha256=9eesZ0-bccXAngIlV1Ur9Yv8lCL0H1AY1juA0QkfPwM,6180
+comate_cli/terminal_agent/logging_adapter.py,sha256=pbZqr9EPcrv-oJqmRvugpy6vrVG3KAhEhpMRuEwCQZQ,5524
+comate_cli/terminal_agent/logo.py,sha256=cRR_Ozuz6BTUr3WaEJP-FE_OBBntMAT2Vi6P_VCboRA,2319
+comate_cli/terminal_agent/markdown_render.py,sha256=08orW1kmvMhrSDQhHUr4kGWJfeQhe2IRu6YO9svXhsM,662
+comate_cli/terminal_agent/mention_completer.py,sha256=oj9qYYfz0Wmmqb4wILjf5fB62RG596quqyUaiO5CoXM,9452
+comate_cli/terminal_agent/message_style.py,sha256=gOVM0BwrVhMynxYIj2AGkblaypkjgLPFV4sy8k_5icg,876
+comate_cli/terminal_agent/models.py,sha256=PJw4_xP7_3a-jUncoCfW-B5pQxZWwUKtTQo3fJ6dMQw,2711
+comate_cli/terminal_agent/question_view.py,sha256=_Ju9kV21urMQgYh9R0d0XW7Sxba5N4BAKTJ0UxWtTuw,22668
+comate_cli/terminal_agent/rewind_store.py,sha256=87HY-1uR69VWe4NJSPB50POU6qsZYemqbPixu3JQc6U,25703
+comate_cli/terminal_agent/rpc_protocol.py,sha256=4_kfBuTA64ccMwfVjXb6Ukys08codCmLilSzyTPB1VU,2962
+comate_cli/terminal_agent/rpc_stdio.py,sha256=Cewv0LaoQvsodcfCS1B2v-F_qH96T4aueTWYmqZsVD8,9308
+comate_cli/terminal_agent/selection_menu.py,sha256=ANS_nAqcY3vJANBSq-axfSNekmNqBkzTzLqPEbeeDsc,9189
+comate_cli/terminal_agent/session_view.py,sha256=sDDKrJIaqeThvAGVeVS40ZcOX-_xXACCWm1imyG_wSA,3213
+comate_cli/terminal_agent/slash_commands.py,sha256=Wv2EPMKIyiMEquJWzwksyoQeBz9lyDyDckEXn-sacXQ,4570
+comate_cli/terminal_agent/startup.py,sha256=KgeQ7TwKSkCvksTGTPEJS6AojndCCKOiBRzWromEZJw,2507
+comate_cli/terminal_agent/status_bar.py,sha256=Aturir9Yqoh-GMATI5NCF0ZRsoch6ltvgBTdj2OKOII,8826
+comate_cli/terminal_agent/text_effects.py,sha256=1FrwEu4oMjySX_6VaA87PxXsxtqOdellq9EIS_XE1AY,753
+comate_cli/terminal_agent/tool_view.py,sha256=G_dvKjwBwmIzr1U27Xx57thCSPN6AIjfUWrzEfVGzoU,21326
+comate_cli/terminal_agent/tui.py,sha256=jw6mviGBDrYcxongig-jigv_qLaUzMuqkbXodlhNv-M,38274
+comate_cli/terminal_agent/tui_parts/__init__.py,sha256=hGrZLgg3tk2dGzhP-69E-OZW2ExJoyvr2eHzpwK4Xlc,721
+comate_cli/terminal_agent/tui_parts/commands.py,sha256=jufrQHXob2nfQ6Vj2wwHz0Vg4C-0ruPrACZ2zcURyfA,28079
+comate_cli/terminal_agent/tui_parts/history_sync.py,sha256=HwMXROshijVXLRIJnJYrUNZUDehdzxLgYnGKFqCMQKA,10291
+comate_cli/terminal_agent/tui_parts/input_behavior.py,sha256=8AuoCDFYP9nVANysQV-shGMrFkgmhbuNx955ugS2ZiE,11585
+comate_cli/terminal_agent/tui_parts/key_bindings.py,sha256=I94I7PEMzb_ssRoUfQDfWeF7sGRWvNZ25NLcIZbIsnw,11643
+comate_cli/terminal_agent/tui_parts/render_panels.py,sha256=kgO63L-_mAvgV-zpskW5hqnWCXVo1o3vlMQerEEF3_s,22010
+comate_cli/terminal_agent/tui_parts/slash_command_registry.py,sha256=0GHRloPJD9H3Xm-_EqltgcCd9OYofOLSIUlCDlAx8o4,1446
+comate_cli/terminal_agent/tui_parts/ui_mode.py,sha256=wNYmvlqhiMTVK2Vnyc6LQwQwHL8gRpByw-YP5lSndnM,156
+comate_cli-0.1.0.dist-info/METADATA,sha256=4acPa69-_nYN_k2-_eeg03BlQ6AWwDOyQi-IN428oxE,957
+comate_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+comate_cli-0.1.0.dist-info/entry_points.txt,sha256=lAhnZ4iLW4lq5M-ULwdxf-fTTxBXC2YtCUV66Nls_C4,48
+comate_cli-0.1.0.dist-info/RECORD,,

comate_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

comate_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+comate = comate_cli.main:main