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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lithe-cli
-Version: 0.2.4
+Version: 0.3.0
 Summary: Command-line interface for the lithe agent kernel: chat, one-shot runs, undo, and run inspection.
 License: MIT License
         
@@ -40,6 +40,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: lithe>=0.9.5
+Requires-Dist: prompt-toolkit>=3.0.38
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: ruff>=0.4; extra == "dev"
@@ -197,8 +198,12 @@ them only after a session has started the servers.)
 ### Colors
 
 Output is colored when stdout is a TTY and `NO_COLOR` is unset; `--color`
-/ `--no-color` force either way. Rendering has zero dependencies — plain
-text degrades cleanly through pipes and cron.
+/ `--no-color` force either way. Output rendering itself stays
+dependency-free — plain text degrades cleanly through pipes and cron.
+Interactive *input* (the chat prompt and the setup wizard) is
+[prompt_toolkit](https://python-prompt-toolkit.readthedocs.io/):
+wide-character-safe editing, bracketed-paste handling, star-echoed API
+keys, inline wizard validation, and persistent history.
 
 ## Where things land
 
@@ -208,6 +213,7 @@ text degrades cleanly through pipes and cron.
 | `~/.lithe/runs` (or `--store`) | JSONL run store: messages, actions, undo records |
 | `~/.lithe/runs/todos-<user>.json` | the agent's task list |
 | `~/.lithe/skills` (or `--skills`) | the markdown skill library, when enabled |
+| `~/.lithe/history` | chat input history (prompt_toolkit `FileHistory`; Up/Ctrl+R recall) |
 
 ## Design notes
 

{lithe_cli-0.2.4 → lithe_cli-0.3.0}/README.md

@@ -150,8 +150,12 @@ them only after a session has started the servers.)
 ### Colors
 
 Output is colored when stdout is a TTY and `NO_COLOR` is unset; `--color`
