comate-cli 0.4.4__tar.gz → 0.4.5__tar.gz

{comate_cli-0.4.4 → comate_cli-0.4.5}/.gitignore

@@ -8,7 +8,7 @@ set_env.sh
 .worktrees/
 # C extensions
 *.so
-
+claude_code_codebase/
 .claude/
 # Distribution / packaging
 .Python

{comate_cli-0.4.4 → comate_cli-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.4.4
+Version: 0.4.5
 Summary: Comate terminal CLI built on comate-agent-sdk
 Project-URL: Homepage, https://github.com/AndyLee1024/agent-sdk
 Project-URL: Repository, https://github.com/AndyLee1024/agent-sdk

{comate_cli-0.4.4 → comate_cli-0.4.5}/comate_cli/terminal_agent/animations.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import random
 import time
 from collections.abc import Sequence
 from enum import Enum
@@ -11,27 +12,215 @@ from rich.text import Text
 from comate_agent_sdk.agent.events import StopEvent, TextEvent, ToolCallEvent, ToolResultEvent, UserQuestionEvent
 
 DEFAULT_STATUS_PHRASES: tuple[str, ...] = (
-    "Embellishing…",
-    "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…",
+    "Embellishing",
+    "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",
+     'Accomplishing',
+  'Comating',
+  'Actioning',
+  'Actualizing',
+  'Architecting',
+  'Baking',
+  'Beaming',
+  "Beboppin'",
+  'Befuddling',
+  'Billowing',
+  'Blanching',
+  'Bloviating',
+  'Boogieing',
+  'Boondoggling',
+  'Booping',
+  'Bootstrapping',
+  'Brewing',
+  'Bunning',
+  'Burrowing',
+  'Calculating',
+  'Canoodling',
+  'Caramelizing',
+  'Cascading',
+  'Catapulting',
+  'Cerebrating',
+  'Channeling',
+  'Channelling',
+  'Choreographing',
+  'Churning',
+  'Clauding',
+  'Coalescing',
+  'Cogitating',
+  'Combobulating',
+  'Composing',
+  'Computing',
+  'Concocting',
+  'Considering',
+  'Contemplating',
+  'Cooking',
+  'Crafting',
+  'Creating',
+  'Crunching',
+  'Crystallizing',
+  'Cultivating',
+  'Deciphering',
+  'Deliberating',
+  'Determining',
+  'Dilly-dallying',
+  'Discombobulating',
+  'Doing',
+  'Doodling',
+  'Drizzling',
+  'Ebbing',
+  'Effecting',
+  'Elucidating',
+  'Embellishing',
+  'Enchanting',
+  'Envisioning',
+  'Evaporating',
+  'Fermenting',
+  'Fiddle-faddling',
+  'Finagling',
+  'Flambéing',
+  'Flibbertigibbeting',
+  'Flowing',
+  'Flummoxing',
+  'Fluttering',
+  'Forging',
+  'Forming',
+  'Frolicking',
+  'Frosting',
+  'Gallivanting',
+  'Galloping',
+  'Garnishing',
+  'Generating',
+  'Gesticulating',
+  'Germinating',
+  'Gitifying',
+  'Grooving',
+  'Gusting',
+  'Harmonizing',
+  'Hashing',
+  'Hatching',
+  'Herding',
+  'Honking',
+  'Hullaballooing',
+  'Hyperspacing',
+  'Ideating',
+  'Imagining',
+  'Improvising',
+  'Incubating',
+  'Inferring',
+  'Infusing',
+  'Ionizing',
+  'Jitterbugging',
+  'Julienning',
+  'Kneading',
+  'Leavening',
+  'Levitating',
+  'Lollygagging',
+  'Manifesting',
+  'Marinating',
+  'Meandering',
+  'Metamorphosing',
+  'Misting',
+  'Moonwalking',
+  'Moseying',
+  'Mulling',
+  'Mustering',
+  'Musing',
+  'Nebulizing',
+  'Nesting',
+  'Newspapering',
+  'Noodling',
+  'Nucleating',
+  'Orbiting',
+  'Orchestrating',
+  'Osmosing',
+  'Perambulating',
+  'Percolating',
+  'Perusing',
+  'Philosophising',
+  'Photosynthesizing',
+  'Pollinating',
+  'Pondering',
+  'Pontificating',
+  'Pouncing',
+  'Precipitating',
+  'Prestidigitating',
+  'Processing',
+  'Proofing',
+  'Propagating',
+  'Puttering',
+  'Puzzling',
+  'Quantumizing',
+  'Razzle-dazzling',
+  'Razzmatazzing',
+  'Recombobulating',
+  'Reticulating',
+  'Roosting',
+  'Ruminating',
+  'Sautéing',
+  'Scampering',
+  'Schlepping',
+  'Scurrying',
+  'Seasoning',
+  'Shenaniganing',
+  'Shimmying',
+  'Simmering',
+  'Skedaddling',
+  'Sketching',
+  'Slithering',
+  'Smooshing',
+  'Sock-hopping',
+  'Spelunking',
+  'Spinning',
+  'Sprouting',
+  'Stewing',
+  'Sublimating',
+  'Swirling',
+  'Swooping',
+  'Symbioting',
+  'Synthesizing',
+  'Tempering',
+  'Thinking',
+  'Thundering',
+  'Tinkering',
+  'Tomfoolering',
+  'Topsy-turvying',
+  'Transfiguring',
+  'Transmuting',
+  'Twisting',
+  'Undulating',
+  'Unfurling',
+  'Unravelling',
+  'Vibing',
+  'Waddling',
+  'Wandering',
+  'Warping',
+  'Whatchamacalliting',
+  'Whirlpooling',
+  'Whirring',
+  'Whisking',
+  'Wibbling',
+  'Working',
+  'Wrangling',
+  'Zesting',
+  'Zigzagging',
 )
 
 BREATH_DOT_COLORS: tuple[str, ...] = (
@@ -117,6 +306,7 @@ class SubmissionAnimator:
     ) -> None:
         del console
         self._phrases = tuple(phrases) if phrases else DEFAULT_STATUS_PHRASES
+        self._shuffled: tuple[str, ...] = tuple(self._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)
@@ -146,6 +336,9 @@ class SubmissionAnimator:
         self._phrase_idx = 0
         self._phrase_started_at_monotonic = time.monotonic()
         self._phrase_duration_seconds = self._phrase_duration_for_idx(0)
+        shuffled = list(self._phrases)
+        random.shuffle(shuffled)
+        self._shuffled = tuple(shuffled)
         self._is_active = True
         self._dirty = True
         self._stop_event = asyncio.Event()
@@ -189,7 +382,7 @@ class SubmissionAnimator:
         if not self._is_active:
             return Text("")
 
-        phrase = self._status_hint if self._status_hint else self._phrases[self._phrase_idx]
+        phrase = self._status_hint if self._status_hint else (self._shuffled[self._phrase_idx] + "…")
         dot_color = breathing_dot_color(self._frame)
         now_monotonic = time.monotonic()
         dot = Text(
@@ -204,7 +397,7 @@ class SubmissionAnimator:
         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_idx = (self._phrase_idx + 1) % len(self._shuffled)
                 self._phrase_started_at_monotonic = now
                 self._phrase_duration_seconds = self._phrase_duration_for_idx(self._phrase_idx)
             self._frame += 1

{comate_cli-0.4.4 → comate_cli-0.4.5}/comate_cli/terminal_agent/event_renderer.py

@@ -510,13 +510,13 @@ class EventRenderer:
                     child_display = resolve_display_tool_name(child_tool.tool_name, {})
                     signature = _tool_signature(child_display, child_tool.args_summary)
                     if child_tool.status == "running":
-                        entries.append((1, f"|_ {signature}"))
+                        entries.append((1, f"⎿ {signature}"))
                     else:
                         icon = "✓" if child_tool.status == "completed" else "✗"
-                        entries.append((1, f"|_ {icon} {signature}"))
+                        entries.append((1, f"⎿ {icon} {signature}"))
 
                 if state.show_init:
-                    entries.append((1, "|_ init"))
+                    entries.append((1, "⎿ init"))
             else:
                 display_name = state.display_tool_name or state.tool_name
                 signature = _tool_signature(display_name, state.args_summary)
@@ -564,7 +564,8 @@ class EventRenderer:
         self._running_tools[tool_call_id] = self._make_running_tool(tool_name, args)
 
     def _build_tool_subtitle(
-        self, tool_name: str, result: str, metadata: dict[str, Any] | None = None
+        self, tool_name: str, result: str, metadata: dict[str, Any] | None = None,
+        output: Any = None,
     ) -> str | None:
         """Build a subtitle string for tool result display.
 
@@ -574,6 +575,31 @@ class EventRenderer:
 
         lowered = tool_name.lower()
 
+        # ── typed output 优先路径 ──
+        if output is not None:
+            try:
+                from comate_agent_sdk.tool_schemas.write import WriteOutput
+                from comate_agent_sdk.tool_schemas.read import ReadOutput
+                from comate_agent_sdk.tool_schemas.bash import BashOutput
+                from comate_agent_sdk.tool_schemas.search import GlobOutput, GrepOutput, LSOutput
+
+                if lowered == "write" and isinstance(output, WriteOutput):
+                    return f"Write {output.lines_written} lines"
+
+                if lowered == "read" and isinstance(output, ReadOutput):
+                    return f"Read {output.lines_returned} lines of {output.total_lines}"
+
+                if lowered == "bash" and isinstance(output, BashOutput):
+                    return f"Exit code {output.exit_code}"
+
+                if lowered in ("glob", "ls") and isinstance(output, (GlobOutput, LSOutput)):
+                    return f"Found {output.count} files"
+
+                if lowered == "grep" and isinstance(output, GrepOutput):
+                    return f"Found {output.total_matches} matches"
+            except ImportError:
+                pass  # SDK not available, fall through to legacy
+
         if lowered == "skill":
             return "Successfully loaded skill"
 
@@ -603,7 +629,7 @@ class EventRenderer:
             lines = result.split("\n") if result else []
             if lines and lines[-1] == "":
                 lines = lines[:-1]
-            return f"Wrote {len(lines)} lines"
+            return f"Write {len(lines)} lines"
 
         if lowered in ("edit", "multiedit"):
             if not metadata:
@@ -719,12 +745,13 @@ class EventRenderer:
         is_error: bool,
         result: Any,
         metadata: dict[str, Any] | None = None,
+        output: Any = None,
     ) -> None:
         sev: Literal["info", "warning", "error"] = "error" if is_error else "info"
         if is_error:
             subtitle = _truncate(_one_line(result), self._tool_error_summary_max_len)
         else:
-            subtitle = self._build_tool_subtitle(tool_name, str(result), metadata)
+            subtitle = self._build_tool_subtitle(tool_name, str(result), metadata, output)
         state = self._running_tools.pop(tool_call_id, None)
         if state is None:
             display_name = resolve_display_tool_name(tool_name, {})
@@ -1054,7 +1081,7 @@ class EventRenderer:
                     self._rebuild_loading_line()
                     return (False, None)
                 self._append_tool_call(tool_name, args_dict, tool_call_id)
-            case ToolResultEvent(tool=tool_name, result=result, tool_call_id=tool_call_id, is_error=is_error, metadata=metadata):
+            case ToolResultEvent(tool=tool_name, result=result, tool_call_id=tool_call_id, is_error=is_error, metadata=metadata, output=output):
                 stored_args = self._tool_call_args.pop(tool_call_id, {})
                 if not should_show_tool_in_scrollback(tool_name, stored_args, is_result=True, is_error=is_error):
                     self._running_tools.pop(tool_call_id, None)
@@ -1066,6 +1093,7 @@ class EventRenderer:
                     is_error=is_error,
                     result=result,
                     metadata=metadata,
+                    output=output,
                 )
             case UsageDeltaEvent(
                 source=_,

{comate_cli-0.4.4 → comate_cli-0.4.5}/comate_cli/terminal_agent/history_printer.py

@@ -82,7 +82,7 @@ def render_history_group(
             renderables.append(Text(""))
             continue
 
-        # System entries: 按 severity 区分视觉样式
+        # System entries: 按 severity 区分视觉样式，缩进 2 空格与消息内容列对齐
         if entry.entry_type == "system":
             if entry.severity == "error":
                 text_style = "bold #FF6B6B"
@@ -90,8 +90,13 @@ def render_history_group(
                 text_style = "#E8B830"
             else:
                 text_style = "dim"
+            content = str(entry.text)
+            content_lines = content.splitlines() or [""]
             line_text = Text()
-            line_text.append(str(entry.text), style=text_style)
+            line_text.append(f"  {content_lines[0]}", style=text_style)
+            for line in content_lines[1:]:
+                line_text.append("\n")
+                line_text.append(f"  {line}", style=text_style)
             renderables.append(line_text)
             renderables.append(Text(""))
             continue

{comate_cli-0.4.4 → comate_cli-0.4.5}/comate_cli/terminal_agent/mention_completer.py

@@ -146,6 +146,10 @@ class LocalFileMentionCompleter(Completer):
         if self._is_completed_file(context.fragment):
             return None
 
+        result_limit = max(max_items, 1)
+        if self._limit > 0:
+            result_limit = min(result_limit, self._limit)
+
         fragment_lower = context.fragment.lower()
         directory_source = self._get_directory_candidates(context.fragment)
         if directory_source is not None:
@@ -175,17 +179,20 @@ class LocalFileMentionCompleter(Completer):
             return None
 
         def _rank(path: str) -> tuple[int, str]:
-            basename = path.rstrip("/").split("/")[-1].lower()
+            normalized = path.rstrip("/")
+            basename = normalized.split("/")[-1].lower()
+            depth = normalized.count("/")
+            is_directory = path.endswith("/")
             if basename.startswith(fragment_lower):
                 category = 0
             elif fragment_lower in basename:
                 category = 1
             else:
                 category = 2
-            return (category, path.lower())
+            return (category, depth, 1 if is_directory else 0, len(normalized), path.lower())
 
         matched.sort(key=_rank)
-        return context, matched[: max(max_items, 1)]
+        return context, matched[:result_limit]
 
     def apply_completion(
         self,
@@ -253,8 +260,6 @@ class LocalFileMentionCompleter(Completer):
                 if self._is_ignored(name):
                     continue
                 entries.append(f"{prefix}{name}/" if entry.is_dir() else f"{prefix}{name}")
-                if len(entries) >= self._limit:
-                    break
         except OSError as exc:
             logger.debug("directory mention scan failed for %s: %s", directory_fragment, exc)
             return cached[1] if cached is not None else []
@@ -284,8 +289,6 @@ class LocalFileMentionCompleter(Completer):
                 if self._is_ignored(name):
                     continue
                 entries.append(f"{name}/" if entry.is_dir() else name)
-                if len(entries) >= self._limit:
-                    break
         except OSError as exc:
             logger.debug("top-level mention scan failed: %s", exc)
             return self._top_cached_paths
@@ -311,8 +314,6 @@ class LocalFileMentionCompleter(Completer):
 
                 if relative_root.parts:
                     paths.append(relative_root.as_posix() + "/")
-                    if len(paths) >= self._limit:
-                        break
 
                 for file_name in sorted(files):
                     if self._is_ignored(file_name):
@@ -321,11 +322,6 @@ class LocalFileMentionCompleter(Completer):
                     if not relative:
                         continue
                     paths.append(relative)
-                    if len(paths) >= self._limit:
-                        break
-
-                if len(paths) >= self._limit:
-                    break
         except OSError as exc:
             logger.debug("deep mention scan failed: %s", exc)
             return self._deep_cached_paths

{comate_cli-0.4.4 → comate_cli-0.4.5}/comate_cli/terminal_agent/tool_view.py

@@ -64,7 +64,9 @@ _ALLOWED_PRIORITY = {"high", "medium", "low"}
 _ALWAYS_HIDDEN_TOOLS: frozenset[str] = frozenset({"askuserquestion", "exitplanmode"})
 
 # Task coordination tools hidden from scrollback unless erroring.
-_SILENT_TASK_TOOLS: frozenset[str] = frozenset({"tasklist", "taskget"})
+_SILENT_TASK_TOOLS: frozenset[str] = frozenset({
+    "taskcreate", "taskupdate", "tasklist", "taskget",
+})
 
 
 def should_show_tool_in_scrollback(
@@ -85,17 +87,7 @@ def should_show_tool_in_scrollback(
     if lowered in _ALWAYS_HIDDEN_TOOLS:
         return is_result and is_error
 
-    # TaskCreate: always visible.
-    if lowered == "taskcreate":
-        return True
-
-    # TaskUpdate: visible only when status=completed, or on error.
-    if lowered == "taskupdate":
-        if str(args.get("status", "")).lower() == "completed":
-            return True
-        return is_result and is_error
-
-    # TaskList / TaskGet: only show errors.
+    # Task tools: only show errors.
     if lowered in _SILENT_TASK_TOOLS:
         return is_result and is_error