lithe-cli 0.4.1__tar.gz → 0.6.0__tar.gz

{lithe_cli-0.4.1 → lithe_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lithe-cli
-Version: 0.4.1
+Version: 0.6.0
 Summary: Command-line interface for the lithe agent kernel: chat, one-shot runs, undo, and run inspection.
 License: MIT License
         
@@ -113,27 +113,42 @@ $ lithe run "总结 README.md 的要点，存到 SUMMARY.md"
 usage/context gauges; `--max-steps` caps the tool loop;
 `--context-window` enables fullness gauges.
 
-### Interactive chat
-
-```bash
-$ lithe chat
-╭──────────────────────────────────────╮
-│ lithe 0.4.0                          │
-│ model   your-model                   │
-│ workdir /home/me/my-project          │
-│ /help 查看会话命令，/exit 退出       │
-╰──────────────────────────────────────╯
-lithe ❯ 把 a.txt 改成三行待办清单
-  ⚒ write_file {"path": "a.txt", ...}
-  ✓ 写入 a.txt 0.0s
-已完成。
-── done · steps 2 · tokens 180
-lithe ❯ /exit
+### Full-screen interface
+
+On an interactive terminal, `lithe chat` and `lithe run TASK` open a
+persistent full-screen interface instead of scribbling one-line events
+into the console:
+
+```text
+ lithe 0.6.0 · your-model · /home/me/my-project      ● 完成 · 0.2s
+┌─ 对话 ──────────────────────────────┐┌─ 运行状态 ─────────┐
+│ 把 a.txt 改成三行待办清单            ││ ● 完成 · 0.2s      │
+│ ⚒ update_todos {"todos": [...]}     ││ 步骤 2/35 · 0.2s   │
+│ ✓ 任务清单已更新（3 条） 0.0s        ││ ✓ update_todos 0.0s│
+│ ⚒ write_file {"path": "a.txt"}      ││ ✓ write_file 0.0s  │
+│ ✓ 写入 a.txt 0.0s                   ││ ── 待办 1/3        │
+│ 已完成。                             ││ [~] 修改 a.txt     │
+│                                     ││ ── 用量            │
+│                                     ││ tokens 1,240       │
+└─────────────────────────────────────┘└────────────────────┘
+lithe ❯ _
+ ● 完成 · step 2/35 · 1,240 tok · $0.0021    Enter 发送 · /help 命令
 ```
 
-History carries across turns within a session (each turn is its own run in
-the store, replayed as context for the next). `/new` clears the session,
-`/tools` lists the registered tools, `/help` lists the commands.
+The left pane is the conversation (task, tool calls and outcomes, the
+streaming assistant reply); the right sidebar shows run status, step
+budget and elapsed time, recent tool calls with duration, the agent's
+todo list (updated live as the agent rewrites it), and running token /
+cost / context totals. The screen stays up between turns — a finished
+run does not dump you back into the raw console. `Ctrl+C` cancels the
+current turn while running and exits when idle; in `lithe run` mode the
+result stays on screen until you press `q`. Layout, wrapping and
+alignment are East-Asian-width aware; narrower terminals stack the two
+panes vertically. Pipes and CI keep the plain per-line output unchanged.
+
+History carries across turns within a session (each turn is its own run
+in the store, replayed as context for the next). `/new` clears the
+session, `/tools` lists the registered tools, `/help` lists the commands.
 
 ### Extra capabilities
 

{lithe_cli-0.4.1 → lithe_cli-0.6.0}/README.md

@@ -65,27 +65,42 @@ $ lithe run "总结 README.md 的要点，存到 SUMMARY.md"
 usage/context gauges; `--max-steps` caps the tool loop;
 `--context-window` enables fullness gauges.
 
-### Interactive chat
-
-```bash
-$ lithe chat
-╭──────────────────────────────────────╮
-│ lithe 0.4.0                          │
-│ model   your-model                   │
-│ workdir /home/me/my-project          │
-│ /help 查看会话命令，/exit 退出       │
-╰──────────────────────────────────────╯
-lithe ❯ 把 a.txt 改成三行待办清单
-  ⚒ write_file {"path": "a.txt", ...}
-  ✓ 写入 a.txt 0.0s
-已完成。
-── done · steps 2 · tokens 180
-lithe ❯ /exit
+### Full-screen interface
+
+On an interactive terminal, `lithe chat` and `lithe run TASK` open a
+persistent full-screen interface instead of scribbling one-line events
+into the console:
+
+```text
+ lithe 0.6.0 · your-model · /home/me/my-project      ● 完成 · 0.2s
+┌─ 对话 ──────────────────────────────┐┌─ 运行状态 ─────────┐
+│ 把 a.txt 改成三行待办清单            ││ ● 完成 · 0.2s      │
+│ ⚒ update_todos {"todos": [...]}     ││ 步骤 2/35 · 0.2s   │
+│ ✓ 任务清单已更新（3 条） 0.0s        ││ ✓ update_todos 0.0s│
+│ ⚒ write_file {"path": "a.txt"}      ││ ✓ write_file 0.0s  │
+│ ✓ 写入 a.txt 0.0s                   ││ ── 待办 1/3        │
+│ 已完成。                             ││ [~] 修改 a.txt     │
+│                                     ││ ── 用量            │
+│                                     ││ tokens 1,240       │
+└─────────────────────────────────────┘└────────────────────┘
+lithe ❯ _
+ ● 完成 · step 2/35 · 1,240 tok · $0.0021    Enter 发送 · /help 命令
 ```
 
-History carries across turns within a session (each turn is its own run in
-the store, replayed as context for the next). `/new` clears the session,
-`/tools` lists the registered tools, `/help` lists the commands.
+The left pane is the conversation (task, tool calls and outcomes, the
+streaming assistant reply); the right sidebar shows run status, step
+budget and elapsed time, recent tool calls with duration, the agent's
+todo list (updated live as the agent rewrites it), and running token /
+cost / context totals. The screen stays up between turns — a finished
+run does not dump you back into the raw console. `Ctrl+C` cancels the
+current turn while running and exits when idle; in `lithe run` mode the
+result stays on screen until you press `q`. Layout, wrapping and
+alignment are East-Asian-width aware; narrower terminals stack the two
+panes vertically. Pipes and CI keep the plain per-line output unchanged.
+
+History carries across turns within a session (each turn is its own run
+in the store, replayed as context for the next). `/new` clears the
+session, `/tools` lists the registered tools, `/help` lists the commands.
 
 ### Extra capabilities
 

{lithe_cli-0.4.1 → lithe_cli-0.6.0}/lithe_cli/__init__.py

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

{lithe_cli-0.4.1 → lithe_cli-0.6.0}/lithe_cli/agent.py

@@ -187,8 +187,17 @@ async def execute(
     task: str,
     history: list[dict] | None = None,
     run_id: str | None = None,
+    on_event=None,
+    stop=None,
 ) -> tuple[str, dict, Any]:
-    """Run one task end-to-end; returns (run_id, done_event, host)."""
+    """Run one task end-to-end; returns (run_id, done_event, host).
+
+    ``on_event`` (the full-screen TUI supplies one) receives every kernel
+    event and silences the line-oriented printing below, including the
+    footer — the caller renders from the events instead. ``stop`` is the
+    kernel's cancellation handle, surfaced so Ctrl+C can cancel a turn
+    without killing the process.
+    """
     reg = build_registry(cfg)
     host = build_host(cfg, reg)
     rid = run_id or uuid.uuid4().hex[:12]
@@ -211,9 +220,12 @@ async def execute(
     ev: dict = {}
     pending: dict[str, float] = {}
     try:
-        async for ev in host.run(ctx, task, history=history):
-            render_event(ev, cfg.verbose, cfg.stream, pending)
-        if ev.get("type") == "done":
+        async for ev in host.run(ctx, task, history=history, stop=stop):
+            if on_event is not None:
+                on_event(ev)
+            else:
+                render_event(ev, cfg.verbose, cfg.stream, pending)
+        if ev.get("type") == "done" and on_event is None:
             if cfg.stream and pending.get("_deltas"):
                 print()  # close the streaming line before the footer
             ui.footer(ev)

{lithe_cli-0.4.1 → lithe_cli-0.6.0}/lithe_cli/main.py

@@ -33,6 +33,7 @@ from . import prompts
 from .agent import build_registry, execute, sandbox_backend, undo
 from .config import config_file, load_config, require_endpoint
 from .prompts import open_history
+from .tui import screen_supported
 from .ui import BOLD, CYAN, GREEN, RED, YELLOW, configure, truncate, ui
 
 
@@ -397,9 +398,17 @@ def main(argv: list[str] | None = None) -> int:
     configure(cfg.color)
     if args.command == "run":
         require_endpoint(cfg, interactive=not args.no_setup)
+        if screen_supported():
+            from .tui import run_screen
+
+            return asyncio.run(run_screen(cfg, args.task, "run"))
         return _cmd_run(cfg, args.task)
     if args.command == "chat":
         require_endpoint(cfg, interactive=not args.no_setup)
+        if screen_supported():
+            from .tui import run_screen
+
+            return asyncio.run(run_screen(cfg, None, "chat"))
         return _chat_loop(cfg)
     if args.command == "tools":
         return _cmd_tools(cfg)

lithe_cli-0.6.0/lithe_cli/tui.py

@@ -0,0 +1,512 @@
+"""Persistent full-screen interface for chat and one-shot runs.
+
+One prompt_toolkit ``Application`` owns the terminal for the whole
+session: a conversation pane (task, tool feed, streaming assistant text)
+on the left, a status sidebar (run state, tool calls, todos, token /
+cost totals) on the right, an input line and a status bar. Turns stream
+into the panes and the screen stays up between runs — no falling back
+to the raw console after a task finishes.
+
+Everything degrades: without a TTY ``main`` never routes here, and the
+frame composition is a pure function (``compose_frame``) so it renders
+identically under tests.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shutil
+import sys
+import time
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import (
+    BufferControl,
+    Dimension,
+    FormattedTextControl,
+    HSplit,
+    Layout,
+    VSplit,
+    Window,
+)
+from prompt_toolkit.styles import Style
+
+from .ui import display_width, pad, truncate, wrap_text
+
+_TODO_MARKS = {"pending": "[ ]", "in_progress": "[~]", "completed": "[x]", "cancelled": "[-]"}
+_TODO_CLASSES = {
+    "pending": "",
+    "in_progress": "todo-ip",
+    "completed": "todo-done",
+    "cancelled": "dim",
+}
+_STATUS_DONE = "done"
+
+_STYLE = Style.from_dict(
+    {
+        "hdr": "bg:ansiblue fg:ansiwhite bold",
+        "foot": "bg:ansibrightblack fg:ansiwhite",
+        "border": "fg:ansibrightblack",
+        "title": "fg:ansicyan bold",
+        "prompt": "fg:ansicyan bold",
+        "user": "fg:ansiblue bold",
+        "assistant": "fg:ansigreen",
+        "tool": "fg:ansicyan",
+        "ok": "fg:ansigreen",
+        "err": "fg:ansired bold",
+        "warn": "fg:ansiyellow",
+        "dim": "fg:ansibrightblack",
+        "reason": "fg:ansimagenta",
+        "todo-ip": "fg:ansiyellow",
+        "todo-done": "fg:ansigreen",
+        "st-idle": "fg:ansicyan bold",
+        "st-run": "fg:ansiyellow bold",
+        "st-ok": "fg:ansigreen bold",
+        "st-bad": "fg:ansired bold",
+    }
+)
+
+_WELCOME = (
+    "输入任务开始对话；/help 查看命令。",
+    "Ctrl+C 在运行中取消本轮，空闲时退出。",
+)
+
+
+def screen_supported() -> bool:
+    """The TUI needs a real terminal (never pipes, CI or dumb terms)."""
+    return sys.stdout.isatty() and os.environ.get("TERM") != "dumb"
+
+
+class TuiState:
+    """Everything the frame renders; mutated by kernel events only."""
+
+    def __init__(
+        self,
+        model: str,
+        workspace: str,
+        max_steps: int,
+        todos: list[dict] | None = None,
+    ):
+        self.model = model
+        self.workspace = workspace
+        self.max_steps = max_steps
+        self.todos = list(todos or [])
+        self.running = False
+        self.status = "就绪"
+        self.step = 0
+        self.tokens = 0
+        self.cost = 0.0
+        self.context_percent = None
+        self.tools: list[dict] = []
+        self.feed: list[tuple[str, str]] = []
+        self.streaming = ""
+        self.started: float | None = None
+        self.last_status: str | None = None
+        self.stop: asyncio.Event | None = None
+        self._app: Application | None = None
+
+    # -- feed ---------------------------------------------------------------
+
+    def say(self, cls: str, text: str) -> None:
+        for line in str(text).splitlines() or [""]:
+            self.feed.append((cls, line))
+        del self.feed[:-400]
+        self.invalidate()
+
+    def invalidate(self) -> None:
+        if self._app is not None and self._app.is_running:
+            self._app.invalidate()
+
+    # -- events -------------------------------------------------------------
+
+    def on_event(self, ev: dict) -> None:
+        kind = ev.get("type")
+        if kind == "run_start":
+            self.status = "思考中"
+            self.step = 0
+            self.tokens = 0
+            self.cost = 0.0
+            self.tools = []
+            self.started = time.monotonic()
+        elif kind == "step":
+            self.step = int(ev.get("step") or 0)
+            self.status = "思考中"
+        elif kind == "assistant_delta":
+            self.streaming += str(ev.get("text") or "")
+        elif kind == "assistant":
+            text = str(ev.get("text") or "")
+            if text and not self.streaming:
+                self.say("assistant", text)
+            self.streaming = ""
+        elif kind == "tool_call":
+            name = str(ev.get("name") or "tool")
+            self.tools.append(
+                {
+                    "id": ev.get("id"),
+                    "name": name,
+                    "args": json.dumps(ev.get("args") or {}, ensure_ascii=False),
+                    "status": "running",
+                    "t0": time.monotonic(),
+                    "elapsed": None,
+                }
+            )
+            self.say("tool", f"⚒ {name} {self.tools[-1]['args']}")
+            self.status = f"工具 {name}"
+        elif kind == "tool_result":
+            self._settle_tool(ev.get("id"), bool(ev.get("ok")), ev.get("summary"))
+        elif kind == "todo_change":
+            self.todos = list(ev.get("new") or [])
+            self.say("dim", f"□ 任务清单已更新（{len(self.todos)} 项）")
+        elif kind == "usage":
+            self.tokens += int(ev.get("total_tokens") or 0)
+            self.cost += float(ev.get("cost") or 0)
+            if ev.get("context_percent") is not None:
+                self.context_percent = ev["context_percent"]
+        elif kind == "reasoning":
+            digest = str(ev.get("text") or ev.get("summary") or "").replace("\n", " ")
+            if digest:
+                self.say("reason", f"~ {digest[:200]}")
+        elif kind == "error":
+            self.status = "失败"
+            self.say("err", str(ev.get("message") or "运行出错"))
+        elif kind == "cancelled":
+            self.say("warn", "（已取消）")
+        elif kind == "done":
+            status = str(ev.get("status") or _STATUS_DONE)
+            self.last_status = status
+            self.status = {
+                "done": "完成",
+                "failed": "失败",
+                "cancelled": "已取消",
+                "max_steps": "步数上限",
+                "budget_exceeded": "预算超限",
+                "empty_response": "空响应",
+            }.get(status, status)
+            self.step = int(ev.get("steps") or self.step)
+            self.tokens = int(ev.get("tokens") or self.tokens)
+            self.cost = float(ev.get("cost") or self.cost)
+            if self.started is not None:
+                self.status += f" · {time.monotonic() - self.started:.1f}s"
+        self.invalidate()
+
+    def _settle_tool(self, tool_id, ok: bool, summary) -> None:
+        tool = next(
+            (t for t in reversed(self.tools) if t["id"] == tool_id and t["status"] == "running"),
+            None,
+        )
+        if tool is not None:
+            tool["elapsed"] = time.monotonic() - tool["t0"]
+            tool["status"] = "done" if ok else "failed"
+            mark = "✓" if ok else "✗"
+            label = str(summary or tool["name"]).replace("\n", " ")
+            self.say("ok" if ok else "err", f"{mark} {label} {tool['elapsed']:.1f}s")
+
+
+# -- frame composition (pure; shared with tests) ---------------------------
+
+def _status_class(status: str) -> str:
+    if "失败" in status or "上限" in status or "超限" in status or "空响应" in status:
+        return "st-bad"
+    if status in ("就绪",):
+        return "st-idle"
+    if "完成" in status or "取消" in status:
+        return "st-ok"
+    return "st-run"
+
+
+def _panel(title: str, lines: list[tuple[str, str]], width: int, height: int) -> list[list]:
+    """A bordered box of exactly *height* rows, each *width* columns wide."""
+    width = max(20, width)
+    height = max(4, height)
+    inner = max(1, width - 4)
+    label = truncate(f" {title} ", inner)
+    rows = [
+        [
+            ("class:border", "┌"),
+            ("class:title", label),
+            ("class:border", "─" * (inner - display_width(label)) + "┐"),
+        ]
+    ]
+    wrapped: list[tuple[str, str]] = []
+    for cls, text in lines:
+        wrapped.extend((cls, seg) for seg in wrap_text(text, inner))
+    for cls, seg in wrapped[-(height - 2):]:
+        rows.append(
+            [("class:border", "│ "), (f"class:{cls}" if cls else "", pad(seg, inner)), ("class:border", " │")]
+        )
+    for _ in range(height - 2 - (len(rows) - 1)):
+        rows.append([("class:border", "│ "), ("", " " * inner), ("class:border", " │")])
+    rows.append([("class:border", "└" + "─" * inner + "┘")])
+    return rows
+
+
+def _conversation_lines(state: TuiState) -> list[tuple[str, str]]:
+    lines = list(state.feed)
+    if state.streaming:
+        lines.append(("assistant", state.streaming))
+    if not lines:
+        lines = [("dim", text) for text in _WELCOME]
+    return lines
+
+
+def _sidebar_lines(state: TuiState) -> list[tuple[str, str]]:
+    cls = _status_class(state.status)
+    elapsed = (
+        time.monotonic() - state.started
+        if state.started is not None and state.running
+        else 0.0
+    )
+    lines = [
+        (cls, f"● {state.status}"),
+        ("dim", f"步骤 {state.step}/{state.max_steps} · {elapsed:.1f}s"),
+        ("dim", f"模型 {state.model}"),
+        ("dim", f"目录 {state.workspace}"),
+        ("dim", "── 工具调用"),
+    ]
+    if not state.tools:
+        lines.append(("dim", "暂无调用"))
+    for tool in state.tools[-4:]:
+        mark = {"running": "…", "done": "✓", "failed": "✗"}.get(tool["status"], "·")
+        suffix = f" {tool['elapsed']:.1f}s" if tool.get("elapsed") is not None else ""
+        lines.append(("ok" if tool["status"] == "done" else "err" if tool["status"] == "failed" else "tool",
+                      f"{mark} {tool['name']}{suffix}"))
+    done = sum(todo.get("status") == "completed" for todo in state.todos)
+    lines.extend([("dim", f"── 待办 {done}/{len(state.todos)}")])
+    if not state.todos:
+        lines.append(("dim", "暂无任务清单"))
+    for todo in state.todos[-5:]:
+        mark = _TODO_MARKS.get(todo.get("status"), "[ ]")
+        cls_todo = _TODO_CLASSES.get(todo.get("status"), "")
+        lines.append((cls_todo, f"{mark} {todo.get('content', '')}"))
+    ctx = "—" if state.context_percent is None else f"{state.context_percent}%"
+    lines.extend(
+        [
+            ("dim", "── 用量"),
+            ("", f"tokens {state.tokens:,}"),
+            ("", f"cost ${state.cost:.4f} · ctx {ctx}"),
+        ]
+    )
+    return lines
+
+
+def _header_row(state: TuiState, width: int, version: str) -> list:
+    chip = f" {state.status} "
+    left = truncate(
+        f" lithe {version} · {state.model} · {state.workspace}",
+        width - display_width(chip) - 1,
+    )
+    return [
+        ("class:hdr", pad(left, width - display_width(chip))),
+        (f"class:hdr class:{_status_class(state.status)}", chip),
+    ]
+
+
+def compose_frame(state: TuiState, width: int, height: int, version: str) -> list[list]:
+    """The whole middle of the screen: header row + panel rows."""
+    width = max(40, width)
+    height = max(10, height)
+    rows = [_header_row(state, width, version)]
+    body = height - 3  # header 1 + input 1 + footer 1
+    if width >= 76:
+        side_w = min(44, max(30, width // 3))
+        conv = _panel("对话", _conversation_lines(state), width - side_w, body)
+        side = _panel("运行状态", _sidebar_lines(state), side_w, body)
+        rows.extend(c + s for c, s in zip(conv, side, strict=True))
+    else:
+        conv_h = max(4, body * 3 // 5)
+        rows.extend(_panel("对话", _conversation_lines(state), width, conv_h))
+        rows.extend(_panel("运行状态", _sidebar_lines(state), width, max(4, body - conv_h)))
+    return rows
+
+
+def compose_footer(state: TuiState, width: int, running_hint: str) -> list:
+    dot = f"class:foot class:{_status_class(state.status)}"
+    left = (
+        f" ● {state.status} · step {state.step}/{state.max_steps}"
+        f" · {state.tokens:,} tok · ${state.cost:.4f}"
+    )
+    room = width - display_width(running_hint) - display_width(left) - 2
+    text = left + (" " * max(1, room)) if room >= 1 else truncate(left, width - display_width(running_hint) - 1)
+    return [(dot, " "), ("class:foot", pad(text, width - display_width(running_hint))), ("class:foot", running_hint)]
+
+
+# -- application ------------------------------------------------------------
+
+def _chat_history():
+    """Persistent chat history (prompt_toolkit FileHistory), shared with the plain REPL."""
+    from .prompts import open_history
+
+    return open_history()
+
+
+def _term_size(app: Application | None) -> tuple[int, int]:
+    if app is not None and app.is_running:
+        size = app.output.get_size()
+        return size.columns, size.rows
+    cols, rows = shutil.get_terminal_size((100, 30))
+    return cols, rows
+
+
+def build_app(state: TuiState, mode: str, version: str, on_line) -> tuple[Application, Buffer]:
+    """Assemble the full-screen Application; the input line drives *on_line*."""
+    kb = KeyBindings()
+
+    @kb.add("c-c", eager=True)
+    def _cancel(event):
+        if state.running and state.stop is not None:
+            state.stop.set()
+            state.say("warn", "（正在取消本轮…）")
+        else:
+            event.app.exit()
+
+    if mode == "run":
+
+        @kb.add("q", eager=True)
+        @kb.add("enter", eager=True)
+        def _quit(event):
+            if not state.running:
+                event.app.exit()
+
+    buffer = Buffer(
+        history=_chat_history() if mode == "chat" else None,
+        multiline=False,
+        read_only=Condition(lambda: state.running or mode == "run"),
+        accept_handler=lambda buff: (on_line(buff.text), False)[1],
+    )
+
+    def _frame():
+        cols, rows = _term_size(state._app)
+        fragments = []
+        for row in compose_frame(state, cols, rows, version):
+            fragments.extend(row)
+            fragments.append(("", "\n"))
+        return FormattedText(fragments)
+
+    def _footer():
+        cols, _ = _term_size(state._app)
+        if mode == "run":
+            hint = " q 退出 " if not state.running else " Ctrl+C 取消 "
+        elif state.running:
+            hint = " Ctrl+C 取消本轮 "
+        else:
+            hint = " Enter 发送 · /help 命令 "
+        return FormattedText(compose_footer(state, cols, hint))
+
+    def _prompt_text():
+        return FormattedText([("class:prompt", "lithe ❯ ")])
+
+    frame_win = Window(
+        FormattedTextControl(_frame, show_cursor=False), wrap_lines=False, height=Dimension(weight=1)
+    )
+    input_row = VSplit(
+        [
+            Window(FormattedTextControl(_prompt_text, show_cursor=False), width=Dimension.exact(8)),
+            Window(BufferControl(buffer=buffer), wrap_lines=False),
+        ]
+    )
+    footer_win = Window(FormattedTextControl(_footer, show_cursor=False), height=Dimension.exact(1))
+    app = Application(
+        layout=Layout(HSplit([frame_win, input_row, footer_win])),
+        key_bindings=kb,
+        style=_STYLE,
+        full_screen=True,
+    )
+    app.layout.focus(buffer)
+    return app, buffer
+
+
+_CHAT_HELP = """可用命令：
+  /help   显示这段帮助
+  /tools  列出当前注册的工具
+  /new    清空会话历史，重新开始
+  /exit   退出（等同 /quit）"""
+
+
+async def run_screen(cfg, task: str | None, mode: str) -> int:
+    """Full-screen driver for `lithe chat` (mode='chat') and `lithe run`."""
+    from lithe.bundles import JsonlRunStore, JsonTodoStore
+
+    from . import __version__
+    from .agent import build_registry, execute
+
+    todo_store = JsonTodoStore(cfg.store_dir / f"todos-{cfg.user_id}.json")
+    state = TuiState(
+        cfg.model or "(scripted)",
+        str(cfg.workspace_dir.resolve()),
+        cfg.max_steps,
+        todo_store.list(),
+    )
+    store = JsonlRunStore(cfg.store_dir)
+    run_ids: list[str] = []
+    current: dict = {"task": None}
+
+    def _slash(line: str) -> bool:
+        if line in ("/exit", "/quit"):
+            state._app.exit()
+            return True
+        if line == "/help":
+            state.say("dim", _CHAT_HELP)
+            return True
+        if line == "/tools":
+            names = sorted(build_registry(cfg).names())
+            state.say("dim", "已注册工具：" + "、".join(names))
+            return True
+        if line == "/new":
+            run_ids.clear()
+            state.say("dim", "（已清空会话历史）")
+            return True
+        return False
+
+    async def _turn(line: str) -> None:
+        stop = asyncio.Event()
+        state.stop = stop
+        state.running = True
+        state.started = time.monotonic()
+        state.invalidate()
+        try:
+            history = store.messages_for_runs(run_ids, cfg.user_id) if run_ids else None
+            rid, done, _ = await execute(
+                cfg, line, history=history, on_event=state.on_event, stop=stop
+            )
+            run_ids.append(rid)
+            if done.get("status") != "done":
+                state.say("warn", f"（本轮状态：{done.get('status')}）")
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            state.say("err", f"运行出错：{exc}")
+        finally:
+            state.running = False
+            state.stop = None
+            state.invalidate()
+
+    def on_line(text: str) -> None:
+        line = text.strip()
+        if not line or state.running:
+            return
+        state.say("user", line)
+        if line.startswith("/") and _slash(line):
+            return
+        current["task"] = asyncio.create_task(_turn(line))
+
+    app, _ = build_app(state, mode, __version__, on_line)
+    state._app = app
+    if mode == "run" and task:
+
+        async def _start() -> None:
+            state.say("user", task)
+            await _turn(task)
+
+        asyncio.create_task(_start())
+    await app.run_async()
+    if current["task"] is not None and not current["task"].done():
+        current["task"].cancel()
+    if mode == "run":
+        return 0 if state.last_status == "done" else 1
+    return 0

{lithe_cli-0.4.1 → lithe_cli-0.6.0}/lithe_cli/ui.py

@@ -79,6 +79,32 @@ def truncate(text: str, width: int) -> str:
     return out + "…"
 
 
+def wrap_text(text: str, width: int) -> list[str]:
+    """Wrap *text* to *width* display columns (CJK-aware, newline-aware)."""
+    if width < 1:
+        return []
+    lines: list[str] = []
+    current = ""
+    used = 0
+    for ch in str(text):
+        if ch == "\n":
+            lines.append(current)
+            current = ""
+            used = 0
+            continue
+        w = 2 if unicodedata.east_asian_width(ch) in "WF" else 1
+        if used + w > width and current:
+            lines.append(current)
+            current = ""
+            used = 0
+        if w <= width:
+            current += ch
+            used += w
+    if current or not lines:
+        lines.append(current)
+    return lines
+
+
 class UI:
     """All terminal output goes through here; ``color`` gates every code."""
 

{lithe_cli-0.4.1 → lithe_cli-0.6.0}/lithe_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lithe-cli
-Version: 0.4.1
+Version: 0.6.0
 Summary: Command-line interface for the lithe agent kernel: chat, one-shot runs, undo, and run inspection.
 License: MIT License
         
@@ -113,27 +113,42 @@ $ lithe run "总结 README.md 的要点，存到 SUMMARY.md"
 usage/context gauges; `--max-steps` caps the tool loop;
 `--context-window` enables fullness gauges.
 
-### Interactive chat
-
-```bash
-$ lithe chat
-╭──────────────────────────────────────╮
-│ lithe 0.4.0                          │
-│ model   your-model                   │
-│ workdir /home/me/my-project          │
-│ /help 查看会话命令，/exit 退出       │
-╰──────────────────────────────────────╯
-lithe ❯ 把 a.txt 改成三行待办清单
-  ⚒ write_file {"path": "a.txt", ...}
-  ✓ 写入 a.txt 0.0s
-已完成。
-── done · steps 2 · tokens 180
-lithe ❯ /exit
+### Full-screen interface
+
+On an interactive terminal, `lithe chat` and `lithe run TASK` open a
+persistent full-screen interface instead of scribbling one-line events
+into the console:
+
+```text
+ lithe 0.6.0 · your-model · /home/me/my-project      ● 完成 · 0.2s
+┌─ 对话 ──────────────────────────────┐┌─ 运行状态 ─────────┐
+│ 把 a.txt 改成三行待办清单            ││ ● 完成 · 0.2s      │
+│ ⚒ update_todos {"todos": [...]}     ││ 步骤 2/35 · 0.2s   │
+│ ✓ 任务清单已更新（3 条） 0.0s        ││ ✓ update_todos 0.0s│
+│ ⚒ write_file {"path": "a.txt"}      ││ ✓ write_file 0.0s  │
+│ ✓ 写入 a.txt 0.0s                   ││ ── 待办 1/3        │
+│ 已完成。                             ││ [~] 修改 a.txt     │
+│                                     ││ ── 用量            │
+│                                     ││ tokens 1,240       │
+└─────────────────────────────────────┘└────────────────────┘
+lithe ❯ _
+ ● 完成 · step 2/35 · 1,240 tok · $0.0021    Enter 发送 · /help 命令
 ```
 
-History carries across turns within a session (each turn is its own run in
-the store, replayed as context for the next). `/new` clears the session,
-`/tools` lists the registered tools, `/help` lists the commands.
+The left pane is the conversation (task, tool calls and outcomes, the
+streaming assistant reply); the right sidebar shows run status, step
+budget and elapsed time, recent tool calls with duration, the agent's
+todo list (updated live as the agent rewrites it), and running token /
+cost / context totals. The screen stays up between turns — a finished
+run does not dump you back into the raw console. `Ctrl+C` cancels the
+current turn while running and exits when idle; in `lithe run` mode the
+result stays on screen until you press `q`. Layout, wrapping and
+alignment are East-Asian-width aware; narrower terminals stack the two
+panes vertically. Pipes and CI keep the plain per-line output unchanged.
+
+History carries across turns within a session (each turn is its own run
+in the store, replayed as context for the next). `/new` clears the
+session, `/tools` lists the registered tools, `/help` lists the commands.
 
 ### Extra capabilities
 

{lithe_cli-0.4.1 → lithe_cli-0.6.0}/lithe_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ lithe_cli/main.py
 lithe_cli/prompts.py
 lithe_cli/py.typed
 lithe_cli/setup.py
+lithe_cli/tui.py
 lithe_cli/ui.py
 lithe_cli.egg-info/PKG-INFO
 lithe_cli.egg-info/SOURCES.txt

{lithe_cli-0.4.1 → lithe_cli-0.6.0}/tests/test_cli.py

@@ -244,6 +244,69 @@ def test_ui_banner_fits_terminal_width():
     assert "…" in out
 
 
+def test_run_dashboard_shows_tools_todos_and_usage():
+    from lithe_cli.tui import TuiState
+
+    state = TuiState("model-x", "/workspace", 12)
+    state.on_event({"type": "run_start", "model": "model-x", "max_steps": 12})
+    state.on_event({"type": "step", "step": 2})
+    state.on_event({"type": "tool_call", "id": "c1", "name": "read_file", "args": {"path": "main.py"}})
+    state.on_event({"type": "tool_result", "id": "c1", "ok": True, "summary": "已读取文件"})
+    state.on_event({
+        "type": "todo_change",
+        "new": [{"content": "检查测试", "status": "in_progress"}],
+    })
+    state.on_event({"type": "usage", "total_tokens": 120, "context_tokens": 100, "context_percent": 10.0, "cost": 0.001})
+    state.on_event({"type": "assistant", "text": "检查完成"})
+    state.on_event({"type": "done", "status": "done", "steps": 3, "tokens": 120, "cost": 0.001})
+
+    assert state.tools[0]["status"] == "done"
+    assert state.tools[0]["elapsed"] is not None
+    assert state.todos and state.todos[0]["content"] == "检查测试"
+    assert state.tokens == 120 and state.last_status == "done"
+    feed_text = "\n".join(text for _, text in state.feed)
+    assert "read_file" in feed_text and "检查完成" in feed_text
+
+
+def test_run_dashboard_fits_narrow_terminal():
+    from lithe_cli.tui import TuiState, compose_footer, compose_frame
+    from lithe_cli.ui import display_width
+
+    state = TuiState("模型", "/工作区", 5)
+    state.on_event({"type": "tool_call", "id": "c1", "name": "read_file", "args": {"path": "x"}})
+    state.on_event({"type": "todo_change", "new": [{"content": "处理中文任务", "status": "pending"}]})
+
+    for width, height in ((100, 30), (76, 24), (56, 24), (40, 20)):
+        rows = compose_frame(state, width, height, "0.6.0")
+        assert len(rows) == height - 2
+        for row in rows:
+            assert display_width("".join(text for _, text in row)) <= width
+        assert all(display_width(text) <= width for _, text in compose_footer(state, width, " hint "))
+    wide = "\n".join("".join(t for _, t in row) for row in compose_frame(state, 100, 30, "0.6.0"))
+    narrow = "\n".join("".join(t for _, t in row) for row in compose_frame(state, 56, 24, "0.6.0"))
+    assert "对话" in wide and "运行状态" in wide
+    assert "处理中文任务" in narrow  # stacked layout still shows todos
+
+
+def test_wrap_text_is_cjk_aware():
+    from lithe_cli.ui import wrap_text
+
+    assert wrap_text("abcdefghij", 4) == ["abcd", "efgh", "ij"]
+    assert wrap_text("中文字符测试", 4) == ["中文", "字符", "测试"]
+    assert wrap_text("a\nbc", 4) == ["a", "bc"]
+
+
+def test_execute_on_event_is_quiet_and_yields_events(tmp_path, capsys):
+    seen = []
+    cfg = make_config(tmp_path, WRITE_THEN_ANSWER)
+    rid, done, _ = asyncio.run(execute(cfg, "把 a.txt 写为 hi", on_event=seen.append))
+    assert done["status"] == "done"
+    assert any(e["type"] == "tool_call" for e in seen)
+    assert any(e["type"] == "done" for e in seen)
+    assert capsys.readouterr().out == ""  # the TUI path prints nothing
+    assert (cfg.workspace_dir / "a.txt").exists()
+
+
 def test_no_command_prints_help(capsys):
     from lithe_cli.main import main