-/ `--no-color` force either way. Rendering has zero dependencies — plain
-text degrades cleanly through pipes and cron.
+/ `--no-color` force either way. Output rendering itself stays
+dependency-free — plain text degrades cleanly through pipes and cron.
+Interactive *input* (the chat prompt and the setup wizard) is
+[prompt_toolkit](https://python-prompt-toolkit.readthedocs.io/):
+wide-character-safe editing, bracketed-paste handling, star-echoed API
+keys, inline wizard validation, and persistent history.
 
 ## Where things land
 
@@ -161,6 +165,7 @@ text degrades cleanly through pipes and cron.
 | `~/.lithe/runs` (or `--store`) | JSONL run store: messages, actions, undo records |
 | `~/.lithe/runs/todos-<user>.json` | the agent's task list |
 | `~/.lithe/skills` (or `--skills`) | the markdown skill library, when enabled |
+| `~/.lithe/history` | chat input history (prompt_toolkit `FileHistory`; Up/Ctrl+R recall) |
 
 ## Design notes
 

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

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

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

@@ -29,9 +29,10 @@ from lithe import __version__ as lithe_version
 from lithe.bundles import JsonlRunStore
 
 from . import __version__
+from . import prompts
 from .agent import build_registry, execute, sandbox_backend, undo
 from .config import config_file, load_config, require_endpoint
-from . import ttyio
+from .prompts import open_history
 from .ui import BOLD, CYAN, GREEN, RED, YELLOW, configure, truncate, ui
 
 
@@ -330,13 +331,13 @@ _CHAT_HELP = """可用命令：
 def _chat_loop(cfg: Any) -> int:
     store = JsonlRunStore(cfg.store_dir)
     run_ids: list[str] = []
-    history: list[str] = []
+    input_history = open_history()  # FileHistory under $LITHE_HOME, shared runs
     print(ui.banner(__version__, cfg.model or "(scripted)", str(cfg.workspace_dir)))
     while True:
         try:
-            # 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()
+            # prompt_toolkit owns the terminal: wide-char safe, paste-safe,
+            # persistent history — never input()/readline
+            line = prompts.chat_line(ui.prompt(), input_history).strip()
         except (EOFError, KeyboardInterrupt):
             print()
             break
@@ -351,7 +352,6 @@ 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.3.0/lithe_cli/prompts.py

@@ -0,0 +1,118 @@
+"""All interactive input goes through prompt_toolkit.
+
+One seam for every prompt the CLI shows: the chat line (persistent
+history, ANSI-colored prompt), the wizard's questions (inline
+validation, hidden API key with star echo), and yes/no confirms.
+
+prompt_toolkit owns the terminal: it draws its own line editor with
+proper wide-character widths (no readline multibyte corruption), turns
+on and consumes bracketed paste itself, and masks ``is_password``
+input with asterisks — the three failure classes this CLI hit when it
+used ``input``/``getpass``/readline are all upstream concerns now.
+"""
+
+from __future__ import annotations
+
+from prompt_toolkit import prompt
+from prompt_toolkit.formatted_text import ANSI
+from prompt_toolkit.history import FileHistory, InMemoryHistory
+from prompt_toolkit.validation import ValidationError, Validator
+
+from .ui import RED, YELLOW, ui
+
+_MAX_EMPTY_TRIES = 3
+
+_UTF8_HINT = (
+    "\n  这行输入无法按 UTF-8 解码，已丢弃；"
+    "请把终端与 locale 设为 UTF-8（如 export LANG=C.UTF-8）后重试。"
+)
+
+
+def history_file():
+    """Where chat history persists, next to the saved endpoint."""
+    from .config import lithe_home
+
+    return lithe_home() / "history"
+
+
+def open_history() -> FileHistory:
+    """A FileHistory under ``$LITHE_HOME`` (dir created on demand)."""
+    path = history_file()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        return InMemoryHistory()
+    return FileHistory(str(path))
+
+
+def chat_line(message: str, history) -> str:
+    """The chat REPL prompt: colored, history-searchable, paste-safe."""
+    return prompt(
+        ANSI(message),
+        history=history,
+        enable_history_search=True,
+    )
+
+
+class _FnValidator(Validator):
+    """Adapt a ``text -> error string | None`` callable for prompt_toolkit."""
+
+    def __init__(self, fn):
+        self.fn = fn
+
+    def validate(self, document) -> None:
+        problem = self.fn(document.text)
+        if problem:
+            raise ValidationError(message=problem, cursor_position=len(document.text))
+
+
+def ask(
+    label: str,
+    default: str = "",
+    password: bool = False,
+    validate=None,
+) -> str | None:
+    """Ask for one value; empty answers keep the default or re-prompt.
+
+    ``validate`` (text -> error string or None) is enforced inline by
+    prompt_toolkit — Enter is refused with the message until the value
+    passes. Returns None when the user bails out (empty too often,
+    Ctrl+C/D).
+    """
+    message = f"{label} [回车沿用已保存值]: " if password and default else f"{label}: "
+    validator = _FnValidator(validate) if validate is not None else None
+    for _ in range(_MAX_EMPTY_TRIES):
+        try:
+            answer = prompt(
+                message,
+                default=default if not password else "",
+                is_password=password,
+                validator=validator,
+            ).strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return None
+        except UnicodeDecodeError:
+            print(ui.s(_UTF8_HINT, RED))
+            continue
+        if not answer and default:
+            return default
+        if not answer:
+            print(ui.s("  这个值不能为空。", YELLOW))
+            continue
+        return answer
+    return None
+
+
+def yes_no(label: str, default: bool) -> bool:
+    """A y/n question; empty answer takes the default."""
+    hint = "Y/n" if default else "y/N"
+    try:
+        answer = prompt(f"{label} [{hint}]: ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return default
+    except UnicodeDecodeError:
+        print(ui.s("\n  这行输入无法按 UTF-8 解码，按默认值处理。", RED))
+        return default
+    return default if not answer else answer in ("y", "yes", "是")

lithe_cli-0.3.0/lithe_cli/setup.py

@@ -0,0 +1,109 @@
+"""First-run endpoint setup: the wizard behind `lithe-cli config`.
+
+The CLI still ships no default endpoint — that principle is untouched.
+What changes is the failure mode: on an interactive terminal, a missing
+endpoint means three prompts and a saved config file instead of a
+refusal with a wall of export lines. Non-interactive contexts (pipes,
+scripts, CI) never see the wizard; they keep the hard error.
+
+Precedence stays flag > env > config file, so the wizard only fills what
+nothing else provided. All prompting is prompt_toolkit (see
+:mod:`lithe_cli.prompts`): inline URL validation, star-echoed API key,
+paste-safe input.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+from . import prompts
+from .config import (
+    ENV_API_KEY,
+    ENV_BASE_URL,
+    ENV_MODEL,
+    config_file,
+    load_saved_endpoint,
+    save_endpoint,
+)
+from .ui import BOLD, CYAN, GREEN, RED, YELLOW, ui
+
+
+def stdin_is_interactive() -> bool:
+    """True only when both ends are TTYs — pipes and captures stay clean."""
+    return sys.stdin.isatty() and sys.stdout.isatty()
+
+
+def _http_like(value: str) -> str | None:
+    return (
+        None
+        if value.startswith(("http://", "https://"))
+        else ("Base URL 需以 http:// 或 https:// 开头。")
+    )
+
+
+def probe_endpoint(base_url: str, api_key: str, timeout: float = 10.0) -> bool:
+    """One cheap GET ``{base_url}/models`` to catch typos before chat.
+
+    The save already happened: a failed probe warns, it never blocks —
+    endpoints legitimately lack ``/models`` or auth differently.
+    """
+    url = base_url.rstrip("/") + "/models"
+    req = Request(url, headers={"Authorization": f"Bearer {api_key}"})
+    try:
+        with urlopen(req, timeout=timeout) as resp:
+            print(ui.s(f"✓ 端点可达（HTTP {resp.status}）", GREEN))
+            return True
+    except HTTPError as exc:
+        if exc.code in (401, 403):
+            print(ui.s(f"~ 端点可达但拒绝了该 key（HTTP {exc.code}）", YELLOW))
+        else:
+            print(ui.s(f"~ 端点有响应：HTTP {exc.code}（无 /models 也无妨）", YELLOW))
+        return True  # reachable is all we wanted to know
+    except (URLError, OSError, TimeoutError) as exc:
+        print(ui.s(f"✗ 连不上 {url}：{exc}", RED))
+        return False
+
+
+def run_setup_wizard() -> dict | None:
+    """Prompt for base_url / api_key / model and save the config file.
+
+    Defaults come from the already-saved file, then env vars, so
+    re-running the wizard is re-editing, not retyping. Returns the saved
+    endpoint dict, or None when the user cancels.
+    """
+    if not stdin_is_interactive():
+        print(ui.s("交互配置需要终端（stdin/stdout 不是 TTY）。", RED))
+        return None
+    saved = load_saved_endpoint()
+    env = {
+        "base_url": os.environ.get(ENV_BASE_URL, "").strip(),
+        "api_key": os.environ.get(ENV_API_KEY, "").strip(),
+        "model": os.environ.get(ENV_MODEL, "").strip(),
+    }
+    defaults = {k: saved.get(k, "") or env[k] for k in env}
+
+    print(ui.s("初始设置：配置模型端点", CYAN, BOLD))
+    print(
+        f"值保存在 {config_file()}（权限 600）；"
+        "优先级 flag > 环境变量 > 配置文件。\n"
+        "之后可用 `lithe-cli config` 重新配置。"
+    )
+    base_url = prompts.ask(
+        "Base URL（如 https://your-endpoint/api/v1）",
+        defaults["base_url"],
+        validate=_http_like,
+    )
+    api_key = prompts.ask("API key", defaults["api_key"], password=True)
+    model = prompts.ask("模型名（如 glm-4.6）", defaults["model"])
+    if not (base_url and api_key and model):
+        print(ui.s("已取消，未保存任何配置。", YELLOW))
+        return None
+
+    path = save_endpoint(api_key, base_url, model)
+    print(ui.s(f"✓ 已保存到 {path}", GREEN))
+    if prompts.yes_no("现在测试一下连接吗", True):
+        probe_endpoint(base_url, api_key)
+    return {"api_key": api_key, "base_url": base_url, "model": model}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lithe-cli
-Version: 0.2.4
+Version: 0.3.0
 Summary: Command-line interface for the lithe agent kernel: chat, one-shot runs, undo, and run inspection.
 License: MIT License
         
