comate-cli 0.7.8__tar.gz → 0.7.9__tar.gz

{comate_cli-0.7.8 → comate_cli-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.8
+Version: 0.7.9
 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.8 → comate_cli-0.7.9}/comate_cli/main.py

@@ -26,6 +26,15 @@ class _ArgumentError(ValueError):
     """Raised when CLI arguments are invalid."""
 
 
+PRINT_STDIN_IDLE_TIMEOUT_SECONDS = 3.0
+PRINT_OUTPUT_FORMAT_TEXT = "text"
+PRINT_OUTPUT_FORMAT_JSON = "json"
+PRINT_OUTPUT_FORMATS = frozenset({PRINT_OUTPUT_FORMAT_TEXT, PRINT_OUTPUT_FORMAT_JSON})
+PRINT_OUTPUT_FORMAT_UNSUPPORTED = frozenset({"stream-json"})
+
+ParsedArgs = tuple[bool, str | None, bool, str | None, str]
+
+
 class _TerminalStateGuard:
     """Best-effort tty restore guard for abnormal shutdown paths."""
 
@@ -200,37 +209,68 @@ def _usage_text() -> str:
     return (
         "Usage:\n"
         "  comate [--rpc-stdio]\n"
-        "  comate -p <prompt>\n"
+        "  comate -p [--output-format text|json] <prompt>\n"
         "  comate resume [<session_id>] [--rpc-stdio]\n"
         "  comate mcp <subcommand> [options]"
     )
 
 
-def _parse_args(argv: list[str]) -> tuple[bool, str | None, bool, str | None]:
+def _parse_args(argv: list[str]) -> ParsedArgs:
     rpc_stdio = False
     print_mode = False
+    output_format = PRINT_OUTPUT_FORMAT_TEXT
+    output_format_explicit = False
     positionals: list[str] = []
-    for arg in argv:
+
+    index = 0
+    while index < len(argv):
+        arg = argv[index]
         if arg == "--rpc-stdio":
             rpc_stdio = True
+            index += 1
             continue
         if arg in ("-p", "--print"):
             print_mode = True
+            index += 1
+            continue
+        if arg == "--output-format" or arg.startswith("--output-format="):
+            output_format_explicit = True
+            if arg == "--output-format":
+                index += 1
+                if index >= len(argv):
+                    raise _ArgumentError("--output-format requires one of: text, json")
+                value = argv[index]
+            else:
+                value = arg.partition("=")[2]
+                if not value:
+                    raise _ArgumentError("--output-format requires one of: text, json")
+            if value in PRINT_OUTPUT_FORMAT_UNSUPPORTED:
+                raise _ArgumentError(
+                    "--output-format stream-json is not supported in this release"
+                )
+            if value not in PRINT_OUTPUT_FORMATS:
+                raise _ArgumentError(f"Unsupported --output-format: {value}")
+            output_format = value
+            index += 1
             continue
         if arg.startswith("-"):
             raise _ArgumentError(f"Unknown option: {arg}")
         positionals.append(arg)
+        index += 1
+
+    if output_format_explicit and not print_mode:
+        raise _ArgumentError("--output-format can only be used with -p/--print")
 
     # -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
+        return rpc_stdio, None, False, print_prompt, output_format
 
     # Non -p mode: original logic
     if not positionals:
-        return rpc_stdio, None, False, None
+        return rpc_stdio, None, False, None, output_format
 
     command = positionals[0]
     if command != "resume":
@@ -241,14 +281,75 @@ def _parse_args(argv: list[str]) -> tuple[bool, str | None, bool, str | None]:
             raise _ArgumentError(
                 "resume without <session_id> does not support --rpc-stdio"
             )
-        return rpc_stdio, None, True, None
+        return rpc_stdio, None, True, None, output_format
 
     if len(positionals) == 2:
-        return rpc_stdio, positionals[1], False, None
+        return rpc_stdio, positionals[1], False, None, output_format
 
     raise _ArgumentError("resume accepts at most one <session_id>")
 
 
