teardrop-cli 0.3.3__tar.gz → 0.3.4__tar.gz

{teardrop_cli-0.3.3 → teardrop_cli-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: teardrop-cli
-Version: 0.3.3
+Version: 0.3.4
 Summary: Command-line interface for the Teardrop AI agent platform
 Project-URL: Homepage, https://github.com/teardrop-ai/teardrop-cli
 Project-URL: Repository, https://github.com/teardrop-ai/teardrop-cli

{teardrop_cli-0.3.3 → teardrop_cli-0.3.4}/docs/cli-reference.md

@@ -133,6 +133,13 @@ teardrop schedules create \
   --interval-seconds 3600 \
   --json
 
+# Read the prompt from a UTF-8 file (or '-' for stdin) instead of --prompt:
+teardrop schedules create \
+  --name hourly-briefing \
+  --prompt-file ./task.md \
+  --interval-seconds 3600 \
+  --json
+
 teardrop schedules list --json
 teardrop schedules get <schedule-id> --json
 teardrop schedules update <schedule-id> --enabled false --json
@@ -142,6 +149,8 @@ teardrop schedules delete <schedule-id>
 teardrop schedules delete <schedule-id> --yes
 ```
 
+Exactly one of `--prompt` or `--prompt-file` is required. `--prompt-file` reads UTF-8 (a leading BOM is stripped) and preserves newlines and emoji; pass `-` to read the prompt from stdin.
+
 Non-JSON list output includes: `ID`, `Name`, `Enabled`, `Interval`, `Consecutive Failures`, `Last Run At`.
 
 Run history output includes: `Run ID`, `Status`, `Cost (USDC)`, `Error Message`, `Executed At`.

{teardrop_cli-0.3.3 → teardrop_cli-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "teardrop-cli"
-version = "0.3.3"
+version = "0.3.4"
 description = "Command-line interface for the Teardrop AI agent platform"
 readme = "README.md"
 license = { file = "LICENSE" }

{teardrop_cli-0.3.3 → teardrop_cli-0.3.4}/src/teardrop_cli/cli.py

@@ -8,11 +8,30 @@ modules are imported only when the subcommand is actually invoked, keeping
 
 from __future__ import annotations
 
+import sys
+from contextlib import suppress
+
 import click
 
 from teardrop_cli._lazy import LazyGroup
 
 
+def _force_utf8_stdio() -> None:
+    """Reconfigure stdout/stderr to UTF-8.
+
+    On legacy Windows consoles the default codec (e.g. cp1252) cannot encode
+    non-ASCII characters such as emoji in prompts or JSON output, raising
+    ``UnicodeEncodeError``. Forcing UTF-8 keeps ``--json`` and rich output
+    working regardless of the console code page.
+    """
+    for stream in (sys.stdout, sys.stderr):
+        with suppress(AttributeError, ValueError):
+            stream.reconfigure(encoding="utf-8")  # type: ignore[union-attr]
+
+
+_force_utf8_stdio()
+
+
 @click.group(
     name="teardrop",
     cls=LazyGroup,

{teardrop_cli-0.3.3 → teardrop_cli-0.3.4}/src/teardrop_cli/commands/event_triggers.py

@@ -23,6 +23,15 @@ def _to_dict(value: Any) -> dict[str, Any]:
     return dict(value)
 
 
+def _list_items(value: Any) -> Any:
+    if isinstance(value, dict):
+        return value.get("items") or []
+    items = getattr(value, "items", None)
+    if items is not None and not callable(items):
+        return items
+    return value
+
+
 def _to_page_dict(value: Any) -> dict[str, Any]:
     data = _to_dict(value)
     data["items"] = [_to_dict(item) for item in data.get("items") or []]
@@ -223,7 +232,10 @@ def list_cmd(
         operation=lambda client: client.event_triggers.list(),
     )
 
-    items = [_to_dict(item) for item in result]
+    # The SDK returns an EventTriggerListResponse model with an ``items``
+    # field (plus ``next_cursor``). Iterating the model directly would yield
+    # its field tuples, so unwrap ``.items`` when present.
+    items = [_to_dict(item) for item in _list_items(result)]
     if as_json:
         print_json(items)
         return

{teardrop_cli-0.3.3 → teardrop_cli-0.3.4}/src/teardrop_cli/commands/schedules.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import asyncio
+import sys
 from collections.abc import Awaitable, Callable
+from pathlib import Path
 from typing import Annotated, Any
 
 import typer
@@ -23,6 +25,32 @@ def _to_dict(value: Any) -> dict[str, Any]:
     return dict(value)
 
 
+def _list_items(value: Any) -> Any:
+    if isinstance(value, dict):
+        return value.get("items") or []
+    items = getattr(value, "items", None)
+    if items is not None and not callable(items):
+        return items
+    return value
+
+
+def _read_prompt_file(path: str) -> str:
+    """Read prompt text from *path* (UTF-8), or stdin when *path* is ``-``."""
+    from teardrop_cli.formatting import print_error
+
+    try:
+        if path == "-":
+            return sys.stdin.read()
+        text = Path(path).read_text(encoding="utf-8-sig")
+        return text
+    except UnicodeError as exc:
+        print_error(f"Could not decode --prompt-file {path!r} as UTF-8: {exc}")
+        raise typer.Exit(1) from None
+    except OSError as exc:
+        print_error(f"Could not read --prompt-file {path!r}: {exc}")
+        raise typer.Exit(1) from None
+
+
 def _to_page_dict(value: Any) -> dict[str, Any]:
     data = _to_dict(value)
     data["items"] = [_to_dict(item) for item in data.get("items") or []]
@@ -132,11 +160,22 @@ def _validate_callback_options(
 @app.command()
 def create(
     name: Annotated[str, typer.Option("--name", help="Schedule name.")],
-    prompt: Annotated[str, typer.Option("--prompt", help="Prompt to run.")],
     interval_seconds: Annotated[
         int,
         typer.Option("--interval-seconds", min=1, help="Run interval in seconds."),
     ],
+    prompt: Annotated[
+        str | None,
+        typer.Option("--prompt", help="Prompt to run. Mutually exclusive with --prompt-file."),
+    ] = None,
+    prompt_file: Annotated[
+        str | None,
+        typer.Option(
+            "--prompt-file",
+            help="Read the prompt from a UTF-8 file. Use '-' to read from stdin. "
+            "Mutually exclusive with --prompt.",
+        ),
+    ] = None,
     callback_url: Annotated[
         str | None,
         typer.Option("--callback-url", help="Optional callback URL invoked after each run."),
@@ -147,7 +186,16 @@ def create(
     """Create a new interval schedule."""
     from teardrop import CreateScheduleRequest
 
-    from teardrop_cli.formatting import print_json, print_success
+    from teardrop_cli.formatting import print_error, print_json, print_success
+
+    if prompt is not None and prompt_file is not None:
+        print_error("Use either --prompt or --prompt-file, not both.")
+        raise typer.Exit(1) from None
+    if prompt is None and prompt_file is None:
+        print_error("Provide either --prompt or --prompt-file.")
+        raise typer.Exit(1) from None
+    if prompt_file is not None:
+        prompt = _read_prompt_file(prompt_file)
 
     request = CreateScheduleRequest(
         name=name,
@@ -185,7 +233,10 @@ def list_cmd(
         operation=lambda client: client.schedules.list(),
     )
 
-    items = [_to_dict(item) for item in result]
+    # The SDK returns a ScheduledRunListResponse model with an ``items``
+    # field (plus ``next_cursor``). Iterating the model directly would yield
+    # its field tuples, so unwrap ``.items`` when present.
+    items = [_to_dict(item) for item in _list_items(result)]
     if as_json:
         print_json(items)
         return

{teardrop_cli-0.3.3 → teardrop_cli-0.3.4}/tests/smoke/conftest.py

@@ -62,6 +62,7 @@ def subprocess_cli(tmp_path: Path) -> Callable[..., subprocess.CompletedProcess]
             capture_output=True,
             stdin=subprocess.PIPE,
             text=True,
+            encoding="utf-8",
             env=env,
         )
 

{teardrop_cli-0.3.3 → teardrop_cli-0.3.4}/tests/test_schedules.py

@@ -70,6 +70,84 @@ class TestCreate:
         assert '"name": "hourly-sync"' in result.output
         assert '"schedule_kind": "interval"' in result.output
 
+    def test_create_prompt_file(self, runner, patch_get_client, mock_client, tmp_path):
+        prompt_file = tmp_path / "task.md"
+        prompt_file.write_text("Line one\nLine two 📊\n", encoding="utf-8")
+        mock_client.schedules.create.return_value = _schedule(name="from-file")
+        result = runner.invoke(
+            app,
+            [
+                "schedules",
+                "create",
+                "--name",
+                "from-file",
+                "--prompt-file",
+                str(prompt_file),
+                "--interval-seconds",
+                "60",
+            ],
+        )
+        assert result.exit_code == 0, result.output
+        request = mock_client.schedules.create.await_args.args[0]
+        assert request.prompt == "Line one\nLine two 📊\n"
+
+    def test_create_prompt_file_mutually_exclusive(self, runner, patch_get_client, mock_client):
+        result = runner.invoke(
+            app,
+            [
+                "schedules",
+                "create",
+                "--name",
+                "x",
+                "--prompt",
+                "inline",
+                "--prompt-file",
+                "somefile.md",
+                "--interval-seconds",
+                "60",
+            ],
+        )
+        assert result.exit_code == 1
+        assert "not both" in result.output
+
+    def test_create_requires_prompt_source(self, runner, patch_get_client, mock_client):
+        result = runner.invoke(
+            app,
+            [
+                "schedules",
+                "create",
+                "--name",
+                "x",
+                "--interval-seconds",
+                "60",
+            ],
+        )
+        assert result.exit_code == 1
+        assert "Provide either --prompt or --prompt-file" in result.output
+        mock_client.schedules.create.assert_not_awaited()
+
+    def test_create_prompt_file_rejects_invalid_utf8(
+        self, runner, patch_get_client, mock_client, tmp_path
+    ):
+        prompt_file = tmp_path / "invalid.bin"
+        prompt_file.write_bytes(b"\xff\xfe\xfd")
+        result = runner.invoke(
+            app,
+            [
+                "schedules",
+                "create",
+                "--name",
+                "x",
+                "--prompt-file",
+                str(prompt_file),
+                "--interval-seconds",
+                "60",
+            ],
+        )
+        assert result.exit_code == 1
+        assert "as UTF-8" in result.output
+        mock_client.schedules.create.assert_not_awaited()
+
 
 class TestList:
     def test_list(self, runner: CliRunner, patch_get_client, mock_client):
@@ -91,6 +169,39 @@ class TestList:
         assert result.exit_code == 0, result.output
         assert '"name": "nightly-report"' in result.output
 
+    def test_list_handles_sdk_list_response_model(
+        self, runner: CliRunner, patch_get_client, mock_client
+    ):
+        # The real SDK returns a ScheduledRunListResponse model with an
+        # ``items`` field (plus ``next_cursor``), not a plain list.
+        from teardrop.models import ScheduledRun, ScheduledRunListResponse
+
+        model = ScheduledRunListResponse(
+            items=[
+                ScheduledRun(
+                    **_schedule(
+                        name="model-backed",
+                        org_id="org_1",
+                        user_id="user_1",
+                    )
+                )
+            ],
+            next_cursor=None,
+        )
+        mock_client.schedules.list.return_value = model
+        result = runner.invoke(app, ["schedules", "list"])
+        assert result.exit_code == 0, result.output
+        assert "model-backed" in result.output
+
+    def test_list_handles_dict_response_envelope(self, runner, patch_get_client, mock_client):
+        mock_client.schedules.list.return_value = {
+            "items": [_schedule(name="dict-backed")],
+            "next_cursor": None,
+        }
+        result = runner.invoke(app, ["schedules", "list", "--json"])
+        assert result.exit_code == 0, result.output
+        assert '"name": "dict-backed"' in result.output
+
 
 class TestGet:
     def test_get_json(self, runner: CliRunner, patch_get_client, mock_client):