@@ -40,6 +40,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: lithe>=0.9.5
+Requires-Dist: prompt-toolkit>=3.0.38
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: ruff>=0.4; extra == "dev"
@@ -197,8 +198,12 @@ them only after a session has started the servers.)
 ### Colors
 
 Output is colored when stdout is a TTY and `NO_COLOR` is unset; `--color`
-/ `--no-color` force either way. Rendering has zero dependencies — plain
-text degrades cleanly through pipes and cron.
+/ `--no-color` force either way. Output rendering itself stays
+dependency-free — plain text degrades cleanly through pipes and cron.
+Interactive *input* (the chat prompt and the setup wizard) is
+[prompt_toolkit](https://python-prompt-toolkit.readthedocs.io/):
+wide-character-safe editing, bracketed-paste handling, star-echoed API
+keys, inline wizard validation, and persistent history.
 
 ## Where things land
 
@@ -208,6 +213,7 @@ text degrades cleanly through pipes and cron.
 | `~/.lithe/runs` (or `--store`) | JSONL run store: messages, actions, undo records |
 | `~/.lithe/runs/todos-<user>.json` | the agent's task list |
 | `~/.lithe/skills` (or `--skills`) | the markdown skill library, when enabled |
+| `~/.lithe/history` | chat input history (prompt_toolkit `FileHistory`; Up/Ctrl+R recall) |
 
 ## Design notes
 

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

@@ -6,9 +6,9 @@ lithe_cli/__main__.py
 lithe_cli/agent.py
 lithe_cli/config.py
 lithe_cli/main.py
+lithe_cli/prompts.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.4 → lithe_cli-0.3.0}/lithe_cli.egg-info/requires.txt