+def _read_stdin_posix_idle_drain(
+    stdin: object,
+    *,
+    timeout_seconds: float,
+    chunk_size: int = 64 * 1024,
+) -> str:
+    import select
+
+    fileno = getattr(stdin, "fileno", None)
+    if not callable(fileno):
+        read = getattr(stdin, "read", None)
+        return str(read()) if callable(read) else ""
+
+    try:
+        fd = fileno()
+    except (AttributeError, OSError, ValueError):
+        read = getattr(stdin, "read", None)
+        return str(read()) if callable(read) else ""
+
+    chunks: list[bytes] = []
+    while True:
+        readable, _, _ = select.select([fd], [], [], timeout_seconds)
+        if not readable:
+            break
+        try:
+            chunk = os.read(fd, chunk_size)
+        except BlockingIOError:
+            break
+        except OSError:
+            break
+        if not chunk:
+            break
+        chunks.append(chunk)
+
+    encoding = str(getattr(stdin, "encoding", "") or "utf-8")
+    return b"".join(chunks).decode(encoding, errors="replace")
+
+
+def _read_stdin_if_ready(
+    stdin: object,
+    *,
+    timeout_seconds: float = PRINT_STDIN_IDLE_TIMEOUT_SECONDS,
+) -> str:
+    isatty = getattr(stdin, "isatty", None)
+    if callable(isatty) and isatty():
+        return ""
+
+    if os.name != "posix":
+        read = getattr(stdin, "read", None)
+        return str(read()) if callable(read) else ""
+
+    try:
+        return _read_stdin_posix_idle_drain(
+            stdin,
+            timeout_seconds=timeout_seconds,
+        )
+    except (OSError, ValueError):
+        read = getattr(stdin, "read", None)
+        return str(read()) if callable(read) else ""
+
+
 def main(argv: list[str] | None = None) -> None:
     run_argv = list(argv) if argv is not None else sys.argv[1:]
 
@@ -278,7 +379,9 @@ def main(argv: list[str] | None = None) -> None:
     _app_import_done_perf = time.perf_counter()
 
     try:
-        rpc_stdio, resume_session_id, resume_select, print_prompt = _parse_args(run_argv)
+        rpc_stdio, resume_session_id, resume_select, print_prompt, print_output_format = (
+            _parse_args(run_argv)
+        )
     except _ArgumentError as exc:
         sys.stderr.write(f"{exc}\n{_usage_text()}\n")
         raise SystemExit(2) from exc
@@ -286,9 +389,7 @@ def main(argv: list[str] | None = None) -> None:
     # 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()
+        stdin_text = _read_stdin_if_ready(sys.stdin)
         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")
@@ -302,6 +403,7 @@ def main(argv: list[str] | None = None) -> None:
                 resume_session_id=resume_session_id,
                 resume_select=resume_select,
                 print_message=print_message,
+                print_output_format=print_output_format,
                 process_start_perf=_PROCESS_START_PERF,
                 app_import_start_perf=_app_import_start_perf,
                 app_import_done_perf=_app_import_done_perf,

{comate_cli-0.7.8 → comate_cli-0.7.9}/comate_cli/terminal_agent/app.py

@@ -5,7 +5,6 @@ import logging
 import os
 import random  # noqa: F401 - tests patch this module-level import for deterministic startup tips.
 import signal
-import sys
 import threading
 import time
 from collections.abc import Iterator
@@ -20,13 +19,30 @@ from comate_cli.terminal_agent.startup_profile import StartupProfiler
 if TYPE_CHECKING:
     from comate_agent_sdk.agent.chat_session import ChatSession
     from comate_agent_sdk.agent.core.template import AgentTemplate as Agent
-    from comate_agent_sdk.agent.events import TextEvent
     from comate_cli.terminal_agent.event_renderer import EventRenderer
     from comate_cli.terminal_agent.update_check import UpdateInfo
 
 console = Console()
 logger = logging.getLogger(__name__)
 _UPDATE_CHECK_DELAY_S = 1.0
+PRINT_MODE_DISALLOWED_TOOLS = (
+    "TeamCreate",
+    "TeamDelete",
+    "SendMessage",
+    "YieldTurn",
+)
+
+
+def _merge_disallowed_tools(*groups: tuple[str, ...] | None) -> tuple[str, ...] | None:
+    merged: list[str] = []
+    seen: set[str] = set()
+    for group in groups:
+        for name in group or ():
+            if name in seen:
+                continue
+            seen.add(name)
+            merged.append(name)
+    return tuple(merged) or None
 
 
 def _resolve_cli_project_root() -> Path:
