langstage-cli 0.6.43__tar.gz → 0.6.45__tar.gz

{langstage_cli-0.6.43/langstage_cli.egg-info → langstage_cli-0.6.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langstage-cli
-Version: 0.6.43
+Version: 0.6.45
 Summary: The terminal stage for your LangGraph agent — Claude Code-style CLI for any CompiledGraph
 Author-email: Kedar Dabhadkar <kdabhadk@gmail.com>
 License-Expression: MIT
@@ -322,7 +322,9 @@ cat prompt.txt | langstage-cli --demo
 
 Pass `-q/--quiet` to force the same clean output in a terminal. Set
 [`NO_COLOR`](https://no-color.org) to any non-empty value to turn color off in a terminal
-too; the layout and spinner stay, uncolored.
+too; the layout and spinner stay, uncolored. With `TERM=dumb` (Emacs shell, `vim :!`)
+the CLI sends no escape sequences at all: no color, a spinner that prints once, and an
+approval menu you answer by typing a number.
 
 ### Exit codes
 

{langstage_cli-0.6.43 → langstage_cli-0.6.45}/README.md

@@ -284,7 +284,9 @@ cat prompt.txt | langstage-cli --demo
 
 Pass `-q/--quiet` to force the same clean output in a terminal. Set
 [`NO_COLOR`](https://no-color.org) to any non-empty value to turn color off in a terminal
-too; the layout and spinner stay, uncolored.
+too; the layout and spinner stay, uncolored. With `TERM=dumb` (Emacs shell, `vim :!`)
+the CLI sends no escape sequences at all: no color, a spinner that prints once, and an
+approval menu you answer by typing a number.
 
 ### Exit codes
 

{langstage_cli-0.6.43 → langstage_cli-0.6.45}/langstage_cli/cli.py

@@ -61,6 +61,16 @@ BRIGHT_GREEN, BRIGHT_YELLOW = "\033[92m", "\033[93m"
 # strip ANSI, so the pipe/file receives ONLY the agent's reply. Toggled once in
 # main(); the render helpers below read it as a module global.
 _QUIET = False
+# A dumb terminal (TERM=dumb: Emacs shell/compile, vim :!, serial consoles) shows escape
+# sequences as literal text, so it gets none at all: no color (via _disable_ansi()), no
+# animated spinner, no line clears or cursor hide/show, and a typed-number approval
+# menu instead of the arrow-key one. Set once in main(). (gh #182)
+_DUMB_TERM = False
+
+
+def _is_dumb_term() -> bool:
+    """``TERM=dumb``: the long-standing "this terminal can't do escapes" convention."""
+    return os.environ.get("TERM", "").strip().lower() == "dumb"
 
 
 def _is_a_tty(stream) -> bool:
@@ -298,7 +308,7 @@ def rl_wrap(code: str) -> str:
     This causes issues with line wrapping when using input().
     Wrapping with \\001 and \\002 tells readline to ignore these characters.
     """
-    if HAS_READLINE:
+    if HAS_READLINE and code:
         return f"\001{code}\002"
     return code
 
@@ -368,10 +378,17 @@ class Spinner:
             time.sleep(0.08)
 
     def start(self):
-        """Start the spinner."""
-        self.running = True
+        """Start the spinner. On a dumb terminal it can't redraw a line, so print the
+        message once as a plain line and don't animate (gh #182)."""
         self._stopped = False
         self.start_time = time.time()
+        if _DUMB_TERM:
+            try:
+                print(f"{self.message}...", flush=True)
+            except (UnicodeEncodeError, ValueError):
+                pass
+            return
+        self.running = True
         self.thread = threading.Thread(target=self._spin, daemon=True)
         self.thread.start()
 
@@ -399,6 +416,8 @@ class Spinner:
         self.running = False
         if self.thread:
             self.thread.join(timeout=0.2)
+        if _DUMB_TERM:
+            return  # start() printed a whole line; there is nothing to clear (gh #182)
         # Clear the spinner line. With color off (NO_COLOR, or stdout not a terminal:
         # _disable_ansi() has blanked RESET), overwrite it with spaces instead of CSI 2K
         # so that output carries no escape sequence at all. (gh #172)
@@ -1121,20 +1140,31 @@ def _absolutize_file_spec(spec: str) -> str:
     return f"{Path(path_part).expanduser().resolve()}{suffix}"
 
 
-def get_tool_arg_preview(args: Dict[str, Any]) -> str:
-    """Get a preview of the first argument value (nanocode style).
+# Per-value cap on the tool-call card (default output; ``-v`` shows values in full).
+_TOOL_ARG_VALUE_MAX = 50
+
 
-    The value is escaped before it is truncated, so a tool arg can't move the cursor
-    or retitle the terminal, and a cut can't leave half an escape sequence live (gh #180).
+def get_tool_arg_preview(args: Dict[str, Any], verbose: bool = False) -> str:
+    """The arguments a tool was called with, for the tool-call card.
+
+    A lone argument shows as its bare value (``read_file └─ docs/a.md``). Several show
+    as ``name=value`` pairs, every one of them: showing only the first misstated the
+    call, ``add(a=17, b=25)`` read as "add 17" (gh #184). Each value is capped at 50
+    characters unless ``verbose``. Values are escaped before they are truncated, so a
+    tool arg can't move the cursor or retitle the terminal, and a cut can't leave half
+    an escape sequence live (gh #180).
     """
     if not args:
         return ""
-    # Get first value
-    first_val = _escape_controls(str(list(args.values())[0]))
-    # Truncate if needed
-    if len(first_val) > 50:
-        return first_val[:50] + "..."
-    return first_val
+    limit = None if verbose else _TOOL_ARG_VALUE_MAX
+    if not isinstance(args, dict):
+        return _approval_text(args, limit)
+    if len(args) == 1:
+        (value,) = args.values()
+        return _approval_text(str(value), limit)
+    return ", ".join(
+        f"{_approval_text(str(k), None)}={_approval_text(v, limit)}" for k, v in args.items()
+    )
 
 
 # Per-value cap for the HITL approval preview. Values are truncated, never dropped: the
@@ -1476,7 +1506,7 @@ def print_chunk(chunk: Dict[str, Any], verbose: bool = False):
             for tool_call in chunk["tool_calls"]:
                 tool_name = _escape_controls(str(tool_call["name"]))  # gh #180
                 args = tool_call.get("args", {})
-                arg_preview = get_tool_arg_preview(args)
+                arg_preview = get_tool_arg_preview(args, verbose)
 
                 safe_print(f"\n{GREEN}● {tool_name}{RESET}")
                 if arg_preview:
@@ -1633,6 +1663,8 @@ def select_option(options: List[str], prompt: str = "Select an option:") -> int:
     Returns:
         Index of selected option (0-based)
     """
+    if _DUMB_TERM:
+        return _select_option_typed(options, prompt)
     selected = 0
     num_options = len(options)
 
@@ -1687,6 +1719,30 @@ def select_option(options: List[str], prompt: str = "Select an option:") -> int:
         print("\033[?25h", end="")
 
 
+def _select_option_typed(options: List[str], prompt: str) -> int:
+    """The approval menu for a dumb terminal: a numbered list and a typed choice.
+
+    The arrow-key menu redraws itself with cursor-up and line-clear escapes, which a
+    dumb terminal prints as literal text, and editor shells (Emacs ``M-x shell``) send
+    whole lines, not keypresses. Enter alone picks the first option. Ctrl-C or EOF
+    abandons the prompt the same way the arrow-key menu does: exit 2, paused. (gh #182)
+    """
+    print(f"\n{prompt}")
+    for i, opt in enumerate(options, 1):
+        print(f"  {i}. {opt}")
+    while True:
+        try:
+            raw = input(f"Choose 1-{len(options)} [1]: ").strip()
+        except (KeyboardInterrupt, EOFError):
+            print()
+            sys.exit(EXIT_PAUSED)
+        if not raw:
+            return 0
+        if raw.isdigit() and 1 <= int(raw) <= len(options):
+            return int(raw) - 1
+        print(f"Enter a number from 1 to {len(options)}.")
+
+
 def handle_interrupt_input(num_actions: int = 1, is_generic: bool = False) -> Any:
     """
     Handle user input for an interrupt using arrow key navigation, returning the
@@ -3215,13 +3271,17 @@ def main(
     # stripped whenever stdout is not a TTY, matching well-behaved CLIs, and whenever
     # NO_COLOR is set to a non-empty value (https://no-color.org), a live terminal
     # included. An empty NO_COLOR doesn't count, per the convention. (gh #172)
+    # TERM=dumb also strips color, and the spinner and approval menu drop their
+    # escape-driven redraws (gh #182).
     _is_tty = _is_a_tty(sys.stdout)
     _stdin_is_tty = _stdin_is_interactive()  # a mintty pty counts; NUL doesn't
     global _QUIET
     _QUIET = quiet or (
         (bool(message or prompt_file) or verify_agent or not _stdin_is_tty) and not _is_tty
     )
-    if _QUIET or not _is_tty or os.environ.get("NO_COLOR"):
+    global _DUMB_TERM
+    _DUMB_TERM = _is_dumb_term()
+    if _QUIET or not _is_tty or os.environ.get("NO_COLOR") or _DUMB_TERM:
         _disable_ansi()
 
     # `langstage-cli init` — scaffold a runnable starter agent + langstage.toml, then

{langstage_cli-0.6.43 → langstage_cli-0.6.45/langstage_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langstage-cli
-Version: 0.6.43
+Version: 0.6.45
 Summary: The terminal stage for your LangGraph agent — Claude Code-style CLI for any CompiledGraph
 Author-email: Kedar Dabhadkar <kdabhadk@gmail.com>
 License-Expression: MIT
@@ -322,7 +322,9 @@ cat prompt.txt | langstage-cli --demo
 
 Pass `-q/--quiet` to force the same clean output in a terminal. Set
 [`NO_COLOR`](https://no-color.org) to any non-empty value to turn color off in a terminal
-too; the layout and spinner stay, uncolored.
+too; the layout and spinner stay, uncolored. With `TERM=dumb` (Emacs shell, `vim :!`)
+the CLI sends no escape sequences at all: no color, a spinner that prints once, and an
+approval menu you answer by typing a number.
 
 ### Exit codes
 

{langstage_cli-0.6.43 → langstage_cli-0.6.45}/langstage_cli.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ tests/test_config.py
 tests/test_config_command.py
 tests/test_configurable.py
 tests/test_deferred_pass.py
+tests/test_dumb_term.py
 tests/test_exit_codes.py
 tests/test_generic_interrupt.py
 tests/test_help_render.py
@@ -58,6 +59,7 @@ tests/test_stream_mode.py
 tests/test_streaming_marker.py
 tests/test_terminal_width.py
 tests/test_toml_relative_paths.py
+tests/test_tool_card_args.py
 tests/test_tool_output_escape.py
 tests/test_turn_error_verbose.py
 tests/test_turn_exit_and_render.py

{langstage_cli-0.6.43 → langstage_cli-0.6.45}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "langstage-cli"
-version = "0.6.43"
+version = "0.6.45"
 description = "The terminal stage for your LangGraph agent — Claude Code-style CLI for any CompiledGraph"
 readme = "README.md"
 requires-python = ">=3.11"

langstage_cli-0.6.45/tests/test_dumb_term.py

@@ -0,0 +1,190 @@
+"""``TERM=dumb`` gets no escape sequences at all (gh #182).
+
+A dumb terminal (Emacs ``M-x shell``/``compile``, ``vim :!``, serial consoles) prints
+escapes as literal text. ``main()`` honored ``NO_COLOR`` but not ``TERM=dumb``, and the
+spinner and approval menu wrote line clears and cursor hide/show on their own. Now
+``TERM=dumb`` strips color, the spinner prints one plain line, and the approval menu is
+a numbered list answered by typing a number.
+"""
+
+import io
+import os
+import subprocess
+import sys
+import time
+from contextlib import redirect_stdout
+
+import pytest
+from click.testing import CliRunner
+
+from langstage_cli import cli
+
+
+@pytest.fixture
+def dumb(monkeypatch):
+    monkeypatch.setattr(cli, "_DUMB_TERM", True)
+
+
+def _typed(monkeypatch, *lines):
+    it = iter(lines)
+    shown = []
+
+    def fake_input(prompt=""):
+        shown.append(prompt)
+        line = next(it)
+        if isinstance(line, BaseException):
+            raise line
+        return line
+
+    monkeypatch.setattr("builtins.input", fake_input)
+    return shown
+
+
+@pytest.mark.parametrize("value", ["dumb", "DUMB", " dumb "])
+def test_term_dumb_is_detected(monkeypatch, value):
+    monkeypatch.setenv("TERM", value)
+    assert cli._is_dumb_term()
+
+
+@pytest.mark.parametrize("value", ["xterm-256color", "", "dumber"])
+def test_other_terms_are_not_dumb(monkeypatch, value):
+    monkeypatch.setenv("TERM", value)
+    assert not cli._is_dumb_term()
+
+
+def test_term_dumb_strips_every_escape_on_a_terminal(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(cli, "_is_a_tty", lambda stream: True)
+    monkeypatch.setenv("TERM", "dumb")
+    r = CliRunner().invoke(cli.main, ["--demo", "hi"])
+    assert r.exit_code == 0, r.output
+    assert "You said: hi" in r.output and "Loaded" in r.output, r.output
+    assert "\x1b" not in r.output, repr(r.output)
+    # The spinner never redraws: no carriage return anywhere.
+    assert "\r" not in r.output, repr(r.output)
+
+
+def test_spinner_prints_one_plain_line_on_a_dumb_terminal(dumb, capsys):
+    spinner = cli.Spinner("Thinking")
+    spinner.start()
+    time.sleep(0.2)  # an animating spinner would have drawn a couple of frames by now
+    spinner.stop()
+    assert capsys.readouterr().out == "Thinking...\n"
+
+
+def test_menu_is_numbered_and_typed_on_a_dumb_terminal(dumb, monkeypatch):
+    monkeypatch.setattr(cli, "get_key", lambda: pytest.fail("no keypress reading"))
+    prompts = _typed(monkeypatch, "2")
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        choice = cli.select_option(["Approve", "Reject", "Exit"], "How would you like to proceed?")
+    assert choice == 1
+    out = buf.getvalue()
+    assert "  1. Approve\n  2. Reject\n  3. Exit\n" in out, repr(out)
+    assert "\x1b" not in out + "".join(prompts)
+
+
+def test_menu_enter_picks_the_first_option(dumb, monkeypatch):
+    _typed(monkeypatch, "")
+    with redirect_stdout(io.StringIO()):
+        assert cli.select_option(["Approve", "Reject"]) == 0
+
+
+def test_menu_asks_again_on_a_bad_choice(dumb, monkeypatch):
+    prompts = _typed(monkeypatch, "9", "yes", "2")
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        assert cli.select_option(["Approve", "Reject"]) == 1
+    assert len(prompts) == 3
+    assert buf.getvalue().count("Enter a number from 1 to 2.") == 2
+
+
+@pytest.mark.parametrize("abort", [KeyboardInterrupt(), EOFError()], ids=["ctrl-c", "eof"])
+def test_leaving_the_typed_menu_exits_paused(dumb, monkeypatch, abort):
+    _typed(monkeypatch, abort)
+    with redirect_stdout(io.StringIO()), pytest.raises(SystemExit) as exc:
+        cli.select_option(["Approve", "Exit"])
+    assert exc.value.code == 2
+
+
+def _run_on_pty(tmp_path, term, args, answers=b""):
+    import pty
+    import select
+
+    env = {k: v for k, v in os.environ.items() if k not in ("NO_COLOR", "TERM")}
+    env["LANGSTAGE_CLI_SESSIONS_DIR"] = str(tmp_path / "_sessions")
+    env["TERM"] = term
+    master, slave = pty.openpty()
+    proc = subprocess.Popen(
+        [sys.executable, "-c", "from langstage_cli.cli import main; main()", *args],
+        stdin=slave,
+        stdout=slave,
+        stderr=slave,
+        cwd=tmp_path,
+        env=env,
+        close_fds=True,
+    )
+    os.close(slave)
+    out = b""
+    sent = False
+    deadline = time.monotonic() + 60
+    try:
+        while time.monotonic() < deadline:
+            ready, _, _ = select.select([master], [], [], 0.5)
+            if not ready:
+                if proc.poll() is not None:
+                    break
+                continue
+            try:
+                data = os.read(master, 4096)
+            except OSError:  # EIO: the child closed the terminal
+                break
+            if not data:
+                break
+            out += data
+            if answers and not sent and b"Choose 1-" in out:
+                os.write(master, answers)
+                sent = True
+        proc.wait(timeout=10)
+    finally:
+        if proc.poll() is None:
+            proc.kill()
+        os.close(master)
+    return proc.returncode, out.decode("utf-8", errors="replace")
+
+
+_HITL_AGENT = """
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import MessagesState
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.types import interrupt
+from langchain_core.messages import AIMessage
+
+def ask(state):
+    decision = interrupt({"action": "delete_file", "path": "/etc/hosts"})
+    return {"messages": [AIMessage(content=f"Decision was: {decision!r}")]}
+
+g = StateGraph(MessagesState)
+g.add_node("ask", ask)
+g.add_edge(START, "ask")
+g.add_edge("ask", END)
+graph = g.compile(checkpointer=MemorySaver())
+"""
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="needs a POSIX pty")
+def test_no_escapes_on_a_real_dumb_terminal(tmp_path):
+    code, out = _run_on_pty(tmp_path, "dumb", ["--demo", "hi"])
+    assert code == 0, out
+    assert "You said: hi" in out and "╭" in out, repr(out)
+    assert "\x1b" not in out, repr(out)
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="needs a POSIX pty")
+def test_approval_menu_works_on_a_real_dumb_terminal(tmp_path):
+    (tmp_path / "hitl_agent.py").write_text(_HITL_AGENT, encoding="utf-8")
+    code, out = _run_on_pty(tmp_path, "dumb", ["-a", "hitl_agent.py:graph", "go"], b"1\n")
+    assert "1. " in out and "Choose 1-" in out, repr(out)
+    assert "Decision was" in out, repr(out)
+    assert code == 0, out
+    assert "\x1b" not in out, repr(out)

langstage_cli-0.6.45/tests/test_tool_card_args.py

@@ -0,0 +1,100 @@
+"""The tool-call card shows every argument, by name (gh #184).
+
+It used to show only the first argument's value, so ``add(a=17, b=25)`` rendered as
+``add └─ 17`` and ``transfer_funds(to, amount, currency)`` as ``└─ alice``, in default
+and ``-v`` output alike. Under ``--no-interactive`` the card is the only record of
+what ran.
+"""
+
+import io
+import re
+from contextlib import redirect_stdout
+
+import pytest
+
+pytest.importorskip("ag_ui_langgraph")
+
+from langchain_core.messages import AIMessage, ToolMessage  # noqa: E402
+from langgraph.graph import END, START, StateGraph  # noqa: E402
+from langgraph.graph.message import MessagesState  # noqa: E402
+
+from langstage_cli import cli  # noqa: E402
+from langstage_cli.agui_stream import build_session_agent  # noqa: E402
+from langstage_cli.cli import get_tool_arg_preview, run_single_turn_agui  # noqa: E402
+
+_SGR = re.compile(r"\x1b\[[0-9;]*m")
+TRANSFER = {"to": "alice", "amount": 1000000, "currency": "USD"}
+
+
+def test_every_argument_is_named():
+    assert get_tool_arg_preview({"a": 17, "b": 25}) == "a=17, b=25"
+    assert get_tool_arg_preview(TRANSFER) == "to=alice, amount=1000000, currency=USD"
+
+
+def test_a_single_argument_stays_a_bare_value():
+    assert get_tool_arg_preview({"path": "docs/a.md"}) == "docs/a.md"
+    assert get_tool_arg_preview({}) == ""
+
+
+def test_values_are_capped_but_never_dropped():
+    long = "x" * 200
+    preview = get_tool_arg_preview({"path": "a.md", "content": long, "mode": "w"})
+    assert preview == f"path=a.md, content={'x' * 50}..., mode=w"
+    # Structured values read as JSON, not Python reprs.
+    assert (
+        get_tool_arg_preview({"ids": [1, 2], "opts": {"k": "v"}}) == 'ids=[1, 2], opts={"k": "v"}'
+    )
+
+
+def test_verbose_shows_values_in_full():
+    long = "y" * 200
+    assert (
+        get_tool_arg_preview({"path": "a.md", "content": long}, verbose=True)
+        == f"path=a.md, content={long}"
+    )
+    assert get_tool_arg_preview({"q": long}, verbose=True) == long
+
+
+def test_names_and_values_are_escaped():
+    preview = get_tool_arg_preview({"p\x1b[2K": "a\x1b]0;t\x07", "b": "c\nd"})
+    assert "\x1b" not in preview and "\x07" not in preview and "\n" not in preview
+    assert preview == r"p\x1b[2K=a\x1b]0;t\x07, b=c\nd"
+
+
+def _transfer_graph():
+    def call(state):
+        tc = {"id": "t1", "name": "transfer_funds", "args": TRANSFER}
+        return {"messages": [AIMessage(content="", tool_calls=[tc])]}
+
+    def tool(state):
+        return {"messages": [ToolMessage(content="ok", tool_call_id="t1")]}
+
+    def reply(state):
+        return {"messages": [AIMessage(content="Transferred.")]}
+
+    g = StateGraph(MessagesState)
+    for n, f in [("call", call), ("tool", tool), ("reply", reply)]:
+        g.add_node(n, f)
+    g.add_edge(START, "call")
+    g.add_edge("call", "tool")
+    g.add_edge("tool", "reply")
+    g.add_edge("reply", END)
+    return g.compile()
+
+
+@pytest.mark.parametrize("verbose", [False, True])
+async def test_card_in_a_real_turn(monkeypatch, verbose):
+    """The issue's keyless repro, through the AG-UI stream the CLI renders."""
+    monkeypatch.setattr(cli, "Spinner", lambda *a, **k: None)
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        await run_single_turn_agui(
+            build_session_agent(_transfer_graph()),
+            "pay alice",
+            "t-184",
+            interactive=False,
+            verbose=verbose,
+        )
+    plain = _SGR.sub("", buf.getvalue())
+    assert "● transfer_funds" in plain, plain
+    assert "└─ to=alice, amount=1000000, currency=USD" in plain, plain