@@ -1,4 +1,5 @@
 lithe>=0.9.5
+prompt-toolkit>=3.0.38
 
 [dev]
 pytest>=8

{lithe_cli-0.2.4 → lithe_cli-0.3.0}/pyproject.toml

@@ -9,7 +9,7 @@ description = "Command-line interface for the lithe agent kernel: chat, one-shot
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.10"
-dependencies = ["lithe>=0.9.5"]
+dependencies = ["lithe>=0.9.5", "prompt-toolkit>=3.0.38"]
 keywords = ["agent", "llm", "react", "cli", "tool-calling"]
 classifiers = [
     "Development Status :: 4 - Beta",

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

@@ -350,15 +350,29 @@ def test_corrupt_config_file_ignored(tmp_path, monkeypatch):
 
 
 def test_wizard_saves_and_reports_cancel(tmp_path, monkeypatch, capsys):
-    from lithe_cli import setup
+    from lithe_cli import prompts, setup
 
     monkeypatch.setenv("LITHE_HOME", str(tmp_path))
+    monkeypatch.setattr(setup, "stdin_is_interactive", lambda: True)
     answers = iter(
-        ["https://wizard.example/api/v1", "sk-wiz", "glm-4.6", "n"]
-    )  # base_url, key, model, skip probe
-    saved = setup.run_setup_wizard(
-        input_fn=lambda prompt: next(answers), secret_fn=lambda prompt: next(answers)
-    )
+        ["https://wizard.example/api/v1", "sk-wiz", "glm-4.6"]
+    )  # base_url, key, model
+    seen_kwargs = []
+
+    def fake_ask(label, default="", password=False, validate=None):
+        seen_kwargs.append(
+            {
+                "label": label,
+                "default": default,
+                "password": password,
+                "validate": validate,
+            }
+        )
+        return next(answers)
+
+    monkeypatch.setattr(prompts, "ask", fake_ask)
+    monkeypatch.setattr(prompts, "yes_no", lambda label, default: False)
+    saved = setup.run_setup_wizard()
     assert saved == {
         "api_key": "sk-wiz",
         "base_url": "https://wizard.example/api/v1",
@@ -369,44 +383,19 @@ def test_wizard_saves_and_reports_cancel(tmp_path, monkeypatch, capsys):
     from lithe_cli.config import load_saved_endpoint
 
     assert load_saved_endpoint()["model"] == "glm-4.6"
+    # the URL is validated inline and the key is the only password prompt
+    assert seen_kwargs[0]["validate"] is setup._http_like
+    assert [k["password"] for k in seen_kwargs] == [False, True, False]
 
-    # bailing out (empty answers, nothing saved yet) returns None and
-    # still saves nothing
+    # bailing out (Ctrl+D on the first question) returns None, saves nothing
     (tmp_path / "config.json").unlink()
-    empty = iter([""] * 12)
-    assert (
-        setup.run_setup_wizard(
-            input_fn=lambda prompt: next(empty), secret_fn=lambda prompt: next(empty)
-        )
-        is None
-    )
+    monkeypatch.setattr(prompts, "ask", lambda *a, **k: None)
+    assert setup.run_setup_wizard() is None
     assert "已取消" in capsys.readouterr().out
     assert load_saved_endpoint() == {}
 
 
-def test_wizard_accepts_bracketed_paste(tmp_path, monkeypatch):
-    from lithe_cli import setup
-
-    monkeypatch.setenv("LITHE_HOME", str(tmp_path))
-    answers = iter(
-        [
-            "\x1b[200~https://paste.example/api/v1\x1b[201~",
-            "\x1b[200~sk-pasted-key  \x1b[201~",
-            "\x1b[200~glm-4.6\x1b[201~",
-            "n",
-        ]
-    )
-    saved = setup.run_setup_wizard(
-        input_fn=lambda prompt: next(answers), secret_fn=lambda prompt: next(answers)
-    )
-    assert saved == {
-        "api_key": "sk-pasted-key",
-        "base_url": "https://paste.example/api/v1",
-        "model": "glm-4.6",
-    }
-
-
-def _pty_run(code: str, feed: list[bytes], settle: float = 0.35):
+def _pty_run(code: str, feed: list[bytes], settle: float = 0.25):
     """Fork a PTY, run `code`, feed byte chunks, return (output, exit_code)."""
     import os
     import pty
@@ -447,136 +436,115 @@ def _pty_drain(fd) -> bytes:
         if not chunk:
             break
         out += chunk
+        if b"\x1b[6n" in chunk:
+            # answer prompt_toolkit's cursor-position request, like a real
+            # terminal would — without a reply ptk falls into a degraded
+            # mode and key bindings (history recall) misbehave
+            os.write(fd, b"\x1b[1;1R")
     return out
 
 
-def test_read_line_multibyte_history_editing_and_paste():
-    # the exact long Chinese line that readline corrupted in the field
+def test_prompt_toolkit_cjk_paste_password_history(tmp_path):
+    # the exact long Chinese line that readline corrupted in the field,
+    # driven through the real prompt_toolkit stack
     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)