@@ -221,6 +237,18 @@ def _import_preflight_runner():
     return run_preflight_if_needed
 
 
+def _import_print_mode_runner():
+    from comate_cli.terminal_agent.print_mode import run_print_mode
+
+    return run_print_mode
+
+
+def _import_print_mode_json_error_writer():
+    from comate_cli.terminal_agent.print_mode import write_json_error_result
+
+    return write_json_error_result
+
+
 def print_logo(*args, **kwargs) -> None:
     from comate_cli.terminal_agent.logo import print_logo as _print_logo
 
@@ -357,6 +385,7 @@ def _build_agent(
     *,
     project_root: Path | None = None,
     profiler: StartupProfiler | None = None,
+    extra_disallowed_tools: tuple[str, ...] | None = None,
 ) -> Agent:
     Agent, AgentConfig, CompactionConfig, EnvOptions = _import_sdk_agent_components(profiler)
     from comate_cli.terminal_agent.config import store
@@ -367,6 +396,7 @@ def _build_agent(
     snapshot = store.load()
     if profiler is not None:
         profiler.mark("agent.config.load.done")
+    disallowed_tools = _merge_disallowed_tools(extra_disallowed_tools)
 
     agent_config = AgentConfig(
         role="software_engineering",
@@ -374,11 +404,13 @@ def _build_agent(
         env_options=EnvOptions(system_env=True, git_env=True),
         use_streaming_task=True,
         include_cost=bool(getattr(snapshot, "token_cost_enabled", False)),
+        strict_hook_settings=False,
         memory_background_enabled=snapshot.memory_background_enabled,
         memory_dreaming_enabled=snapshot.memory_dreaming_enabled,
         compaction=CompactionConfig(
             threshold_ratio=snapshot.compaction_threshold_ratio,
         ),
+        disallowed_tools=disallowed_tools,
     )
     if profiler is not None:
         profiler.mark("agent.construct.start")
@@ -502,28 +534,17 @@ async def _run_print_mode(
     message: str,
     *,
     project_root: Path,
+    output_format: str = "text",
 ) -> None:
-    ChatSession, TextEvent = _import_print_mode_components()
-    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)
+    run_print_mode = _import_print_mode_runner()
+    await run_print_mode(
+        agent,
+        message,
+        project_root=project_root,
+        output_format=output_format,
+        preload_mcp=_preload_mcp_in_tui,
+        graceful_shutdown=_graceful_shutdown,
+    )
 
 
 def _install_event_loop_exception_handler() -> None:
@@ -557,6 +578,7 @@ async def run(
     resume_session_id: str | None = None,
     resume_select: bool = False,
     print_message: str | None = None,
+    print_output_format: str = "text",
     process_start_perf: float | None = None,
     app_import_start_perf: float | None = None,
     app_import_done_perf: float | None = None,
@@ -576,14 +598,25 @@ async def run(
     profiler.mark("cli_project_root.done")
     profiler.mark("preflight.start")
     run_preflight_if_needed = _import_preflight_runner()
+    preflight_console = console
+    if print_message is not None and print_output_format == "json":
+        preflight_console = Console(stderr=True)
     preflight_result = await run_preflight_if_needed(
-        console=console,
+        console=preflight_console,
         project_root=project_root,
         interactive=not rpc_stdio and print_message is None,
     )
     profiler.mark("preflight.done")
     if preflight_result.should_abort_launch:
         if print_message is not None:
+            if print_output_format == "json":
+                write_json_error_result = _import_print_mode_json_error_writer()
+                detail = preflight_result.detail or preflight_result.status
+                write_json_error_result(
+                    error=f"Preflight failed: {detail}",
+                    stop_reason=None,
+                    session_id=None,
+                )
             raise SystemExit(1)
         return
 
@@ -604,7 +637,13 @@ async def run(
                 return
 
     profiler.mark("agent.build.start")
-    agent = _build_agent(project_root=project_root, profiler=profiler)
+    agent = _build_agent(
+        project_root=project_root,
+        profiler=profiler,
+        extra_disallowed_tools=(
+            PRINT_MODE_DISALLOWED_TOOLS if print_message is not None else None
+        ),
+    )
     profiler.mark("agent.build.done")
 
     if rpc_stdio and resume_select and not resume_session_id:
@@ -628,7 +667,12 @@ async def run(
 
     # --- Print mode branch ---
     if print_message is not None:
-        await _run_print_mode(agent, print_message, project_root=project_root)
+        await _run_print_mode(
+            agent,
+            print_message,
+            project_root=project_root,
+            output_format=print_output_format,
+        )
         return
 
     if resume_select and not resume_session_id:

comate_cli-0.7.9/comate_cli/terminal_agent/print_mode.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import json
+import logging
+import sys
+import time
+import uuid
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from comate_agent_sdk.tokens import UsageSummary
+
+logger = logging.getLogger(__name__)
+
+TEXT_OUTPUT_FORMAT = "text"
+JSON_OUTPUT_FORMAT = "json"
+ERROR_DURING_EXECUTION = "error_during_execution"
+ERROR_MAX_TURNS = "error_max_turns"
+
+
+def _import_print_mode_components() -> tuple[type, type, type, type]:
+    from comate_agent_sdk.agent.chat_session import ChatSession
+    from comate_agent_sdk.agent.events import SessionInitEvent, StopEvent, TextEvent
+
+    return ChatSession, SessionInitEvent, StopEvent, TextEvent
+
+
+@dataclass(slots=True)
+class _PrintRunFacts:
+    final_text: str = ""
+    structured_output: dict[str, Any] | None = None
+    stop_reason: str | None = None
+    session_id: str | None = None
+
+
+def _empty_usage_summary() -> UsageSummary:
+    return UsageSummary(
+        total_prompt_tokens=0,
+        total_prompt_cost=0.0,
+        total_prompt_cached_tokens=0,
+        total_prompt_cached_cost=0.0,
+        total_completion_tokens=0,
+        total_reasoning_tokens=0,
+        total_completion_cost=0.0,
+        total_tokens=0,
+        total_cost=0.0,
+        entry_count=0,
+        by_model={},
+        by_level={},
+        by_source={},
+    )
+
+
+async def _get_usage_or_empty(session: object | None) -> UsageSummary:
+    if session is None:
+        return _empty_usage_summary()
+    get_usage: Callable[..., Awaitable[object]] | None = getattr(session, "get_usage", None)
+    if not callable(get_usage):
+        return _empty_usage_summary()
+    try:
+        usage = await get_usage()
+    except Exception as exc:
+        logger.warning("Print mode failed to collect usage: %s", exc, exc_info=True)
+        return _empty_usage_summary()
+    if isinstance(usage, UsageSummary):
+        return usage
+    return _empty_usage_summary()
+
+
+def _dump_usage(usage: UsageSummary) -> dict[str, Any]:
+    return usage.model_dump(mode="json")
+
+
+def _is_error_stop(stop_reason: str | None) -> bool:
+    return stop_reason is not None and stop_reason != "completed"
+
+
+def _subtype_for_stop(stop_reason: str | None) -> str:
+    if stop_reason == "max_iterations":
+        return ERROR_MAX_TURNS
+    if _is_error_stop(stop_reason):
+        return ERROR_DURING_EXECUTION
+    return "success"
+
+
+def _build_result_payload(
+    *,
+    facts: _PrintRunFacts,
+    usage: UsageSummary,
+    duration_ms: int,
+    errors: list[str] | None = None,
+) -> dict[str, Any]:
+    is_error = bool(errors) or _is_error_stop(facts.stop_reason)
+    subtype = ERROR_DURING_EXECUTION if errors else _subtype_for_stop(facts.stop_reason)
+    payload: dict[str, Any] = {
+        "type": "result",
+        "subtype": subtype,
+        "duration_ms": duration_ms,
+        "duration_api_ms": 0,
+        "is_error": is_error,
+        "num_turns": 1,
+        "stop_reason": facts.stop_reason,
+        "total_cost_usd": usage.total_cost,
+        "usage": _dump_usage(usage),
+        "modelUsage": {},
+        "permission_denials": [],
+        "uuid": str(uuid.uuid4()),
+        "session_id": facts.session_id,
+    }
+    if is_error:
+        payload["errors"] = errors or [f"Run stopped: {facts.stop_reason}"]
+    else:
+        payload["result"] = facts.final_text
+        if facts.structured_output is not None:
+            payload["structured_output"] = facts.structured_output
+    return payload
+
+
+def _write_text_result(text: str) -> None:
+    if not text:
+        return
+    sys.stdout.write(text)
+    if not text.endswith("\n"):
+        sys.stdout.write("\n")
+    sys.stdout.flush()
+
+
+def _write_json_result(payload: dict[str, Any]) -> None:
+    sys.stdout.write(json.dumps(payload, ensure_ascii=False, separators=(",", ":")))
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+
+
+def write_json_error_result(
+    *,
+    error: str,
+    stop_reason: str | None = None,
+    session_id: str | None = None,
+    duration_ms: int = 0,
+) -> None:
+    payload = _build_result_payload(
+        facts=_PrintRunFacts(stop_reason=stop_reason, session_id=session_id),
+        usage=_empty_usage_summary(),
+        duration_ms=duration_ms,
+        errors=[error],
+    )
+    _write_json_result(payload)
+
+
+async def _consume_query_stream(session: object, message: str) -> _PrintRunFacts:
+    ChatSession, SessionInitEvent, StopEvent, TextEvent = _import_print_mode_components()
+    del ChatSession
+    facts = _PrintRunFacts(session_id=str(getattr(session, "session_id", "") or "") or None)
+    async for event in session.query_stream(message):
+        if isinstance(event, SessionInitEvent):
+            facts.session_id = event.session_id
+            continue
+        if isinstance(event, TextEvent):
+            facts.final_text = event.content
+            facts.structured_output = event.structured_output
+            continue
+        if isinstance(event, StopEvent):
+            facts.stop_reason = event.reason
+            error = event.metadata.get("error") if event.metadata else None
+            if error is not None and facts.stop_reason == "interrupted":
+                if isinstance(error, BaseException):
+                    raise RuntimeError(str(error)) from error
+                raise RuntimeError(str(error))
+    return facts
+
+
+async def run_print_mode(
+    agent: object,
+    message: str,
+    *,
+    project_root: Path,
+    output_format: str = TEXT_OUTPUT_FORMAT,
+    preload_mcp: Callable[[object], Awaitable[None]],
+    graceful_shutdown: Callable[[object], Awaitable[None]],
+) -> None:
+    ChatSession, _, _, _ = _import_print_mode_components()
+    session: object | None = None
+    started = time.perf_counter()
+    facts = _PrintRunFacts()
+    try:
+        session = ChatSession(agent, cwd=project_root, persistent=False)
+        facts.session_id = str(getattr(session, "session_id", "") or "") or None
+        await preload_mcp(session)
+        facts = await _consume_query_stream(session, message)
+        usage = await _get_usage_or_empty(session)
+        duration_ms = int((time.perf_counter() - started) * 1000)
+        if output_format == JSON_OUTPUT_FORMAT:
+            payload = _build_result_payload(
+                facts=facts,
+                usage=usage,
+                duration_ms=duration_ms,
+            )
+            _write_json_result(payload)
+            if payload["is_error"]:
+                raise SystemExit(1)
+            return
+        _write_text_result(facts.final_text)
+    except SystemExit:
+        raise
+    except Exception as exc:
+        logger.error("Print mode failed: %s", exc, exc_info=True)
+        duration_ms = int((time.perf_counter() - started) * 1000)
+        usage = await _get_usage_or_empty(session)
+        if output_format == JSON_OUTPUT_FORMAT:
+            payload = _build_result_payload(
+                facts=facts,
+                usage=usage,
+                duration_ms=duration_ms,
+                errors=[str(exc)],
+            )
+            _write_json_result(payload)
+        else:
+            sys.stderr.write(f"Error: {exc}\n")
+        raise SystemExit(1) from exc
+    finally:
+        if session is not None:
+            await graceful_shutdown(session)

{comate_cli-0.7.8 → comate_cli-0.7.9}/pyproject.toml

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