comate-cli 0.7.0a8__tar.gz → 0.7.0a10__tar.gz

{comate_cli-0.7.0a8 → comate_cli-0.7.0a10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.0a8
+Version: 0.7.0a10
 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

{comate_cli-0.7.0a8 → comate_cli-0.7.0a10}/comate_cli/terminal_agent/animations.py

@@ -9,7 +9,7 @@ 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
+from comate_agent_sdk.agent.events import StopEvent, ToolCallEvent, ToolResultEvent, UserQuestionEvent
 
 from comate_cli.terminal_agent.figures import (
     BREATH_DOT_GLYPHS as _FIGURES_BREATH_DOT_GLYPHS,
@@ -238,6 +238,27 @@ BREATH_DOT_COLORS: tuple[str, ...] = (
 )
 BREATH_DOT_GLYPHS: tuple[str, ...] = _FIGURES_BREATH_DOT_GLYPHS
 
+LOADING_SPINNER_FRAMES: tuple[str, ...] = (
+    "⠋",
+    "⠙",
+    "⠹",
+    "⠸",
+    "⠼",
+    "⠴",
+    "⠦",
+    "⠧",
+    "⠇",
+    "⠏",
+)
+
+HIDDEN_THINKING_BADGES: tuple[str, ...] = (
+    "ultra thinking",
+    "deep reasoning",
+    "thinking deeper",
+    "extended thinking",
+    "working through it",
+)
+
 
 def breathing_dot_color(frame: int) -> str:
     """Return the breathing dot color for a given animation frame."""
@@ -252,6 +273,11 @@ def breathing_dot_glyph(now_monotonic: float | None = None) -> str:
     return BREATH_DOT_GLYPHS[phase]
 
 
+def loading_spinner_glyph(frame: int) -> str:
+    """Return the compact spinner glyph for the main loading line."""
+    return LOADING_SPINNER_FRAMES[frame % len(LOADING_SPINNER_FRAMES)]
+
+
 def _lerp_rgb(
     start_rgb: tuple[int, int, int],
     end_rgb: tuple[int, int, int],
@@ -385,11 +411,9 @@ class SubmissionAnimator:
             return Text("")
 
         phrase = self._status_hint if self._status_hint else (self._shuffled[self._phrase_idx] + ELLIPSIS)
-        dot_color = breathing_dot_color(self._frame)
-        now_monotonic = time.monotonic()
         dot = Text(
-            f"{breathing_dot_glyph(now_monotonic)} ",
-            style=f"bold {dot_color}",
+            f"{loading_spinner_glyph(self._frame)} ",
+            style="bold #9CA3AF",
         )
         sweep = _cyan_sweep_text(phrase, frame=self._frame)
         return Text.assemble(dot, sweep)

{comate_cli-0.7.0a8 → comate_cli-0.7.0a10}/comate_cli/terminal_agent/app.py

@@ -186,14 +186,23 @@ async def add(a: int, b: int) -> int:
 
 
 def _build_agent(*, project_root: Path | 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()
+    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,  # 启用流式 Task（实时显示嵌套工具调用）
+            use_streaming_task=True,
+            memory_background_enabled=snapshot.memory_background_enabled,
+            memory_dreaming_enabled=snapshot.memory_dreaming_enabled,
+            compaction=CompactionConfig(
+                threshold_ratio=snapshot.compaction_threshold_ratio,
+            ),
         )
     )
 

comate_cli-0.7.0a10/comate_cli/terminal_agent/config/model.py

@@ -0,0 +1,52 @@
+"""ConfigSnapshot：/config UI、store、startup 三处共享的偏好快照。
+
+Revision 2: 5 项偏好（display_thinking, model_level, compaction, memory_background, memory_dreaming）。
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import Literal
+
+ModelLevelPreset = Literal["LOW", "MID", "HIGH"]
+ThresholdPreset = Literal["conservative", "balanced", "aggressive"]
+
+COMPACT_PRESETS: dict[str, float] = {
+    "conservative": 0.65,
+    "balanced": 0.80,
+    "aggressive": 0.92,
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigSnapshot:
+    """5 项 CLI 偏好的不可变快照。"""
+
+    display_thinking: bool = False
+    model_level: ModelLevelPreset = "MID"
+    compaction_threshold_ratio: float = 0.80
+    compaction_threshold_preset: ThresholdPreset = "balanced"
+    memory_background_enabled: bool = True
+    memory_dreaming_enabled: bool = True
+
+    @classmethod
+    def default(cls) -> "ConfigSnapshot":
+        return cls()
+
+    def with_display_thinking(self, enabled: bool) -> "ConfigSnapshot":
+        return replace(self, display_thinking=enabled)
+
+    def with_model_level(self, level: ModelLevelPreset) -> "ConfigSnapshot":
+        return replace(self, model_level=level)
+
+    def with_threshold_preset(self, preset: ThresholdPreset) -> "ConfigSnapshot":
+        return replace(
+            self,
+            compaction_threshold_preset=preset,
+            compaction_threshold_ratio=COMPACT_PRESETS[preset],
+        )
+
+    def with_memory_background(self, enabled: bool) -> "ConfigSnapshot":
+        return replace(self, memory_background_enabled=enabled)
+
+    def with_memory_dreaming(self, enabled: bool) -> "ConfigSnapshot":
+        return replace(self, memory_dreaming_enabled=enabled)

comate_cli-0.7.0a10/comate_cli/terminal_agent/config/picker.py

@@ -0,0 +1,232 @@
+"""/config slash command 的嵌入式 TUI 面板。
+
+仿 plugins/plugin_picker.py:PluginPickerUI 的模式：
+enter() → container → focus_target() → handle_*。
+
+Revision 2: 5 行 ConfigField。
+"""
+from __future__ import annotations
+
+import logging
+
+from prompt_toolkit.layout.containers import HSplit, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+from comate_cli.terminal_agent.figures import (
+    EFFORT_HIGH,
+    EFFORT_LOW,
+    HEAVY_HORIZONTAL,
+    PLAY_ICON,
+)
+
+from .model import ConfigSnapshot
+from .picker_state import (
+    ConfigField,
+    ConfigPickerState,
+    PickerExit,
+    PickerExitKind,
+    ViewMode,
+)
+from . import store
+
+logger = logging.getLogger(__name__)
+
+_FIELD_LABELS: dict[ConfigField, str] = {
+    ConfigField.DISPLAY_THINKING: "Thinking display",
+    ConfigField.MODEL_LEVEL: "Default model level",
+    ConfigField.AUTO_COMPACT_THRESHOLD: "Auto compact threshold",
+    ConfigField.MEMORY_BACKGROUND: "Memory background",
+    ConfigField.MEMORY_DREAMING: "Memory dreaming",
+}
+
+_FIELD_ORDER = (
+    ConfigField.DISPLAY_THINKING,
+    ConfigField.MODEL_LEVEL,
+    ConfigField.AUTO_COMPACT_THRESHOLD,
+    ConfigField.MEMORY_BACKGROUND,
+    ConfigField.MEMORY_DREAMING,
+)
+
+_ENUM_FIELDS = {ConfigField.MODEL_LEVEL, ConfigField.AUTO_COMPACT_THRESHOLD}
+_BOOL_FIELDS = {ConfigField.DISPLAY_THINKING, ConfigField.MEMORY_BACKGROUND, ConfigField.MEMORY_DREAMING}
+
+
+class ConfigPickerUI:
+    """嵌入式 /config 面板。tui.py 持有单实例，ConditionalContainer 控制可见性。"""
+
+    def __init__(self) -> None:
+        self._state: ConfigPickerState | None = None
+        self._content_window: Window | None = None
+        self._root: HSplit | None = None
+
+    # ---- entry / lifecycle ---------------------------------------------
+    def enter(self, snapshot: ConfigSnapshot) -> None:
+        self._state = ConfigPickerState(origin=snapshot)
+        self._state.save_callback = store.save  # type: ignore[assignment]
+
+    def take_result(self) -> tuple[bool, tuple[str, ...]]:
+        """返回 (saved, error_messages)。供 tui.py 在 mode 切回 NORMAL 后落 history。"""
+        if self._state is None:
+            return (False, ())
+        return (self._state.save_called, self._state.last_save_error_messages)
+
+    # ---- container ------------------------------------------------------
+    @property
+    def container(self) -> HSplit:
+        if self._root is None:
+            self._root = self._build_layout()
+        return self._root
+
+    def focus_target(self) -> Window:
+        if self._content_window is None:
+            self._build_layout()
+        assert self._content_window is not None
+        return self._content_window
+
+    # ---- delegated handlers --------------------------------------------
+    def handle_up(self) -> None:
+        if self._state:
+            self._state.handle_up()
+
+    def handle_down(self) -> None:
+        if self._state:
+            self._state.handle_down()
+
+    def handle_tab(self) -> None:
+        if self._state:
+            self._state.handle_tab()
+
+    def handle_enter(self) -> PickerExit | None:
+        if self._state is None:
+            return None
+        return self._state.handle_enter()  # type: ignore[return-value]
+
+    def handle_escape(self) -> PickerExit | None:
+        if self._state is None:
+            return PickerExit(PickerExitKind.CLEAN_EXIT)
+        return self._state.handle_escape()
+
+    def handle_ctrl_s(self) -> PickerExit | None:
+        if self._state is None:
+            return None
+        return self._state.handle_ctrl_s()
+
+    # ---- fragment builders ---------------------------------------------
+    def _header_fragments(self) -> list[tuple[str, str]]:
+        return [("class:selection.title", "  Config")]
+
+    def _content_fragments(self) -> list[tuple[str, str]]:
+        if self._state is None:
+            return [("", "")]
+
+        if self._state.view_mode == ViewMode.MAIN:
+            return self._main_fragments()
+        return self._subview_fragments()
+
+    def _main_fragments(self) -> list[tuple[str, str]]:
+        state = self._state
+        rows: list[tuple[str, str]] = []
+        for f in _FIELD_ORDER:
+            focused = f == state.focused_field
+            cursor = PLAY_ICON if focused else " "
+            marker = EFFORT_HIGH if focused else EFFORT_LOW
+            prefix = f"  {cursor} {marker} "
+            name = _FIELD_LABELS[f]
+            value = self._render_field_value(f, state.draft)
+            suffix = "  \u21b5" if f in _ENUM_FIELDS else ""
+            row_style = (
+                "class:selection.option.selected"
+                if focused
+                else "class:selection.option"
+            )
+            value_style = (
+                "class:selection.description.selected"
+                if focused
+                else "class:selection.description"
+            )
+            rows.append((row_style, f"{prefix}{name:<26}"))
+            rows.append((value_style, f"{value}{suffix}\n"))
+        return rows
+
+    def _render_field_value(self, f: ConfigField, snap: ConfigSnapshot) -> str:
+        if f == ConfigField.DISPLAY_THINKING:
+            return f"[ {'on ' if snap.display_thinking else 'off'} ]"
+        if f == ConfigField.MODEL_LEVEL:
+            return f"[ {snap.model_level} ]"
+        if f == ConfigField.AUTO_COMPACT_THRESHOLD:
+            return f"[ {snap.compaction_threshold_preset} ({snap.compaction_threshold_ratio:.2f}) ]"
+        if f == ConfigField.MEMORY_BACKGROUND:
+            return f"[ {'on ' if snap.memory_background_enabled else 'off'} ]"
+        if f == ConfigField.MEMORY_DREAMING:
+            return f"[ {'on ' if snap.memory_dreaming_enabled else 'off'} ]"
+        return ""
+
+    def _subview_fragments(self) -> list[tuple[str, str]]:
+        state = self._state
+        if state is None or state.view_mode != ViewMode.SUBVIEW or state.subview_field is None:
+            return []
+        title = _FIELD_LABELS[state.subview_field]
+        rows: list[tuple[str, str]] = [
+            ("class:selection.title", f"  {title}\n"),
+            ("", "\n"),
+        ]
+        for idx, opt in enumerate(state.subview_options()):
+            focused = idx == state.subview_cursor
+            cursor = PLAY_ICON if focused else " "
+            marker = EFFORT_HIGH if focused else EFFORT_LOW
+            prefix = f"  {cursor} {marker} "
+            style = (
+                "class:selection.option.selected"
+                if focused
+                else "class:selection.option"
+            )
+            rows.append((style, f"{prefix}{opt.label}\n"))
+            desc_style = (
+                "class:selection.description.selected"
+                if focused
+                else "class:selection.description"
+            )
+            rows.append((desc_style, f"      {opt.description}\n"))
+        return rows
+
+    def _footer_fragments(self) -> list[tuple[str, str]]:
+        if self._state is None:
+            return []
+        if self._state.view_mode == ViewMode.MAIN:
+            if self._state.dirty_warning_active:
+                return [("class:warning", "  Press Esc again to discard, Ctrl+S to save")]
+            if self._state.last_save_error_messages:
+                return [("class:error", "  Save failed: " + " | ".join(self._state.last_save_error_messages))]
+            return [
+                (
+                    "class:selection.hint",
+                    "  Tab cycle \u00b7 Enter open \u00b7 Ctrl+S save \u00b7 Esc cancel",
+                )
+            ]
+        return [("class:selection.hint", "  Enter confirm \u00b7 Esc back")]
+
+    def _build_layout(self) -> HSplit:
+        header = Window(
+            content=FormattedTextControl(self._header_fragments),
+            height=1,
+            dont_extend_height=True,
+            style="class:selection.title",
+        )
+        divider = Window(
+            height=1,
+            char=HEAVY_HORIZONTAL,
+            style="class:selection.divider",
+        )
+        self._content_window = Window(
+            content=FormattedTextControl(self._content_fragments, focusable=True),
+            wrap_lines=True,
+            always_hide_cursor=True,
+            style="class:selection.body",
+        )
+        footer = Window(
+            content=FormattedTextControl(self._footer_fragments),
+            height=1,
+            dont_extend_height=True,
+            style="class:selection.body",
+        )
+        return HSplit([header, divider, self._content_window, footer])

comate_cli-0.7.0a10/comate_cli/terminal_agent/config/picker_state.py

@@ -0,0 +1,210 @@
+"""ConfigPicker 的纯逻辑状态机——不依赖 prompt_toolkit。
+
+Revision 2: 5 行 ConfigField。
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Callable
+
+from .model import (
+    COMPACT_PRESETS,
+    ConfigSnapshot,
+    ModelLevelPreset,
+    ThresholdPreset,
+)
+
+
+class ConfigField(Enum):
+    DISPLAY_THINKING = "display_thinking"
+    MODEL_LEVEL = "model_level"
+    AUTO_COMPACT_THRESHOLD = "auto_compact_threshold"
+    MEMORY_BACKGROUND = "memory_background"
+    MEMORY_DREAMING = "memory_dreaming"
+
+
+class ViewMode(Enum):
+    MAIN = "main"
+    SUBVIEW = "subview"
+
+
+class PickerExitKind(Enum):
+    SAVED = "saved"
+    CLEAN_EXIT = "clean_exit"   # 无 dirty，直接退出
+    DISCARDED = "discarded"     # dirty 但用户两次 esc 丢弃
+
+
+@dataclass(frozen=True, slots=True)
+class SubviewOption:
+    value: str
+    label: str
+    description: str
+
+
+@dataclass(frozen=True, slots=True)
+class PickerExit:
+    kind: PickerExitKind
+
+
+_FIELD_ORDER = (
+    ConfigField.DISPLAY_THINKING,
+    ConfigField.MODEL_LEVEL,
+    ConfigField.AUTO_COMPACT_THRESHOLD,
+    ConfigField.MEMORY_BACKGROUND,
+    ConfigField.MEMORY_DREAMING,
+)
+
+_THRESHOLD_VALUES: tuple[ThresholdPreset, ...] = ("conservative", "balanced", "aggressive")
+_THRESHOLD_DESCRIPTIONS: dict[str, str] = {
+    "conservative": "0.65 — compact more often; smaller per-call ctx.",
+    "balanced": "0.80 — default. Compact when ctx >= 80% utilized.",
+    "aggressive": "0.92 — compact late; larger ctx per call.",
+}
+
+_MODEL_LEVEL_VALUES: tuple[ModelLevelPreset, ...] = ("LOW", "MID", "HIGH")
+_MODEL_LEVEL_DESCRIPTIONS: dict[str, str] = {
+    "LOW": "Fastest, cheapest. Good for simple tasks.",
+    "MID": "Default. Balanced speed and capability.",
+    "HIGH": "Most capable. For complex reasoning tasks.",
+}
+
+
+@dataclass
+class ConfigPickerState:
+    """ConfigPickerUI 的全部业务状态——可独立单元测试。"""
+
+    origin: ConfigSnapshot
+    draft: ConfigSnapshot = field(init=False)
+    focused_field: ConfigField = field(init=False, default=ConfigField.DISPLAY_THINKING)
+    view_mode: ViewMode = field(init=False, default=ViewMode.MAIN)
+    subview_field: ConfigField | None = field(init=False, default=None)
+    subview_cursor: int = field(init=False, default=0)
+    dirty_warning_active: bool = field(init=False, default=False)
+    save_called: bool = field(init=False, default=False)
+    last_save_error_messages: tuple[str, ...] = field(init=False, default=())
+
+    save_callback: Callable[[ConfigSnapshot], object] | None = None
+
+    def __post_init__(self) -> None:
+        self.draft = self.origin
+
+    # ---- queries --------------------------------------------------------
+    def is_dirty(self) -> bool:
+        return self.draft != self.origin
+
+    def subview_options(self) -> list[SubviewOption]:
+        if self.view_mode != ViewMode.SUBVIEW or self.subview_field is None:
+            return []
+        if self.subview_field == ConfigField.AUTO_COMPACT_THRESHOLD:
+            return [
+                SubviewOption(v, v.capitalize(), _THRESHOLD_DESCRIPTIONS[v])
+                for v in _THRESHOLD_VALUES
+            ]
+        if self.subview_field == ConfigField.MODEL_LEVEL:
+            return [
+                SubviewOption(v, v, _MODEL_LEVEL_DESCRIPTIONS[v])
+                for v in _MODEL_LEVEL_VALUES
+            ]
+        return []
+
+    # ---- key handlers ---------------------------------------------------
+    def handle_up(self) -> None:
+        if self.view_mode == ViewMode.MAIN:
+            idx = _FIELD_ORDER.index(self.focused_field)
+            self.focused_field = _FIELD_ORDER[(idx - 1) % len(_FIELD_ORDER)]
+        else:
+            self.subview_cursor = (self.subview_cursor - 1) % len(self.subview_options())
+        self.dirty_warning_active = False
+
+    def handle_down(self) -> None:
+        if self.view_mode == ViewMode.MAIN:
+            idx = _FIELD_ORDER.index(self.focused_field)
+            self.focused_field = _FIELD_ORDER[(idx + 1) % len(_FIELD_ORDER)]
+        else:
+            self.subview_cursor = (self.subview_cursor + 1) % len(self.subview_options())
+        self.dirty_warning_active = False
+
+    def handle_tab(self) -> None:
+        if self.view_mode != ViewMode.MAIN:
+            return
+        self.dirty_warning_active = False
+        f = self.focused_field
+        if f == ConfigField.DISPLAY_THINKING:
+            self.draft = self.draft.with_display_thinking(not self.draft.display_thinking)
+        elif f == ConfigField.MEMORY_BACKGROUND:
+            self.draft = self.draft.with_memory_background(not self.draft.memory_background_enabled)
+        elif f == ConfigField.MEMORY_DREAMING:
+            self.draft = self.draft.with_memory_dreaming(not self.draft.memory_dreaming_enabled)
+        elif f == ConfigField.AUTO_COMPACT_THRESHOLD:
+            cur = _THRESHOLD_VALUES.index(self.draft.compaction_threshold_preset)
+            next_v = _THRESHOLD_VALUES[(cur + 1) % len(_THRESHOLD_VALUES)]
+            self.draft = self.draft.with_threshold_preset(next_v)
+        elif f == ConfigField.MODEL_LEVEL:
+            cur = _MODEL_LEVEL_VALUES.index(self.draft.model_level)
+            next_v = _MODEL_LEVEL_VALUES[(cur + 1) % len(_MODEL_LEVEL_VALUES)]
+            self.draft = self.draft.with_model_level(next_v)
+
+    def handle_enter(self) -> PickerExit | None:
+        if self.view_mode == ViewMode.MAIN:
+            f = self.focused_field
+            if f in (ConfigField.AUTO_COMPACT_THRESHOLD, ConfigField.MODEL_LEVEL):
+                self.view_mode = ViewMode.SUBVIEW
+                self.subview_field = f
+                self.subview_cursor = self._initial_subview_cursor(f)
+            else:
+                # bool 行：Enter 等价 Tab
+                self.handle_tab()
+        else:
+            # SUBVIEW: commit selection to draft, return to MAIN.
+            opts = self.subview_options()
+            if not opts:
+                self._return_to_main()
+                return None
+            chosen = opts[self.subview_cursor].value
+            if self.subview_field == ConfigField.AUTO_COMPACT_THRESHOLD:
+                self.draft = self.draft.with_threshold_preset(chosen)  # type: ignore[arg-type]
+            elif self.subview_field == ConfigField.MODEL_LEVEL:
+                self.draft = self.draft.with_model_level(chosen)  # type: ignore[arg-type]
+            self._return_to_main()
+        return None
+
+    def handle_escape(self) -> PickerExit | None:
+        if self.view_mode == ViewMode.SUBVIEW:
+            self._return_to_main()
+            return None
+
+        # MAIN
+        if not self.is_dirty():
+            return PickerExit(PickerExitKind.CLEAN_EXIT)
+        if not self.dirty_warning_active:
+            self.dirty_warning_active = True
+            return None
+        return PickerExit(PickerExitKind.DISCARDED)
+
+    def handle_ctrl_s(self) -> PickerExit | None:
+        if self.view_mode == ViewMode.SUBVIEW:
+            return None
+        if self.save_callback is None:
+            raise RuntimeError("save_callback 未注入；ConfigPickerUI 接入时必须设置")
+        result = self.save_callback(self.draft)
+        self.dirty_warning_active = False
+        if getattr(result, "ok", False):
+            self.save_called = True
+            self.last_save_error_messages = ()
+            return PickerExit(PickerExitKind.SAVED)
+        self.last_save_error_messages = tuple(getattr(result, "error_messages", ()) or ())
+        return None
+
+    # ---- helpers --------------------------------------------------------
+    def _initial_subview_cursor(self, f: ConfigField) -> int:
+        if f == ConfigField.AUTO_COMPACT_THRESHOLD:
+            return _THRESHOLD_VALUES.index(self.draft.compaction_threshold_preset)
+        if f == ConfigField.MODEL_LEVEL:
+            return _MODEL_LEVEL_VALUES.index(self.draft.model_level)
+        return 0
+
+    def _return_to_main(self) -> None:
+        self.view_mode = ViewMode.MAIN
+        self.subview_field = None
+        self.subview_cursor = 0