lithe-cli 0.2.3__tar.gz → 0.2.4__tar.gz

{lithe_cli-0.2.3 → lithe_cli-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lithe-cli
-Version: 0.2.3
+Version: 0.2.4
 Summary: Command-line interface for the lithe agent kernel: chat, one-shot runs, undo, and run inspection.
 License: MIT License
         

{lithe_cli-0.2.3 → lithe_cli-0.2.4}/lithe_cli/__init__.py

@@ -1,3 +1,3 @@
 """lithe-cli: the command-line interface for the lithe agent kernel."""
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"

{lithe_cli-0.2.3 → lithe_cli-0.2.4}/lithe_cli/main.py

@@ -31,6 +31,7 @@ from lithe.bundles import JsonlRunStore
 from . import __version__
 from .agent import build_registry, execute, sandbox_backend, undo
 from .config import config_file, load_config, require_endpoint
+from . import ttyio
 from .ui import BOLD, CYAN, GREEN, RED, YELLOW, configure, truncate, ui
 
 
@@ -329,10 +330,13 @@ _CHAT_HELP = """可用命令：
 def _chat_loop(cfg: Any) -> int:
     store = JsonlRunStore(cfg.store_dir)
     run_ids: list[str] = []
+    history: list[str] = []
     print(ui.banner(__version__, cfg.model or "(scripted)", str(cfg.workspace_dir)))
     while True:
         try:
-            line = input(ui.prompt()).strip()
+            # raw cbreak reader, not input(): readline's redisplay can
+            # corrupt multibyte buffers on long wrapped lines
+            line = ttyio.read_line(ui.prompt(), history=history).strip()
         except (EOFError, KeyboardInterrupt):
             print()
             break
@@ -347,6 +351,7 @@ def _chat_loop(cfg: Any) -> int:
             continue
         if not line:
             continue
+        history.append(line)
         if line in ("/exit", "/quit", "exit", "quit"):
             break
         if line == "/help":

{lithe_cli-0.2.3 → lithe_cli-0.2.4}/lithe_cli/setup.py

@@ -14,7 +14,6 @@ from __future__ import annotations
 
 import os
 import sys
-from getpass import getpass
 from urllib.error import HTTPError, URLError
 from urllib.request import Request, urlopen
 
@@ -26,12 +25,11 @@ from .config import (
     load_saved_endpoint,
     save_endpoint,
 )
+from .ttyio import _PASTE_MARKERS, read_line
 from .ui import BOLD, CYAN, GREEN, RED, YELLOW, ui
 
 _MAX_EMPTY_TRIES = 3
 
-_PASTE_MARKERS = ("\x1b[200~", "\x1b[201~")
-
 
 def _clean_answer(text: str) -> str:
     """Strip whitespace plus bracketed-paste wrappers from a typed/pasted reply.
@@ -42,87 +40,18 @@ def _clean_answer(text: str) -> str:
     key would be saved with them glued on and fail auth later.
     """
     for marker in _PASTE_MARKERS:
-        text = text.replace(marker, "")
+        text = text.replace(marker.decode(), "")
     return text.strip()
 
 
 def _read_masked(prompt: str = "") -> str:
     """getpass-style hidden read that echoes a ``*`` per accepted character.
 
-    getpass is fully silent, so a pasted key looks like nothing happened
-    and users retype it by hand. This reader shows one star per character
-    (paste wrappers and editing keys echo nothing), supports backspace and
-    Ctrl+U, and falls back to plain getpass where raw termios is
-    unavailable (no controlling terminal, Windows).
+    Thin wrapper over :func:`lithe_cli.ttyio.read_line`; the why lives
+    there. Falls back to plain ``input()`` without a TTY, never getpass
+    silence: every accepted character is acknowledged.
     """
-    try:
-        import termios
-    except ImportError:  # pragma: no cover — non-POSIX
-        return getpass(prompt)
-    try:
-        tty_fd = os.open("/dev/tty", os.O_RDWR)
-    except OSError:  # no controlling terminal → silent fallback
-        return getpass(prompt)
-
-    chars: list[str] = []
-    pending = ""
-
-    def emit(text: str) -> None:
-        os.write(tty_fd, text.encode(errors="ignore"))
-
-    def plain(ch: str) -> str | None:
-        if ch in ("\r", "\n"):
-            return "".join(chars)
-        if ch in ("\x7f", "\b"):  # backspace rubs out one star
-            if chars:
-                chars.pop()
-                emit("\b \b")
-            return None
-        if ch == "\x15":  # Ctrl+U wipes the line
-            emit("\b \b" * len(chars))
-            chars.clear()
-            return None
-        if ch == "\x04":  # Ctrl+D bails out on an empty line
-            if not chars:
-                raise EOFError
-            return "".join(chars)
-        if ch.isprintable():
-            chars.append(ch)
-            emit("*")
-        return None
-
-    old = termios.tcgetattr(tty_fd)
-    new = termios.tcgetattr(tty_fd)
-    new[3] &= ~(termios.ECHO | termios.ICANON)  # 3 == lflags
-    new[6][termios.VMIN] = 1  # 6 == cc: read(1) blocks per char
-    new[6][termios.VTIME] = 0
-    try:
-        termios.tcsetattr(tty_fd, termios.TCSANOW, new)
-        emit(prompt)
-        while True:
-            byte = os.read(tty_fd, 1)
-            if not byte:
-                raise EOFError
-            ch = byte.decode(errors="replace")
-            if pending or ch == "\x1b":
-                candidate = pending + ch
-                if any(m.startswith(candidate) for m in _PASTE_MARKERS):
-                    pending = "" if candidate in _PASTE_MARKERS else candidate
-                    continue
-                pending = ""
-                line = None
-                for single in candidate:  # not a wrapper: replay as input
-                    line = plain(single)
-                    if line is not None:
-                        break
-            else:
-                line = plain(ch)
-            if line is not None:
-                emit("\n")
-                return line
-    finally:
-        termios.tcsetattr(tty_fd, termios.TCSANOW, old)
-        os.close(tty_fd)
+    return read_line(prompt, mask=True)
 
 
 def stdin_is_interactive() -> bool:

lithe_cli-0.2.4/lithe_cli/ttyio.py

@@ -0,0 +1,195 @@
+"""Raw-mode TTY line reading without GNU readline.
+
+Why this exists: readline's redisplay machinery can diverge from its own
+buffer on long multibyte lines (observed as ``input()`` raising
+UnicodeDecodeError on a line the terminal echoed correctly — the buffer
+lost a byte mid-character). We cannot fix C-level readline, so chat
+input bypasses it entirely: this module reads bytes off ``/dev/tty`` in
+cbreak mode, echoes exactly what arrived (the terminal wraps it — we
+never compute columns), and supports the editing keys a chat REPL
+needs: backspace, Ctrl+W, Ctrl+U, Up/Down history, Ctrl+C/Ctrl+D.
+
+Bracketed-paste wrappers and unknown escape sequences (arrow keys other
+than Up/Down, focus events, cursor replies…) are swallowed instead of
+leaking into the returned line. Decoding is strict incremental UTF-8 —
+a line that arrives broken raises UnicodeDecodeError for the caller to
+drop with a hint, never silently mangled.
+"""
+
+from __future__ import annotations
+
+import codecs
+import os
+import sys
+import unicodedata
+
+_PASTE_MARKERS = (b"\x1b[200~", b"\x1b[201~")
+_UP = (b"\x1b[A", b"\x1bOA")
+_DOWN = (b"\x1b[B", b"\x1bOB")
+
+
+def _width(ch: str) -> int:
+    return 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1
+
+
+def read_line(
+    prompt: str = "",
+    *,
+    mask: bool = False,
+    history: list[str] | None = None,
+    input_fn=None,
+) -> str:
+    """Read one line from the TTY, echoing input (or ``*`` when masked).
+
+    Falls back to plain ``input()`` when there is no interactive
+    terminal (pipes, tests) or termios is unavailable. Raises
+    EOFError (Ctrl+D on empty), KeyboardInterrupt (Ctrl+C), and
+    UnicodeDecodeError for undecodable input.
+    """
+    if input_fn is None:
+        import builtins
+
+        input_fn = builtins.input
+    if not (sys.stdin.isatty() and sys.stdout.isatty()):
+        return input_fn(prompt)
+    try:
+        import termios
+    except ImportError:  # pragma: no cover — non-POSIX
+        return input_fn(prompt)
+    try:
+        tty_fd = os.open("/dev/tty", os.O_RDWR)
+    except OSError:  # no controlling terminal
+        return input_fn(prompt)
+
+    chars: list[str] = []
+    pending = b""
+    hist_index: int | None = None
+    draft = ""
+    decoder = codecs.getincrementaldecoder("utf-8")()
+
+    def emit(text: str) -> None:
+        os.write(tty_fd, text.encode(errors="ignore"))
+
+    def cells(ch: str) -> int:
+        return 1 if mask else _width(ch)
+
+    def show(ch: str) -> None:
+        emit("*" if mask else ch)
+
+    def rub_out(ch: str) -> None:
+        emit("\b \b" * cells(ch))
+
+    def replace_line(text: str) -> None:
+        for ch in reversed(chars):
+            rub_out(ch)
+        chars.clear()
+        chars.extend(text)
+        for ch in text:
+            show(ch)
+
+    def move_history(delta: int) -> None:
+        nonlocal hist_index, draft
+        if not history:
+            return
+        if delta < 0:
+            if hist_index is None:
+                draft = "".join(chars)
+                hist_index = len(history) - 1
+            else:
+                hist_index = max(0, hist_index - 1)
+            replace_line(history[hist_index])
+        else:
+            if hist_index is None:
+                return
+            if hist_index + 1 >= len(history):
+                hist_index = None
+                replace_line(draft)
+            else:
+                hist_index += 1
+                replace_line(history[hist_index])
+
+    def finish() -> str:
+        chars.append(decoder.decode(b"", final=True))
+        emit("\n")
+        return "".join(chars)
+
+    def literal(byte: int) -> str | None:
+        if byte in (0x0D, 0x0A):
+            return finish()
+        if byte in (0x7F, 0x08):  # backspace rubs one character out
+            if chars:
+                rub_out(chars.pop())
+            return None
+        if byte == 0x15:  # Ctrl+U wipes the line
+            for ch in reversed(chars):
+                rub_out(ch)
+            chars.clear()
+            return None
+        if byte == 0x17:  # Ctrl+W rubs the last word
+            while chars and chars[-1] == " ":
+                rub_out(chars.pop())
+            while chars and chars[-1] != " ":
+                rub_out(chars.pop())
+            return None
+        if byte == 0x04:  # Ctrl+D bails out on an empty line
+            if not chars:
+                raise EOFError
+            return finish()
+        if byte >= 0x20:  # printable bytes; controls are ignored
+            piece = decoder.decode(bytes([byte]))
+            for ch in piece:
+                chars.append(ch)
+                show(ch)
+        return None
+
+    def dispatch(seq: bytes) -> None:
+        if seq in _UP:
+            move_history(-1)
+        elif seq in _DOWN:
+            move_history(1)
+
+    old = termios.tcgetattr(tty_fd)
+    new = termios.tcgetattr(tty_fd)
+    new[3] &= ~(termios.ECHO | termios.ICANON)  # 3 == lflags
+    new[6][termios.VMIN] = 1  # 6 == cc: read(1) blocks per byte
+    new[6][termios.VTIME] = 0
+    try:
+        termios.tcsetattr(tty_fd, termios.TCSANOW, new)
+        emit(prompt)
+        while True:
+            chunk = os.read(tty_fd, 1)
+            if not chunk:
+                raise EOFError
+            byte = chunk[0]
+            if pending:
+                cand = pending + chunk
+                head = cand[:2]
+                if any(m.startswith(cand) for m in _PASTE_MARKERS):
+                    pending = b"" if cand in _PASTE_MARKERS else cand
+                elif head == b"\x1b[":
+                    if 0x40 <= byte <= 0x7E:
+                        dispatch(cand)
+                        pending = b""
+                    else:
+                        pending = cand
+                elif head == b"\x1bO":
+                    if 0x20 <= byte <= 0x7E:
+                        dispatch(cand)
+                        pending = b""
+                    else:
+                        pending = cand
+                else:
+                    pending = b""  # lone ESC: drop it, take the byte
+                    line = literal(byte)
+                    if line is not None:
+                        return line
+                continue
+            if byte == 0x1B:
+                pending = chunk
+                continue
+            line = literal(byte)
+            if line is not None:
+                return line
+    finally:
+        termios.tcsetattr(tty_fd, termios.TCSANOW, old)
+        os.close(tty_fd)

{lithe_cli-0.2.3 → lithe_cli-0.2.4}/lithe_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lithe-cli
-Version: 0.2.3
+Version: 0.2.4
 Summary: Command-line interface for the lithe agent kernel: chat, one-shot runs, undo, and run inspection.
 License: MIT License
         

{lithe_cli-0.2.3 → lithe_cli-0.2.4}/lithe_cli.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ lithe_cli/config.py
 lithe_cli/main.py
 lithe_cli/py.typed
 lithe_cli/setup.py
+lithe_cli/ttyio.py
 lithe_cli/ui.py
 lithe_cli.egg-info/PKG-INFO
 lithe_cli.egg-info/SOURCES.txt

{lithe_cli-0.2.3 → lithe_cli-0.2.4}/tests/test_cli.py

@@ -406,6 +406,89 @@ def test_wizard_accepts_bracketed_paste(tmp_path, monkeypatch):
     }
 
 
+def _pty_run(code: str, feed: list[bytes], settle: float = 0.35):
+    """Fork a PTY, run `code`, feed byte chunks, return (output, exit_code)."""
+    import os
+    import pty
+    import sys
+    import time
+
+    pid, fd = pty.fork()
+    if pid == 0:
+        env = dict(os.environ, PYTHONPATH=os.getcwd())
+        os.execvpe(
+            sys.executable, [sys.executable, "-c", code], env
+        )
+        os._exit(1)
+    try:
+        out = b""
+        for chunk in feed:
+            time.sleep(settle)
+            out += _pty_drain(fd)
+            os.write(fd, chunk)
+        time.sleep(settle)
+        out += _pty_drain(fd)
+        _, status = os.waitpid(pid, 0)
+        return out.decode(errors="replace"), os.waitstatus_to_exitcode(status)
+    finally:
+        os.close(fd)
+
+
+def _pty_drain(fd) -> bytes:
+    import os
+    import select
+
+    out = b""
+    while select.select([fd], [], [], 0.2)[0]:
+        try:
+            chunk = os.read(fd, 4096)
+        except OSError:
+            break
+        if not chunk:
+            break
+        out += chunk
+    return out
+
+
+def test_read_line_multibyte_history_editing_and_paste():
+    # the exact long Chinese line that readline corrupted in the field
+    long_line = "你能使用python matplotlib 绘制 九大行星的运动动画，然后你把它运行起来。"
+    code = """
+from lithe_cli import ttyio
+h = []
+r1 = ttyio.read_line('p1> ', history=h)
+print('R1:' + repr(r1)); h.append(r1)
+r2 = ttyio.read_line('p2> ', history=h)
+print('R2:' + repr(r2)); h.append(r2)
+r3 = ttyio.read_line('p3> ', history=h)
+print('R3:' + repr(r3))
+r4 = ttyio.read_line('k> ', mask=True)
+print('R4:' + repr(r4))
+r5 = ttyio.read_line('p5> ')
+print('R5:' + repr(r5))
+"""
+    # r1: IME-style bursts of the long line, with terminal focus junk injected
+    feed = []
+    msg = long_line.encode()
+    for i in range(0, len(msg), 6):
+        feed.append(msg[i : i + 6])
+        if i == 24:
+            feed.append(b"\x1b[I")  # focus-in event must not pollute the line
+    feed.append(b"\r")
+    feed.append(b"ab\x7fc\r")  # r2: backspace → "ac"
+    feed.append(b"\x1b[A\r")  # r3: Up recalls "ac"
+    feed.append("密钥\r".encode())  # r4: masked non-ASCII stays intact
+    feed.append(b"\x1b[200~sk-x\x1b[201~\r")  # r5: paste wrappers stripped
+    out, rc = _pty_run(code, feed)
+    assert rc == 0
+    assert "UnicodeDecodeError" not in out
+    assert f"R1:{long_line!r}" in out
+    assert "R2:'ac'" in out
+    assert "R3:'ac'" in out
+    assert "R4:'密钥'" in out
+    assert "R5:'sk-x'" in out
+
+
 def test_read_masked_echoes_stars_and_swallows_paste_markers():
     import os
     import pty