comate-cli 0.2.7__tar.gz → 0.3.0__tar.gz

{comate_cli-0.2.7 → comate_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.2.7
+Version: 0.3.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

{comate_cli-0.2.7 → comate_cli-0.3.0}/comate_cli/main.py

@@ -101,24 +101,37 @@ def _usage_text() -> str:
     return (
         "Usage:\n"
         "  comate [--rpc-stdio]\n"
+        "  comate -p <prompt>\n"
         "  comate resume [<session_id>] [--rpc-stdio]\n"
         "  comate mcp <subcommand> [options]"
     )
 
 
-def _parse_args(argv: list[str]) -> tuple[bool, str | None, bool]:
+def _parse_args(argv: list[str]) -> tuple[bool, str | None, bool, str | None]:
     rpc_stdio = False
+    print_mode = False
     positionals: list[str] = []
     for arg in argv:
         if arg == "--rpc-stdio":
             rpc_stdio = True
             continue
+        if arg in ("-p", "--print"):
+            print_mode = True
+            continue
         if arg.startswith("-"):
             raise _ArgumentError(f"Unknown option: {arg}")
         positionals.append(arg)
 
+    # -p mode: all positionals become the prompt
+    if print_mode:
+        if rpc_stdio:
+            raise _ArgumentError("-p/--print and --rpc-stdio are mutually exclusive")
+        print_prompt = " ".join(positionals) if positionals else ""
+        return rpc_stdio, None, False, print_prompt
+
+    # Non -p mode: original logic
     if not positionals:
-        return rpc_stdio, None, False
+        return rpc_stdio, None, False, None
 
     command = positionals[0]
     if command != "resume":
@@ -129,10 +142,10 @@ def _parse_args(argv: list[str]) -> tuple[bool, str | None, bool]:
             raise _ArgumentError(
                 "resume without <session_id> does not support --rpc-stdio"
             )
-        return rpc_stdio, None, True
+        return rpc_stdio, None, True, None
 
     if len(positionals) == 2:
-        return rpc_stdio, positionals[1], False
+        return rpc_stdio, positionals[1], False, None
 
     raise _ArgumentError("resume accepts at most one <session_id>")
 
@@ -160,17 +173,30 @@ def main(argv: list[str] | None = None) -> None:
     from comate_cli.terminal_agent.app import run
 
     try:
-        rpc_stdio, resume_session_id, resume_select = _parse_args(run_argv)
+        rpc_stdio, resume_session_id, resume_select, print_prompt = _parse_args(run_argv)
     except _ArgumentError as exc:
         sys.stderr.write(f"{exc}\n{_usage_text()}\n")
         raise SystemExit(2) from exc
 
+    # Assemble print mode message
+    print_message: str | None = None
+    if print_prompt is not None:
+        stdin_text = ""
+        if not sys.stdin.isatty():
+            stdin_text = sys.stdin.read()
+        parts = [p for p in (stdin_text.strip(), print_prompt.strip()) if p]
+        if not parts:
+            sys.stderr.write("Error: -p requires a prompt argument or stdin input\n")
+            raise SystemExit(1)
+        print_message = "\n\n".join(parts)
+
     try:
         asyncio.run(
             run(
                 rpc_stdio=rpc_stdio,
                 resume_session_id=resume_session_id,
                 resume_select=resume_select,
+                print_message=print_message,
             )
         )
     except KeyboardInterrupt:

{comate_cli-0.2.7 → comate_cli-0.3.0}/comate_cli/terminal_agent/app.py

@@ -7,6 +7,7 @@ import logging
 import os
 import random
 import signal
+import sys
 import threading
 import time
 from collections.abc import Iterator
@@ -15,7 +16,7 @@ from pathlib import Path
 
 from rich.console import Console
 
-from comate_agent_sdk.agent import Agent, AgentConfig, ChatSession
+from comate_agent_sdk.agent import Agent, AgentConfig, ChatSession, TextEvent
 from comate_agent_sdk.context import EnvOptions
 from comate_agent_sdk.tools import tool
 
@@ -100,6 +101,8 @@ async def _check_update() -> str | None:
 
 def _flush_langfuse_if_configured() -> None:
     """Flush Langfuse pending events synchronously to prevent atexit thread-join errors on Ctrl+C."""
+    if not os.environ.get("LANGFUSE_PUBLIC_KEY"):
+        return
     try:
         from langfuse import get_client
         get_client().flush()
@@ -256,19 +259,50 @@ async def _preload_mcp_in_tui(session: ChatSession) -> None:
         logger.info(f"MCP Server loaded: {', '.join(aliases)} ({count} tools)")
 
 
+async def _run_print_mode(
+    agent: Agent,
+    message: str,
+    *,
+    project_root: Path,
+) -> None:
+    session = ChatSession(agent, cwd=project_root, persistent=False)
+    try:
+        await _preload_mcp_in_tui(session)
+
+        final_text = ""
+        async for event in session.query_stream(message):
+            if isinstance(event, TextEvent):
+                final_text = event.content
+
+        if final_text:
+            sys.stdout.write(final_text)
+            if not final_text.endswith("\n"):
+                sys.stdout.write("\n")
+            sys.stdout.flush()
+    except Exception as exc:
+        logger.error(f"Print mode failed: {exc}", exc_info=True)
+        sys.stderr.write(f"Error: {exc}\n")
+        raise SystemExit(1) from exc
+    finally:
+        await _graceful_shutdown(session)
+
+
 async def run(
     *,
     rpc_stdio: bool = False,
     resume_session_id: str | None = None,
     resume_select: bool = False,
+    print_message: str | None = None,
 ) -> None:
     project_root = _resolve_cli_project_root()
     preflight_result = await run_preflight_if_needed(
         console=console,
         project_root=project_root,
-        interactive=not rpc_stdio,
+        interactive=not rpc_stdio and print_message is None,
     )
     if preflight_result.should_abort_launch:
+        if print_message is not None:
+            raise SystemExit(1)
         return
 
     agent = _build_agent(project_root=project_root)
@@ -286,6 +320,11 @@ async def run(
             await _graceful_shutdown(session)
         return
 
+    # --- Print mode branch ---
+    if print_message is not None:
+        await _run_print_mode(agent, print_message, project_root=project_root)
+        return
+
     print_logo(console, project_root=project_root)
     console.print(f"[dim]💡 Tip: {random.choice(TIPS)}[/dim]")
 

{comate_cli-0.2.7 → comate_cli-0.3.0}/comate_cli/terminal_agent/event_renderer.py

@@ -508,6 +508,60 @@ class EventRenderer:
     def _append_tool_call(self, tool_name: str, args: dict[str, Any], tool_call_id: str) -> None:
         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
+    ) -> str | None:
+        """Build a subtitle string for tool result display.
+
+        Returns None for tools that don't need a subtitle line.
+        """
+        import re
+
+        lowered = tool_name.lower()
+
+        if lowered == "skill":
+            return "Successfully loaded skill"
+
+        if lowered == "read":
+            lines = result.split("\n") if result else []
+            if lines and lines[-1] == "":
+                lines = lines[:-1]
+            return f"Read {len(lines)} lines"
+
+        if lowered == "write":
+            lines = result.split("\n") if result else []
+            if lines and lines[-1] == "":
+                lines = lines[:-1]
+            return f"Wrote {len(lines)} lines"
+
+        if lowered in ("edit", "multiedit"):
+            if not metadata:
+                return None
+            diff_lines = metadata.get("diff")
+            if not isinstance(diff_lines, list) or not diff_lines:
+                return None
+            added = sum(1 for line in diff_lines if line.startswith("+") and not line.startswith("+++"))
+            removed = sum(1 for line in diff_lines if line.startswith("-") and not line.startswith("---"))
+            a_unit = "line" if added == 1 else "lines"
+            r_unit = "line" if removed == 1 else "lines"
+            return f"Added {added} {a_unit}, removed {removed} {r_unit}"
+
+        if lowered == "bash":
+            match = re.search(r"Exit code (\d+)", result or "")
+            if match:
+                return f"Exit code {match.group(1)}"
+            return "Completed"
+
+        if lowered in ("glob", "ls"):
+            lines = [line for line in (result or "").splitlines() if line.strip()]
+            return f"Found {len(lines)} files"
+
+        if lowered == "grep":
+            lines = [line for line in (result or "").splitlines() if line.strip()]
+            return f"Found matches in {len(lines)} files"
+
+        return None
+
     def append_static_tool_result(
         self,
         signature: str,
@@ -585,14 +639,15 @@ class EventRenderer:
         metadata: dict[str, Any] | None = 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)
         state = self._running_tools.pop(tool_call_id, None)
         if state is None:
             display_name = resolve_display_tool_name(tool_name, {})
             signature = _tool_signature(display_name, "")
-            error_suffix = ""
-            if is_error:
-                error_suffix = f" · {_truncate(_one_line(result), self._tool_error_summary_max_len)}"
-            self._history.append(HistoryEntry(entry_type="tool_result", text=f"{signature}{error_suffix}", severity=sev))
+            self._history.append(HistoryEntry(entry_type="tool_result", text=signature, severity=sev, subtitle=subtitle))
             return
 
         if state.is_task:
@@ -628,10 +683,6 @@ class EventRenderer:
             signature = _tool_signature(display_name, summary)
             base = f"{signature}"
 
-        error_suffix = ""
-        if is_error:
-            error_suffix = f" · {_truncate(_one_line(result), self._tool_error_summary_max_len)}"
-
         # Render diff for Edit/MultiEdit if metadata contains diff lines
         if not is_error and metadata:
             diff_lines = metadata.get("diff")
@@ -640,20 +691,18 @@ class EventRenderer:
                 if isinstance(base, Text):
                     text_obj = base
                 else:
-                    text_obj = Text(f"{base}{error_suffix}")
+                    text_obj = Text(base)
                 text_obj.append("\n")
                 text_obj.append(self._render_diff_text(diff_lines, max_lines=self._diff_max_lines))
                 self._history.append(
-                    HistoryEntry(entry_type="tool_result", text=text_obj, severity="info")
+                    HistoryEntry(entry_type="tool_result", text=text_obj, severity="info", subtitle=subtitle)
                 )
                 return
 
         if isinstance(base, Text):
-            if error_suffix:
-                base.append(error_suffix)
-            self._history.append(HistoryEntry(entry_type="tool_result", text=base, severity=sev))
+            self._history.append(HistoryEntry(entry_type="tool_result", text=base, severity=sev, subtitle=subtitle))
         else:
-            self._history.append(HistoryEntry(entry_type="tool_result", text=f"{base}{error_suffix}", severity=sev))
+            self._history.append(HistoryEntry(entry_type="tool_result", text=base, severity=sev, subtitle=subtitle))
 
     @staticmethod
     def _render_diff_text(diff_lines: list[str], max_lines: int = 50) -> Text:
@@ -790,6 +839,9 @@ class EventRenderer:
             return
 
         # All completed: hide panel and write a summary entry once.
+        # 守卫：_current_tasks 已空说明完成总结已写过，跳过重复写入
+        if not self._current_tasks:
+            return
         started = self._task_started_at_monotonic
         elapsed_suffix = ""
         if started is not None:

{comate_cli-0.2.7 → comate_cli-0.3.0}/comate_cli/terminal_agent/history_printer.py

@@ -10,6 +10,17 @@ from comate_cli.terminal_agent.message_style import ASSISTANT_PREFIX
 from comate_cli.terminal_agent.models import HistoryEntry
 
 
+def _render_subtitle_line(subtitle: str, *, error: bool = False) -> Text:
+    """Render a ⎿ subtitle line for tool results."""
+    line = Text()
+    line.append("  ⎿", style="#555555")
+    if error:
+        line.append(f" {subtitle}", style="bold red")
+    else:
+        line.append(f" {subtitle}", style="dim")
+    return line
+
+
 def _entry_prefix(entry: HistoryEntry) -> str:
     if entry.entry_type == "user":
         return ">"
@@ -93,12 +104,16 @@ def render_history_group(
             prefix_char = "✖" if entry.severity == "error" else "●"
             prefix_style = "bold red" if entry.severity == "error" else "bold green"
 
+            is_error = entry.severity == "error"
+
             if isinstance(entry.text, Text):
                 # Rich Text object — preserve styled content (e.g. colored diff)
                 line_text = Text()
                 line_text.append(f"{prefix_char} ", style=prefix_style)
                 line_text.append_text(entry.text)
                 renderables.append(line_text)
+                if entry.subtitle:
+                    renderables.append(_render_subtitle_line(entry.subtitle, error=is_error))
                 renderables.append(Text(""))
                 continue
 
@@ -114,6 +129,8 @@ def render_history_group(
                 line_text.append(line)
 
             renderables.append(line_text)
+            if entry.subtitle:
+                renderables.append(_render_subtitle_line(entry.subtitle, error=is_error))
             renderables.append(Text(""))
             continue
 

{comate_cli-0.2.7 → comate_cli-0.3.0}/comate_cli/terminal_agent/models.py

@@ -80,6 +80,7 @@ class HistoryEntry:
     entry_type: HistoryEntryType
     text: str | Text  # 支持普通字符串或 Rich Text 对象
     severity: Literal["info", "warning", "error"] = "info"
+    subtitle: str | None = None
 
 
 @dataclass(frozen=True)

{comate_cli-0.2.7 → comate_cli-0.3.0}/comate_cli/terminal_agent/tui.py

@@ -21,7 +21,7 @@ from prompt_toolkit.completion import (
     merge_completers,
 )
 from prompt_toolkit.filters import Condition, has_completions, has_focus
-from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.history import FileHistory, InMemoryHistory
 from prompt_toolkit.layout import FloatContainer, HSplit, Layout, Window
 from prompt_toolkit.layout.containers import ConditionalContainer
 from prompt_toolkit.layout.controls import FormattedTextControl
@@ -76,6 +76,37 @@ from comate_cli.terminal_agent.tui_parts import (
 logger = logging.getLogger(__name__)
 
 _TASK_POLL_INTERVAL_S = 2.0
+_INPUT_HISTORY_DIR = Path.home() / ".agent" / "history"
+_INPUT_HISTORY_MAX_ENTRIES = 200
+
+
+def _get_input_history_path(cwd: str) -> Path:
+    """Compute FileHistory path for a given cwd, ensuring parent dir exists."""
+    import hashlib
+
+    slug = cwd.replace("/", "_").lstrip("_")
+    if len(slug) > 200:
+        hash_suffix = hashlib.sha1(cwd.encode()).hexdigest()[:8]
+        slug = f"{slug[:100]}_{hash_suffix}"
+    _INPUT_HISTORY_DIR.mkdir(parents=True, exist_ok=True)
+    return _INPUT_HISTORY_DIR / f"{slug}.txt"
+
+
+def _truncate_file_history(path: Path, max_entries: int = 200) -> None:
+    """Truncate a prompt_toolkit FileHistory file to at most max_entries."""
+    if not path.exists():
+        return
+    content = path.read_text()
+    if not content.strip():
+        return
+    # FileHistory format: entries are +prefixed line blocks separated by blank lines
+    blocks = content.split("\n\n")
+    # Filter out empty blocks
+    blocks = [b for b in blocks if b.strip()]
+    if len(blocks) <= max_entries:
+        return
+    kept = blocks[-max_entries:]
+    path.write_text("\n\n".join(kept) + "\n\n")
 
 
 class TerminalAgentTUI(
@@ -289,7 +320,7 @@ class TerminalAgentTUI(
             completer=self._input_completer,
             auto_suggest=self._slash_argument_hint,
             complete_while_typing=False,  # 通过 Tab/上下键手动触发补全
-            history=InMemoryHistory(),
+            history=self._create_input_history(),
             style="class:input.line",
             get_line_prefix=_input_line_prefix,
         )
@@ -609,6 +640,18 @@ class TerminalAgentTUI(
             return
         self._schedule_background(self._submit_user_message(queued))
 
+    def _create_input_history(self) -> FileHistory | InMemoryHistory:
+        """Create persistent FileHistory based on cwd, with fallback to InMemoryHistory."""
+        try:
+            session_cwd = getattr(self._session, "_cwd", None)
+            cwd = str(Path(session_cwd).expanduser().resolve()) if session_cwd else str(Path.cwd().resolve())
+            history_path = _get_input_history_path(cwd)
+            _truncate_file_history(history_path, _INPUT_HISTORY_MAX_ENTRIES)
+            return FileHistory(str(history_path))
+        except Exception:
+            logger.debug("Failed to create FileHistory, falling back to InMemoryHistory", exc_info=True)
+            return InMemoryHistory()
+
     def _input_placeholder_hint(self) -> str | None:
         if self._ui_mode != UIMode.NORMAL:
             return None

{comate_cli-0.2.7 → comate_cli-0.3.0}/comate_cli/terminal_agent/tui_parts/input_behavior.py

@@ -149,7 +149,7 @@ class InputBehaviorMixin:
         self._refresh_layers()
         self._schedule_background(self._submit_user_message(normalized))
 
-    def _clear_input_area(self) -> None:
+    def _clear_input_area(self, *, save_to_history: bool = False) -> None:
         self._clear_paste_state()
         self._last_input_len = 0
         self._last_input_text = ""
@@ -158,7 +158,14 @@ class InputBehaviorMixin:
         buffer.cancel_completion()
         self._suppress_input_change_hook = True
         try:
-            buffer.set_document(Document("", cursor_position=0), bypass_readonly=True)
+            if save_to_history:
+                buffer.reset(
+                    Document("", cursor_position=0), append_to_history=True
+                )
+            else:
+                buffer.set_document(
+                    Document("", cursor_position=0), bypass_readonly=True
+                )
         finally:
             self._suppress_input_change_hook = False
 
@@ -310,7 +317,7 @@ class InputBehaviorMixin:
 
         if self._input_area.buffer.complete_state is not None:
             self._input_area.buffer.cancel_completion()
-        self._clear_input_area()
+        self._clear_input_area(save_to_history=True)
 
         # busy 或 initializing 时：非斜杠命令 → 入队，斜杠命令 → 交由命令分发决定
         is_busy = self._busy or self._initializing

{comate_cli-0.2.7 → comate_cli-0.3.0}/comate_cli/terminal_agent/tui_parts/render_panels.py

@@ -576,7 +576,7 @@ class RenderPanelsMixin:
                 if clipped.startswith("✓ "):
                     symbol, text = "✓", clipped[2:]
                     symbol_style = "fg:#86EFAC"
-                    text_style = "fg:#6B7280 strike"
+                    text_style = "fg:#4B5563 strike"
                 elif clipped.startswith("◼ "):
                     symbol, text = "◼", clipped[2:]
                     symbol_style = "fg:#F97316"

{comate_cli-0.2.7 → comate_cli-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.2.7"
+version = "0.3.0"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
 requires-python = ">=3.11"

comate_cli-0.3.0/tests/test_app_print_mode.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import asyncio
+import unittest
+from io import StringIO
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from comate_agent_sdk.agent import TextEvent, StopEvent, SessionInitEvent
+
+
+class TestRunPrintMode(unittest.TestCase):
+    """Tests for _run_print_mode in app.py."""
+
+    def test_print_mode_outputs_last_text_event(self):
+        """Should output only the last TextEvent.content to stdout."""
+        from comate_cli.terminal_agent.app import _run_print_mode
+
+        mock_session = MagicMock()
+        mock_session.query_stream = MagicMock(return_value=_async_iter([
+            SessionInitEvent(session_id="test"),
+            TextEvent(content="first answer"),
+            TextEvent(content="final answer"),
+            StopEvent(reason="completed"),
+        ]))
+        mock_session.close = AsyncMock()
+        mock_session.shutdown = AsyncMock()
+
+        captured = StringIO()
+        with patch("comate_cli.terminal_agent.app.ChatSession", return_value=mock_session):
+            with patch("comate_cli.terminal_agent.app._preload_mcp_in_tui", new_callable=AsyncMock):
+                with patch("comate_cli.terminal_agent.app._graceful_shutdown", new_callable=AsyncMock):
+                    with patch("sys.stdout", captured):
+                        asyncio.run(_run_print_mode(
+                            MagicMock(), "test prompt", project_root=MagicMock()
+                        ))
+
+        self.assertIn("final answer", captured.getvalue())
+        self.assertNotIn("first answer", captured.getvalue())
+
+    def test_print_mode_no_text_event_silent_exit(self):
+        """No TextEvent → silent exit, no output."""
+        from comate_cli.terminal_agent.app import _run_print_mode
+
+        mock_session = MagicMock()
+        mock_session.query_stream = MagicMock(return_value=_async_iter([
+            SessionInitEvent(session_id="test"),
+            StopEvent(reason="completed"),
+        ]))
+        mock_session.close = AsyncMock()
+        mock_session.shutdown = AsyncMock()
+
+        captured = StringIO()
+        with patch("comate_cli.terminal_agent.app.ChatSession", return_value=mock_session):
+            with patch("comate_cli.terminal_agent.app._preload_mcp_in_tui", new_callable=AsyncMock):
+                with patch("comate_cli.terminal_agent.app._graceful_shutdown", new_callable=AsyncMock):
+                    with patch("sys.stdout", captured):
+                        asyncio.run(_run_print_mode(
+                            MagicMock(), "test", project_root=MagicMock()
+                        ))
+
+        self.assertEqual(captured.getvalue(), "")
+
+    def test_print_mode_appends_newline_if_missing(self):
+        """Output should end with newline even if content doesn't."""
+        from comate_cli.terminal_agent.app import _run_print_mode
+
+        mock_session = MagicMock()
+        mock_session.query_stream = MagicMock(return_value=_async_iter([
+            SessionInitEvent(session_id="test"),
+            TextEvent(content="no newline"),
+            StopEvent(reason="completed"),
+        ]))
+        mock_session.close = AsyncMock()
+        mock_session.shutdown = AsyncMock()
+
+        captured = StringIO()
+        with patch("comate_cli.terminal_agent.app.ChatSession", return_value=mock_session):
+            with patch("comate_cli.terminal_agent.app._preload_mcp_in_tui", new_callable=AsyncMock):
+                with patch("comate_cli.terminal_agent.app._graceful_shutdown", new_callable=AsyncMock):
+                    with patch("sys.stdout", captured):
+                        asyncio.run(_run_print_mode(
+                            MagicMock(), "test", project_root=MagicMock()
+                        ))
+
+        self.assertTrue(captured.getvalue().endswith("\n"))
+
+
+async def _async_iter(items):
+    for item in items:
+        yield item