zino-cli 0.1.0__tar.gz

zino_cli-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: zino-cli
+Version: 0.1.0
+Summary: Minimal CLI client for zino-daemon
+Project-URL: Repository, https://github.com/you/yourrepo
+Requires-Python: >=3.11
+Requires-Dist: zino-common

zino_cli-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "zino-cli"
+version = "0.1.0"
+description = "Minimal CLI client for zino-daemon"
+requires-python = ">=3.11"
+readme = "README.md"
+dependencies = [
+    "zino-common",
+]
+
+[project.scripts]
+zino-cli = "zino_cli:main"
+
+[project.urls]
+Repository = "https://github.com/you/yourrepo"

zino_cli-0.1.0/src/zino_cli/__init__.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+zino-cli — minimal test client for zino-daemon.
+
+Usage:
+  python3 zino-cli.py "your message here"
+  python3 zino-cli.py --config /path/to/ZINO.toml "your message here"
+"""
+
+import asyncio
+import os
+import sys
+import tomllib
+from pathlib import Path
+
+from zino_common import send_msg, recv_msg, open_uds
+
+SPINNER_CHARS = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+
+async def spinner(description: str):
+    i = 0
+    try:
+        while True:
+            print(f"\r  {SPINNER_CHARS[i % len(SPINNER_CHARS)]} {description}", end="", flush=True)
+            await asyncio.sleep(0.1)
+            i += 1
+    except asyncio.CancelledError:
+        print(f"\r  ✓ {description}", flush=True)
+
+
+def load_socket(config_path: str) -> str:
+    p = Path(config_path)
+    if not p.exists():
+        return "/run/zino/daemon.sock"
+    with open(p, "rb") as f:
+        config = tomllib.load(f)
+    return config.get("daemon", {}).get("socket", "/run/zino/daemon.sock")
+
+
+def _tool_progress_label(kind: str, name: str, data: dict) -> str | None:
+    """
+    Derive a human-readable spinner label from a tool_progress packet.
+    Returns None when the packet should not update the spinner
+    (e.g. streaming sub-agent text deltas, which are printed directly).
+    """
+    if kind == "tool_call":
+        status = data.get("status", "")
+        if status == "running":
+            executor = data.get("executor", name)
+            return f"{name}  [{executor}]"
+        if status == "complete":
+            exit_code = data.get("exit_code", 0)
+            suffix = "✗ non-zero exit" if exit_code != 0 else "done"
+            has_stderr = data.get("has_stderr", False)
+            if exit_code == 0 and has_stderr:
+                suffix = "done (stderr)"
+            return f"{name}  {suffix}"
+
+    elif kind == "task":
+        status = data.get("status", "")
+        if status == "thinking":
+            return f"{name}  iteration {data.get('iteration', '?')} — thinking"
+        if status == "running_tool":
+            tool = data.get("tool", "")
+            executor = data.get("executor", "")
+            return f"{name}  running {tool} [{executor}]"
+        if status == "tool_complete":
+            tool = data.get("tool", "")
+            exit_code = data.get("exit_code", 0)
+            flag = "" if exit_code == 0 else " ✗"
+            return f"{name}  {tool} complete{flag}"
+        if data.get("done"):
+            return None  # spinner will be cancelled by tool_done
+
+    return None
+
+
+async def send_request(socket_path: str, message: str, channel_id: str | None):
+    reader, writer = await open_uds(socket_path)
+
+    payload = {"message": message}
+    if channel_id:
+        payload["channel_id"] = channel_id
+
+    await send_msg(writer, payload)
+
+    spinner_task = None
+    current_label = ""
+    in_subagent = False  # True while streaming sub-agent text deltas
+
+    def _cancel_spinner():
+        nonlocal spinner_task, in_subagent
+        if spinner_task:
+            spinner_task.cancel()
+            spinner_task = None
+        in_subagent = False
+
+    async def _await_spinner():
+        nonlocal spinner_task
+        if spinner_task:
+            try:
+                await spinner_task
+            except asyncio.CancelledError:
+                pass
+            spinner_task = None
+
+    async def _set_spinner(label: str):
+        nonlocal spinner_task, current_label
+        if spinner_task and label == current_label:
+            return  # no change needed
+        _cancel_spinner()
+        current_label = label
+        spinner_task = asyncio.create_task(spinner(label))
+
+    try:
+        while True:
+            packet = await recv_msg(reader)
+            ptype = packet.get("type")
+
+            if ptype == "chunk":
+                # Primary model streaming — spinner should not be running here,
+                # but guard in case of interleaving
+                if spinner_task:
+                    _cancel_spinner()
+                    await _await_spinner()
+                    print()
+                print(packet.get("delta", ""), end="", flush=True)
+
+            elif ptype == "tool_start":
+                # Ensure any trailing primary-model text ends cleanly
+                print()
+                desc = packet.get("description", "working...")
+                await _set_spinner(desc)
+
+            elif ptype == "tool_progress":
+                kind = packet.get("kind", "")
+                name = packet.get("name", "")
+                data = packet.get("data", {})
+
+                if kind == "task" and "delta" in data:
+                    # Sub-agent streaming text — pause spinner, print indented,
+                    # then resume
+                    if spinner_task:
+                        _cancel_spinner()
+                        await _await_spinner()
+                        if not in_subagent:
+                            # First delta for this sub-agent block: newline + prefix
+                            print(f"\n  ┆ ", end="", flush=True)
+                            in_subagent = True
+                    print(data["delta"], end="", flush=True)
+                else:
+                    # Status update — resume spinner with new label
+                    if in_subagent:
+                        print()  # close out sub-agent text line
+                        in_subagent = False
+                    label = _tool_progress_label(kind, name, data)
+                    if label:
+                        await _set_spinner(label)
+
+            elif ptype == "tool_done":
+                if in_subagent:
+                    print()
+                    in_subagent = False
+                _cancel_spinner()
+                await _await_spinner()
+
+            elif ptype == "done":
+                if in_subagent:
+                    print()
+                print()  # final newline after primary stream
+                break
+
+            elif ptype == "error":
+                print(f"\nError: {packet.get('message')}", file=sys.stderr)
+                break
+
+            else:
+                print(f"\nUnknown packet: {packet}", file=sys.stderr)
+                break
+
+    finally:
+        _cancel_spinner()
+        await _await_spinner()
+        writer.close()
+        await writer.wait_closed()
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="zino-cli: test client for zino-daemon")
+    parser.add_argument("message", nargs="*", help="Message to send")
+    parser.add_argument("--channel",    "-ch", default=None)
+    parser.add_argument("--config",     "-c",  default=os.environ.get("ZINO_CONFIG", "ZINO.toml"))
+    args = parser.parse_args()
+
+    message = " ".join(args.message) if args.message else "What is today's date?"
+    socket_path = load_socket(args.config)
+
+    asyncio.run(send_request(socket_path, message, args.channel))
+
+if __name__ == "__main__":
+    main()