+    hist = str(tmp_path / "hist")
+    code = f"""
+import os
+from prompt_toolkit.history import FileHistory
+from lithe_cli.prompts import ask, chat_line
+from lithe_cli.setup import _http_like
+hpath = {hist!r}
+r1 = chat_line('\\x1b[36mlithe ❯ \\x1b[0m', FileHistory(hpath))
+print('R1:' + repr(r1))
+r2 = ask('API key', password=True)
+print('R2:' + repr(r2))
+r3 = ask('Base URL', validate=_http_like)
 print('R3:' + repr(r3))
-r4 = ttyio.read_line('k> ', mask=True)
+r4 = chat_line('p4> ', FileHistory(hpath))
 print('R4:' + repr(r4))
-r5 = ttyio.read_line('p5> ')
+r5 = chat_line('p5> ', FileHistory(hpath))
 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):
+    for i in range(0, len(msg), 6):  # IME-style bursts
         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
+    feed.append(b"sk-ptk\r")  # password prompt
+    feed.append(b"no-scheme\r")  # validator refuses Enter, shows the message
+    feed.append(b"\x7f" * 9)  # wipe "no-scheme"…
+    feed.append(b"https://ok\r")  # …type a valid URL
+    feed.append(b"\x1b[A\r")  # Up recalls r1 from the history file
+    feed.append(b"\x1b[200~sk-paste\x1b[201~\r")  # bracketed paste
     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
-    import select
-    import sys
-    import time
-
-    code = (
-        "from lithe_cli.setup import _read_masked;"
-        "print();print('GOT:' + _read_masked('API key: '))"
-    )
-    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:
-        time.sleep(0.4)
-        os.write(fd, b"\x1b[200~sk-paste\x1b[201~\r")  # pasted with wrappers
-        time.sleep(0.4)
-        out = b""
-        while select.select([fd], [], [], 0.2)[0]:
-            try:
-                chunk = os.read(fd, 4096)
-            except OSError:
-                break
-            if not chunk:
-                break
-            out += chunk
-    finally:
-        os.close(fd)
-        os.waitpid(pid, 0)
-    text = out.decode(errors="replace")
-    assert "GOT:sk-paste" in text  # value is clean
-    assert "********" in text  # one star per visible character
-    assert "\x1b[200~" not in text and "\x1b[201~" not in text
+    assert "R2:'sk-ptk'" in out and "******" in out  # stars echoed
+    assert "R3:'https://ok'" in out and "http://" in out  # inline validation
+    assert f"R4:{long_line!r}" in out  # history recall across prompts
+    assert "R5:'sk-paste'" in out  # paste wrappers consumed
+    assert "\x1b[200~" not in out
 
 
 def test_undecodable_input_line_never_crashes(tmp_path, monkeypatch, capsys):
-    # a mangled (non-UTF-8) input line — e.g. readline/locale mismatch —
-    # must be dropped with a hint, not kill the whole process
-    def bad_decode(prompt=""):
+    # a mangled (non-UTF-8) input line must be dropped with a hint,
+    # not kill the whole process
+    def bad_decode(*a, **k):
         raise UnicodeDecodeError("utf-8", b"\xe5", 52, 53, "invalid continuation byte")
 
-    from lithe_cli import setup
+    from lithe_cli import prompts
     from lithe_cli.main import _chat_loop
     from conftest import make_config
 
+    monkeypatch.setenv("LITHE_HOME", str(tmp_path))
     calls = iter([bad_decode, EOFError])
 
-    def fake_input(prompt=""):
+    def fake_chat_line(message, history):
         f = next(calls)
         if isinstance(f, type(EOFError)):
             raise f
-        f(prompt)
+        f(message, history)
 
-    monkeypatch.setattr("builtins.input", fake_input)
+    monkeypatch.setattr(prompts, "chat_line", fake_chat_line)
     assert _chat_loop(make_config(tmp_path, [])) == 0
     out = capsys.readouterr().out
     assert "UTF-8" in out
 
-    # the wizard prompts take the same beating and re-ask instead of dying
-    answers = iter([bad_decode, "https://ok.example/api"])
+    # ask() takes the same beating and re-asks instead of dying
+    answers = iter([bad_decode, "x"])
 
-    def wizard_input(prompt=""):
+    def fake_prompt(*a, **k):
         f = next(answers)
         if callable(f):
-            f(prompt)
-            return ""
+            f(*a, **k)
+            raise AssertionError("callable should have raised")
         return f
 
-    assert (
-        setup._prompt("Base URL", validate=setup._http_like, input_fn=wizard_input)
-        == "https://ok.example/api"
-    )
+    monkeypatch.setattr(prompts, "prompt", fake_prompt)
+    assert prompts.ask("Label") == "x"
     assert "UTF-8" in capsys.readouterr().out
 
 
-def test_wizard_rejects_bad_url_then_accepts(tmp_path, monkeypatch, capsys):
-    from lithe_cli import setup
+def test_ask_empty_retries_and_default_keeps(monkeypatch, capsys):
+    from lithe_cli import prompts
+
+    answers = iter(["", "", "", "leftover"])
+
+    def fake_prompt(*a, **k):
+        return next(answers)
+
+    monkeypatch.setattr(prompts, "prompt", fake_prompt)
+    assert prompts.ask("Label") is None  # three empties → bail out
+    assert "不能为空" in capsys.readouterr().out
+
+    monkeypatch.setattr(
+        prompts, "prompt", lambda *a, **k: ""
+    )  # empty keeps the default
+    assert prompts.ask("Label", default="kept") == "kept"
+    assert prompts.ask("Key", default="sk-saved", password=True) == "sk-saved"
 
-    monkeypatch.setenv("LITHE_HOME", str(tmp_path))
-    answers = iter(["no-scheme.example", "https://ok.example/api", "sk-2", "m2", "n"])
-    saved = setup.run_setup_wizard(
-        input_fn=lambda prompt: next(answers), secret_fn=lambda prompt: next(answers)
-    )
-    assert saved is not None and saved["base_url"] == "https://ok.example/api"
-    assert "http" in capsys.readouterr().out  # the validation complaint
 
 
 def test_require_endpoint_wizard_only_on_tty(tmp_path, monkeypatch):

lithe_cli-0.2.4/lithe_cli/setup.py

@@ -1,198 +0,0 @@
-"""First-run endpoint setup: the wizard behind `lithe-cli config`.
-
-The CLI still ships no default endpoint — that principle is untouched.
-What changes is the failure mode: on an interactive terminal, a missing
-endpoint now means three prompts and a saved config file instead of a
-refusal with a wall of export lines. Non-interactive contexts (pipes,
-scripts, CI) never see the wizard; they keep the hard error.
-
-Precedence stays flag > env > config file, so the wizard only fills what
-nothing else provided.
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-from urllib.error import HTTPError, URLError
-from urllib.request import Request, urlopen
-
-from .config import (
-    ENV_API_KEY,
-    ENV_BASE_URL,
-    ENV_MODEL,
-    config_file,
-    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
-
-
-def _clean_answer(text: str) -> str:
-    """Strip whitespace plus bracketed-paste wrappers from a typed/pasted reply.
-
-    Shells (zsh, recent bash) leave the terminal in bracketed-paste mode
-    (DECSET 2004), so pasted text arrives wrapped in ``\\x1b[200~ ... \\x1b[201~``.
-    Neither ``input`` nor ``getpass`` removes those markers — a pasted API
-    key would be saved with them glued on and fail auth later.
-    """
-    for marker in _PASTE_MARKERS:
-        text = text.replace(marker.decode(), "")
-    return text.strip()
-
-
-def _read_masked(prompt: str = "") -> str:
-    """getpass-style hidden read that echoes a ``*`` per accepted character.
-
-    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.
-    """
-    return read_line(prompt, mask=True)
-
-
-def stdin_is_interactive() -> bool:
-    """True only when both ends are TTYs — pipes and captures stay clean."""
-    return sys.stdin.isatty() and sys.stdout.isatty()
-
-
-def _prompt(
-    label: str,
-    default: str = "",
-    secret: bool = False,
-    validate=None,
-    input_fn=input,
-    secret_fn=_read_masked,
-) -> str | None:
-    """Ask for one value; brackets show a non-secret default when set.
-
-    ``validate`` (value -> error string or None) re-prompts on bad input.
-    Returns None when the user bails out (empty too often, Ctrl+C/D).
-    """
-    ask = secret_fn if secret else input_fn
-    for _ in range(_MAX_EMPTY_TRIES):
-        if secret and default:
-            suffix = " [回车沿用已保存值]"
-        elif default:
-            suffix = f" [{default}]"
-        else:
-            suffix = ""
-        try:
-            answer = _clean_answer(ask(f"{label}{suffix}: "))
-        except (EOFError, KeyboardInterrupt):
-            print()
-            return None
-        except UnicodeDecodeError:
-            print(
-                ui.s(
-                    "\n  这行输入无法按 UTF-8 解码，已丢弃；"
-                    "请把终端与 locale 设为 UTF-8（如 export LANG=C.UTF-8）后重试。",
-                    RED,
-                )
-            )
-            continue
-        if not answer and default:
-            answer = default
-        if not answer:
-            print(ui.s("  这个值不能为空。", YELLOW))
-            continue
-        if validate is not None:
-            problem = validate(answer)
-            if problem:
-                print(ui.s(f"  {problem}", YELLOW))
-                continue
-        return answer
-    return None
-
-
-def _yes_no(label: str, default: bool, input_fn=input) -> bool:
-    hint = "Y/n" if default else "y/N"
-    try:
-        answer = input_fn(f"{label} [{hint}]: ").strip().lower()
-    except (EOFError, KeyboardInterrupt):
-        print()
-        return default
-    except UnicodeDecodeError:
-        print(ui.s("\n  这行输入无法按 UTF-8 解码，按默认值处理。", RED))
-        return default
-    return default if not answer else answer in ("y", "yes", "是")
-
-
-def _http_like(value: str) -> str | None:
-    return (
-        None
-        if value.startswith(("http://", "https://"))
-        else ("Base URL 需以 http:// 或 https:// 开头。")
-    )
-
-
-def probe_endpoint(base_url: str, api_key: str, timeout: float = 10.0) -> bool:
-    """One cheap GET ``{base_url}/models`` to catch typos before chat.
-
-    The save already happened: a failed probe warns, it never blocks —
-    endpoints legitimately lack ``/models`` or auth differently.
-    """
-    url = base_url.rstrip("/") + "/models"
-    req = Request(url, headers={"Authorization": f"Bearer {api_key}"})
-    try:
-        with urlopen(req, timeout=timeout) as resp:
-            print(ui.s(f"✓ 端点可达（HTTP {resp.status}）", GREEN))
-            return True
-    except HTTPError as exc:
-        if exc.code in (401, 403):
-            print(ui.s(f"~ 端点可达但拒绝了该 key（HTTP {exc.code}）", YELLOW))
-        else:
-            print(ui.s(f"~ 端点有响应：HTTP {exc.code}（无 /models 也无妨）", YELLOW))
-        return True  # reachable is all we wanted to know
-    except (URLError, OSError, TimeoutError) as exc:
-        print(ui.s(f"✗ 连不上 {url}：{exc}", RED))
-        return False
-
-
-def run_setup_wizard(input_fn=input, secret_fn=_read_masked) -> dict | None:
-    """Prompt for base_url / api_key / model and save the config file.
-
-    Defaults come from the already-saved file, then env vars, so
-    re-running the wizard is re-editing, not retyping. Returns the saved
-    endpoint dict, or None when the user cancels.
-    """
-    saved = load_saved_endpoint()
-    env = {
-        "base_url": os.environ.get(ENV_BASE_URL, "").strip(),
-        "api_key": os.environ.get(ENV_API_KEY, "").strip(),
-        "model": os.environ.get(ENV_MODEL, "").strip(),
-    }
-    defaults = {k: saved.get(k, "") or env[k] for k in env}
-
-    print(ui.s("初始设置：配置模型端点", CYAN, BOLD))
-    print(
-        f"值保存在 {config_file()}（权限 600）；"
-        "优先级 flag > 环境变量 > 配置文件。\n"
-        "之后可用 `lithe-cli config` 重新配置。"
-    )
-    base_url = _prompt(
-        "Base URL（如 https://your-endpoint/api/v1）",
-        defaults["base_url"],
-        validate=_http_like,
-        input_fn=input_fn,
-    )
-    api_key = _prompt(
-        "API key",
-        defaults["api_key"],
-        secret=True,
-        input_fn=input_fn,
-        secret_fn=secret_fn,
-    )
-    model = _prompt("模型名（如 glm-4.6）", defaults["model"], input_fn=input_fn)
-    if not (base_url and api_key and model):
-        print(ui.s("已取消，未保存任何配置。", YELLOW))
-        return None
-
-    path = save_endpoint(api_key, base_url, model)
-    print(ui.s(f"✓ 已保存到 {path}", GREEN))
-    if _yes_no("现在测试一下连接吗", True, input_fn=input_fn):
-        probe_endpoint(base_url, api_key)
-    return {"api_key": api_key, "base_url": base_url, "model": model}

lithe_cli-0.2.4/lithe_cli/ttyio.py

@@ -1,195 +0,0 @@
-"""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)