lithe-cli 0.4.0__tar.gz → 0.5.0__tar.gz

{lithe_cli-0.4.0 → lithe_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lithe-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: Command-line interface for the lithe agent kernel: chat, one-shot runs, undo, and run inspection.
 License: MIT License
         
@@ -39,7 +39,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: lithe>=0.9.7
+Requires-Dist: lithe>=0.9.8
 Requires-Dist: prompt-toolkit>=3.0.38
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"

{lithe_cli-0.4.0 → lithe_cli-0.5.0}/lithe_cli/__init__.py

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

{lithe_cli-0.4.0 → lithe_cli-0.5.0}/lithe_cli/agent.py

@@ -135,6 +135,7 @@ def render_event(
     verbose: bool = False,
     stream: bool = False,
     pending: dict | None = None,
+    dashboard=None,
 ) -> None:
     """Render one runtime event onto the terminal.
 
@@ -142,6 +143,9 @@ def render_event(
     elapsed seconds. ``stream`` suppresses the full-text echo of the final
     answer when its tokens were already streamed.
     """
+    if dashboard is not None:
+        dashboard.update(ev, verbose=verbose)
+        return
     t = ev.get("type")
     pending = pending if pending is not None else {}
     if t == "assistant_delta":
@@ -210,14 +214,29 @@ async def execute(
                 ui.error(f"MCP {name}: {res}")
     ev: dict = {}
     pending: dict[str, float] = {}
+    todo_path = cfg.store_dir / f"todos-{cfg.user_id}.json"
+    dashboard = ui.dashboard(
+        cfg.model or "(scripted)",
+        str(cfg.workspace_dir.resolve()),
+        rid,
+        task,
+        cfg.max_steps,
+        JsonTodoStore(todo_path).list(),
+    )
     try:
+        if dashboard is not None:
+            dashboard.start()
         async for ev in host.run(ctx, task, history=history):
-            render_event(ev, cfg.verbose, cfg.stream, pending)
+            render_event(ev, cfg.verbose, cfg.stream, pending, dashboard)
         if ev.get("type") == "done":
-            if cfg.stream and pending.get("_deltas"):
-                print()  # close the streaming line before the footer
+            if dashboard is not None:
+                dashboard.finish(ev)
+            elif cfg.stream and pending.get("_deltas"):
+                print()
             ui.footer(ev)
     finally:
+        if dashboard is not None:
+            dashboard.close()
         if manager is not None:
             await manager.close()
     return rid, ev, host

lithe_cli-0.5.0/lithe_cli/ui.py

@@ -0,0 +1,486 @@
+"""Zero-dependency terminal rendering for the lithe CLI.
+
+Color policy: on only when stdout is a TTY, ``NO_COLOR`` is unset
+(https://no-color.org) and ``TERM`` is not ``dumb``; ``--color`` /
+``--no-color`` override everything. Every helper degrades to plain text
+when color is off, so piped output and test capture stay clean.
+
+Widths are computed with East-Asian widths in mind (task text is often
+Chinese), so tables stay aligned where a bare ``len()`` would not.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import sys
+import time
+import unicodedata
+
+RESET = "\x1b[0m"
+BOLD = "\x1b[1m"
+DIM = "\x1b[2m"
+RED = "\x1b[31m"
+GREEN = "\x1b[32m"
+YELLOW = "\x1b[33m"
+BLUE = "\x1b[34m"
+MAGENTA = "\x1b[35m"
+CYAN = "\x1b[36m"
+
+# Terminal states worth coloring differently (everything else stays plain).
+_OK_STATES = frozenset({"done"})
+_BAD_STATES = frozenset({"failed", "error", "budget_exceeded", "max_steps"})
+_WARN_STATES = frozenset({"cancelled", "running"})
+
+_ROLE_STYLES = {
+    "user": BLUE,
+    "assistant": GREEN,
+    "tool": CYAN,
+    "system": MAGENTA,
+}
+
+
+def default_color() -> bool:
+    """Auto-detect: a TTY, no NO_COLOR, and TERM not "dumb"."""
+    if os.environ.get("NO_COLOR"):
+        return False
+    if os.environ.get("TERM", "") == "dumb":
+        return False
+    return bool(sys.stdout.isatty())
+
+
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def display_width(text: str) -> int:
+    """Column width of *text* counting East-Asian glyphs as double; ANSI
+    escape sequences are transparent."""
+    clean = _ANSI_RE.sub("", text)
+    return sum(2 if unicodedata.east_asian_width(ch) in "WF" else 1 for ch in clean)
+
+
+def pad(text: str, width: int) -> str:
+    """Left-aligned *text* padded to *width* display columns."""
+    return text + " " * max(0, width - display_width(text))
+
+
+def truncate(text: str, width: int) -> str:
+    """Cut *text* to *width* display columns, appending an ellipsis."""
+    if display_width(text) <= width:
+        return text
+    out = ""
+    used = 0
+    for ch in text:
+        w = 2 if unicodedata.east_asian_width(ch) in "WF" else 1
+        if used + w > width - 1:
+            break
+        out += ch
+        used += w
+    return out + "…"
+
+
+class UI:
+    """All terminal output goes through here; ``color`` gates every code."""
+
+    def __init__(self, color: bool = False, width: int | None = None):
+        self.color = bool(color)
+        self._width = width
+
+    @property
+    def width(self) -> int:
+        return max(12, self._width or shutil.get_terminal_size((100, 24)).columns)
+
+    def s(self, text: str, *styles: str) -> str:
+        """Wrap *text* in *styles* when color is on and text is non-empty."""
+        if not self.color or not text or not styles:
+            return text
+        return "".join(styles) + text + RESET
+
+    # -- structural ---------------------------------------------------------
+
+    def rule(self, char: str = "─", width: int = 60) -> str:
+        return self.s(char * min(width, self.width), DIM)
+
+    def kv(self, label: str, value: str) -> str:
+        return f"{self.s(pad(label, 11), CYAN, BOLD)} {value}"
+
+    def section(self, title: str) -> str:
+        width = min(50, self.width)
+        label = f"── {title} "
+        if display_width(label) > width:
+            return self.s(truncate(label, width), DIM)
+        return self.s(label + "─" * (width - display_width(label)), DIM)
+
+    def table(
+        self, headers: list[str], rows: list[list[str]], cell_styles: list | None = None
+    ) -> str:
+        """Aligned, terminal-width-aware table with display-width styling."""
+        widths = [display_width(h) for h in headers]
+        for row in rows:
+            for i, cell in enumerate(row[:len(headers)]):
+                widths[i] = max(widths[i], display_width(cell))
+        spacing = "  " if self.width >= 3 * len(headers) else " "
+        available = max(1, self.width - display_width(spacing) * (len(headers) - 1))
+        overflow = max(0, sum(widths) - available)
+        for i in range(len(widths) - 1, -1, -1):
+            floor = min(widths[i], max(1, display_width(headers[i])))
+            reduction = min(overflow, widths[i] - floor)
+            widths[i] -= reduction
+            overflow -= reduction
+        for i in range(len(widths) - 1, -1, -1):
+            reduction = min(overflow, widths[i] - 1)
+            widths[i] -= reduction
+            overflow -= reduction
+        shown_headers = [truncate(h, widths[i]) for i, h in enumerate(headers)]
+        head = self.s(
+            spacing.join(pad(shown_headers[i], widths[i]) for i in range(len(headers))),
+            BOLD,
+            DIM,
+        )
+        sep = self.s(spacing.join("─" * w for w in widths), DIM)
+        lines = [head, sep]
+        for row in rows:
+            cells = []
+            for i, cell in enumerate(row[:len(headers)]):
+                shown = truncate(cell, widths[i])
+                styled = cell_styles[i](shown) if cell_styles and cell_styles[i] else shown
+                cells.append(pad(styled, widths[i]))
+            lines.append(spacing.join(cells))
+        return "\n".join(lines)
+
+    def status(self, text: str) -> str:
+        if text in _OK_STATES:
+            return self.s(text, GREEN)
+        if text in _BAD_STATES:
+            return self.s(text, RED)
+        if text in _WARN_STATES:
+            return self.s(text, YELLOW)
+        return text
+
+    def role(self, text: str) -> str:
+        return self.s(text, _ROLE_STYLES.get(text, DIM))
+
+    # -- events -------------------------------------------------------------
+
+    def delta(self, text: str) -> None:
+        print(text, end="", flush=True)
+
+    def assistant(self, text: str) -> None:
+        print(self.s(text, GREEN))
+
+    def tool_call(self, name: str, args: str) -> None:
+        prefix = f"  ⚒ {name} "
+        detail = truncate(args, max(8, self.width - display_width(prefix)))
+        print(f"  {self.s('⚒', CYAN)} {self.s(name, CYAN, BOLD)} {self.s(detail, DIM)}")
+
+    def tool_result(self, ok: bool, summary: str, elapsed: float | None) -> None:
+        mark = self.s("✓", GREEN) if ok else self.s("✗", RED)
+        tail = self.s(f" {elapsed:.1f}s", DIM) if elapsed is not None else ""
+        label = truncate(summary, max(8, self.width - 8 - display_width(tail)))
+        print(f"  {mark} {self.s(label, GREEN if ok else RED)}{tail}")
+
+    def error(self, msg: str) -> None:
+        print(f"  {self.s('!', RED)} {self.s(msg, RED)}")
+
+    def warn(self, msg: str) -> None:
+        print(f"  {self.s('~', YELLOW)} {self.s(msg, YELLOW)}")
+
+    def usage(self, prompt_tk, completion_tk, ctx_tk, ctx_pct) -> str:
+        return self.s(
+            f"  · tokens p{prompt_tk}/c{completion_tk} "
+            f"ctx={ctx_tk or '?'}tk ({ctx_pct}%)",
+            DIM,
+        )
+
+    def reasoning(self, digest: str) -> str:
+        return self.s(f"  ~ {digest}", DIM)
+
+    def footer(self, ev: dict) -> None:
+        """The one-line wrap-up after a run: status · steps · tokens · cost."""
+        parts = [self.status(str(ev.get("status", "?")))]
+        if ev.get("steps") is not None:
+            parts.append(f"steps {ev['steps']}")
+        tokens = ev.get("tokens")
+        if isinstance(tokens, dict):
+            tokens = tokens.get("total_tokens")
+        if tokens:
+            parts.append(f"tokens {tokens}")
+        cost = ev.get("cost")
+        if cost:
+            parts.append(f"cost {cost:.4f}")
+        print(f"{self.s('──', DIM)} {' · '.join(parts)}")
+
+    # -- chat ---------------------------------------------------------------
+
+    def banner(self, version: str, model: str, workspace: str) -> str:
+        rows = [
+            f"lithe {version} · command agent",
+            f"◆ model      {model}",
+            f"⌂ workspace  {workspace}",
+            "/help 查看会话命令 · /exit 退出",
+        ]
+        inner = max(8, self.width - 4)
+        rows = [truncate(row, inner - 2) for row in rows]
+        width = max(display_width(row) for row in rows) + 2
+        top = "╭" + "─" * width + "╮"
+        bot = "╰" + "─" * width + "╯"
+        body = "\n".join("│" + pad(" " + row, width) + "│" for row in rows)
+        art = "\n".join((top, body, bot))
+        return self.s(art, CYAN)
+
+    def dashboard(
+        self,
+        model: str,
+        workspace: str,
+        run_id: str,
+        task: str,
+        max_steps: int,
+        todos: list[dict] | None = None,
+    ) -> RunDashboard | None:
+        if not sys.stdout.isatty() or os.environ.get("TERM") == "dumb":
+            return None
+        return RunDashboard(self, model, workspace, run_id, task, max_steps, todos)
+
+    def prompt(self) -> str:
+        return self.s("lithe ❯ ", CYAN, BOLD)
+
+
+class RunDashboard:
+    def __init__(
+        self,
+        renderer: UI,
+        model: str,
+        workspace: str,
+        run_id: str,
+        task: str,
+        max_steps: int,
+        todos: list[dict] | None = None,
+    ):
+        self.ui = renderer
+        self.model = model
+        self.workspace = workspace
+        self.run_id = run_id
+        self.task = task
+        self.max_steps = max_steps
+        self.todos = list(todos or [])
+        self.status = "starting"
+        self.step = 0
+        self.tokens = 0
+        self.context_tokens = None
+        self.context_percent = None
+        self.cost = 0.0
+        self.started = time.monotonic()
+        self.elapsed = 0.0
+        self.feed: list[str] = []
+        self.tools: list[dict] = []
+        self.response = ""
+        self.reasoning = ""
+        self._delta_pending = False
+        self._active = False
+
+    def _wrap(self, text: str, width: int) -> list[str]:
+        if width < 1:
+            return []
+        lines: list[str] = []
+        current = ""
+        used = 0
+        for char in str(text):
+            if char == "\n":
+                lines.append(current)
+                current = ""
+                used = 0
+                continue
+            char_width = 2 if unicodedata.east_asian_width(char) in "WF" else 1
+            if used + char_width > width and current:
+                lines.append(current)
+                current = ""
+                used = 0
+            if char_width <= width:
+                current += char
+                used += char_width
+        if current or not lines:
+            lines.append(current)
+        return lines
+
+    def _panel(self, title: str, lines: list[str], width: int, height: int) -> list[str]:
+        width = max(12, width)
+        height = max(4, height)
+        inner = width - 2
+        label = truncate(f"─ {title} ", inner)
+        top = "┌" + label + "─" * max(0, inner - display_width(label)) + "┐"
+        bottom = "└" + "─" * inner + "┘"
+        content_width = max(1, inner - 2)
+        body = []
+        for line in lines:
+            body.extend(self._wrap(line, content_width))
+        visible = body[-(height - 2):]
+        visible = ["│ " + pad(truncate(line, content_width), content_width) + " │" for line in visible]
+        visible.extend("│ " + " " * content_width + " │" for _ in range(height - 2 - len(visible)))
+        return [top, *visible, bottom]
+
+    def _left_lines(self) -> list[str]:
+        lines = ["任务", *self._wrap(self.task, 120), "", "运行记录"]
+        lines.extend(self.feed[-12:] or ["等待 Agent 开始处理"])
+        if self.reasoning:
+            lines.extend(["", "思考摘要", self.reasoning])
+        lines.extend(["", "Agent 回复"])
+        lines.extend(self._wrap(self.response[-2400:], 120) if self.response else ["等待模型响应"])
+        return lines
+
+    def _right_lines(self) -> list[str]:
+        elapsed = self.elapsed or time.monotonic() - self.started
+        lines = [
+            f"状态  {self.status}",
+            f"模型  {self.model}",
+            f"步骤  {self.step}/{self.max_steps} · {elapsed:.1f}s",
+            f"Run   {self.run_id}",
+            f"目录  {self.workspace}",
+            "",
+            f"工具调用  {len(self.tools)}",
+        ]
+        if not self.tools:
+            lines.append("暂无调用")
+        for tool in self.tools[-3:]:
+            mark = {"running": "…", "done": "✓", "failed": "✗"}.get(tool["status"], "·")
+            suffix = f" {tool['elapsed']:.1f}s" if tool.get("elapsed") is not None else ""
+            lines.append(f"{mark} {tool['name']}{suffix}")
+            if tool["status"] == "running" and tool.get("args"):
+                lines.append(f"  {truncate(tool['args'], 36)}")
+        done_count = sum(todo.get("status") == "completed" for todo in self.todos)
+        lines.extend(["", f"待办  {done_count}/{len(self.todos)} 完成"])
+        if not self.todos:
+            lines.append("暂无任务清单")
+        markers = {"pending": "[ ]", "in_progress": "[~]", "completed": "[x]", "cancelled": "[-]"}
+        for todo in self.todos[-4:]:
+            marker = markers.get(todo.get("status"), "[ ]")
+            lines.append(f"{marker} {todo.get('content', '')}")
+        lines.extend([
+            "",
+            f"Token  {self.tokens or '—'} · ${self.cost:.6f}",
+            f"上下文  {self.context_tokens or '—'} · {self.context_percent if self.context_percent is not None else '—'}%",
+        ])
+        return lines
+
+    def render(self, width: int | None = None, height: int | None = None) -> str:
+        width = max(12, width or self.ui.width)
+        term_height = shutil.get_terminal_size((100, 24)).lines
+        height = max(6, height or term_height)
+        status = f" {self.status.upper()} · step {self.step}/{self.max_steps} "
+        title = " LITHE  /  AGENT SESSION "
+        header = title + status
+        header = truncate(header, width)
+        if width >= 76:
+            left_width = int((width - 1) * 0.66)
+            right_width = width - left_width - 1
+            panel_height = max(4, height - 3)
+            left = self._panel("任务与执行", self._left_lines(), left_width, panel_height)
+            right = self._panel("运行侧栏", self._right_lines(), right_width, panel_height)
+            rows = [a + " " + b for a, b in zip(left, right, strict=True)]
+        else:
+            available = max(4, height - 3)
+            left_height = max(4, int(available * 0.62))
+            right_height = max(4, available - left_height)
+            rows = self._panel("任务与执行", self._left_lines(), width, left_height)
+            rows.extend(self._panel("运行侧栏", self._right_lines(), width, right_height))
+        footer = truncate(" Ctrl+C 中断运行  ·  会话结束后显示最终回复 ", width)
+        return "\n".join([self.ui.s(header, CYAN, BOLD), *rows, self.ui.s(footer, DIM)])
+
+    def update(self, event: dict, verbose: bool = False) -> None:
+        kind = event.get("type")
+        if kind == "run_start":
+            self.status = "running"
+            self.model = str(event.get("model") or self.model)
+            self.max_steps = int(event.get("max_steps") or self.max_steps)
+        elif kind == "step":
+            self.step = int(event.get("step") or self.step)
+            self.status = "thinking"
+        elif kind == "assistant_delta":
+            text = str(event.get("text") or "")
+            self.response += text
+            self._delta_pending = True
+            self.status = "writing"
+        elif kind == "assistant":
+            text = str(event.get("text") or "")
+            if text and not self._delta_pending:
+                self.response += ("\n" if self.response else "") + text
+            self._delta_pending = False
+            self.status = "running"
+        elif kind == "tool_call":
+            name = str(event.get("name") or "tool")
+            args = event.get("args") or {}
+            tool = {
+                "id": event.get("id"),
+                "name": name,
+                "args": json.dumps(args, ensure_ascii=False),
+                "started": time.monotonic(),
+                "elapsed": None,
+                "status": "running",
+            }
+            self.tools.append(tool)
+            self.feed.append(f"调用工具  {name}")
+            self.status = f"tool: {name}"
+        elif kind == "tool_result":
+            tool_id = event.get("id")
+            tool = next((item for item in reversed(self.tools) if item.get("id") == tool_id and item["status"] == "running"), None)
+            if tool is not None:
+                tool["elapsed"] = time.monotonic() - tool["started"]
+                tool["status"] = "done" if event.get("ok") else "failed"
+            summary = str(event.get("summary") or "").replace("\n", " ")
+            mark = "完成" if event.get("ok") else "失败"
+            self.feed.append(f"{mark}  {summary or (tool or {}).get('name', '工具')}")
+            self.status = "thinking"
+        elif kind == "todo_change":
+            self.todos = list(event.get("new") or [])
+            self.feed.append(f"待办清单已更新  {len(self.todos)} 项")
+        elif kind == "usage":
+            self.tokens += int(event.get("total_tokens") or 0)
+            self.context_tokens = event.get("context_tokens", self.context_tokens)
+            self.context_percent = event.get("context_percent", self.context_percent)
+            self.cost += float(event.get("cost") or 0)
+        elif verbose and kind == "reasoning":
+            self.reasoning = str(event.get("text") or event.get("summary") or "").replace("\n", " ")[:240]
+        elif kind == "error":
+            self.status = "failed"
+            self.feed.append(f"错误  {event.get('message', '')}")
+        elif kind == "cancelled":
+            self.status = "cancelled"
+        elif kind == "done":
+            self.status = str(event.get("status") or "done")
+            self.step = int(event.get("steps") or self.step)
+            self.tokens = int(event.get("tokens") or self.tokens)
+            self.cost = float(event.get("cost") or self.cost)
+            self.elapsed = time.monotonic() - self.started
+        if self._active:
+            sys.stdout.write("\x1b[H\x1b[2J" + self.render())
+            sys.stdout.flush()
+
+    def start(self) -> None:
+        self._active = True
+        sys.stdout.write("\x1b[?1049h\x1b[?25l\x1b[2J\x1b[H")
+        sys.stdout.write(self.render())
+        sys.stdout.flush()
+
+    def finish(self, event: dict) -> None:
+        if event.get("type") != "done":
+            self.update(event)
+        self.close()
+        if self.response.strip():
+            self.ui.assistant(self.response.strip())
+
+    def close(self) -> None:
+        if self._active:
+            sys.stdout.write("\x1b[?25h\x1b[?1049l")
+            sys.stdout.flush()
+            self._active = False
+
+
+# Module-level singleton; main() reconfigures it from flags/env.
+ui = UI(default_color())
+
+
+def configure(color: bool | None = None) -> UI:
+    """(Re)configure the singleton; ``None`` means auto-detect."""
+    ui.color = default_color() if color is None else bool(color)
+    return ui

{lithe_cli-0.4.0 → lithe_cli-0.5.0}/lithe_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lithe-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: Command-line interface for the lithe agent kernel: chat, one-shot runs, undo, and run inspection.
 License: MIT License
         
@@ -39,7 +39,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: lithe>=0.9.7
+Requires-Dist: lithe>=0.9.8
 Requires-Dist: prompt-toolkit>=3.0.38
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"

{lithe_cli-0.4.0 → lithe_cli-0.5.0}/lithe_cli.egg-info/requires.txt

@@ -1,4 +1,4 @@
-lithe>=0.9.7
+lithe>=0.9.8
 prompt-toolkit>=3.0.38
 
 [dev]

{lithe_cli-0.4.0 → lithe_cli-0.5.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.7", "prompt-toolkit>=3.0.38"]
+dependencies = ["lithe>=0.9.8", "prompt-toolkit>=3.0.38"]
 keywords = ["agent", "llm", "react", "cli", "tool-calling"]
 classifiers = [
     "Development Status :: 4 - Beta",

{lithe_cli-0.4.0 → lithe_cli-0.5.0}/tests/test_cli.py

@@ -244,6 +244,42 @@ def test_ui_banner_fits_terminal_width():
     assert "…" in out
 
 
+def test_run_dashboard_shows_tools_todos_and_usage():
+    from lithe_cli.ui import RunDashboard, UI, display_width
+
+    dashboard = RunDashboard(
+        UI(color=False), "model-x", "/workspace", "run-123", "检查项目代码", 12
+    )
+    dashboard.update({"type": "run_start", "model": "model-x", "max_steps": 12})
+    dashboard.update({"type": "step", "step": 2})
+    dashboard.update({"type": "tool_call", "id": "c1", "name": "read_file", "args": {"path": "main.py"}})
+    dashboard.update({"type": "tool_result", "id": "c1", "ok": True, "summary": "已读取文件"})
+    dashboard.update({
+        "type": "todo_change",
+        "new": [{"content": "检查测试", "status": "in_progress"}],
+    })
+    dashboard.update({"type": "usage", "total_tokens": 120, "context_tokens": 100, "context_percent": 10.0, "cost": 0.001})
+    dashboard.update({"type": "assistant", "text": "检查完成"})
+
+    out = dashboard.render(width=100, height=32)
+    assert "LITHE" in out
+    assert "read_file" in out
+    assert "检查测试" in out
+    assert "120" in out
+    assert "检查完成" in out
+    assert all(display_width(line) <= 100 for line in out.splitlines())
+
+
+def test_run_dashboard_fits_narrow_terminal():
+    from lithe_cli.ui import RunDashboard, UI, display_width
+
+    dashboard = RunDashboard(UI(color=False), "模型", "/工作区", "r1", "处理中文任务", 5)
+    out = dashboard.render(width=56, height=24)
+    assert all(display_width(line) <= 56 for line in out.splitlines())
+    assert "任务与执行" in out
+    assert "运行侧栏" in out
+
+
 def test_no_command_prints_help(capsys):
     from lithe_cli.main import main
 

lithe_cli-0.4.0/lithe_cli/ui.py

@@ -1,242 +0,0 @@
-"""Zero-dependency terminal rendering for the lithe CLI.
-
-Color policy: on only when stdout is a TTY, ``NO_COLOR`` is unset
-(https://no-color.org) and ``TERM`` is not ``dumb``; ``--color`` /
-``--no-color`` override everything. Every helper degrades to plain text
-when color is off, so piped output and test capture stay clean.
-
-Widths are computed with East-Asian widths in mind (task text is often
-Chinese), so tables stay aligned where a bare ``len()`` would not.
-"""
-
-from __future__ import annotations
-
-import os
-import re
-import shutil
-import sys
-import unicodedata
-
-RESET = "\x1b[0m"
-BOLD = "\x1b[1m"
-DIM = "\x1b[2m"
-RED = "\x1b[31m"
-GREEN = "\x1b[32m"
-YELLOW = "\x1b[33m"
-BLUE = "\x1b[34m"
-MAGENTA = "\x1b[35m"
-CYAN = "\x1b[36m"
-
-# Terminal states worth coloring differently (everything else stays plain).
-_OK_STATES = frozenset({"done"})
-_BAD_STATES = frozenset({"failed", "error", "budget_exceeded", "max_steps"})
-_WARN_STATES = frozenset({"cancelled", "running"})
-
-_ROLE_STYLES = {
-    "user": BLUE,
-    "assistant": GREEN,
-    "tool": CYAN,
-    "system": MAGENTA,
-}
-
-
-def default_color() -> bool:
-    """Auto-detect: a TTY, no NO_COLOR, and TERM not "dumb"."""
-    if os.environ.get("NO_COLOR"):
-        return False
-    if os.environ.get("TERM", "") == "dumb":
-        return False
-    return bool(sys.stdout.isatty())
-
-
-_ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
-
-
-def display_width(text: str) -> int:
-    """Column width of *text* counting East-Asian glyphs as double; ANSI
-    escape sequences are transparent."""
-    clean = _ANSI_RE.sub("", text)
-    return sum(2 if unicodedata.east_asian_width(ch) in "WF" else 1 for ch in clean)
-
-
-def pad(text: str, width: int) -> str:
-    """Left-aligned *text* padded to *width* display columns."""
-    return text + " " * max(0, width - display_width(text))
-
-
-def truncate(text: str, width: int) -> str:
-    """Cut *text* to *width* display columns, appending an ellipsis."""
-    if display_width(text) <= width:
-        return text
-    out = ""
-    used = 0
-    for ch in text:
-        w = 2 if unicodedata.east_asian_width(ch) in "WF" else 1
-        if used + w > width - 1:
-            break
-        out += ch
-        used += w
-    return out + "…"
-
-
-class UI:
-    """All terminal output goes through here; ``color`` gates every code."""
-
-    def __init__(self, color: bool = False, width: int | None = None):
-        self.color = bool(color)
-        self._width = width
-
-    @property
-    def width(self) -> int:
-        return max(12, self._width or shutil.get_terminal_size((100, 24)).columns)
-
-    def s(self, text: str, *styles: str) -> str:
-        """Wrap *text* in *styles* when color is on and text is non-empty."""
-        if not self.color or not text or not styles:
-            return text
-        return "".join(styles) + text + RESET
-
-    # -- structural ---------------------------------------------------------
-
-    def rule(self, char: str = "─", width: int = 60) -> str:
-        return self.s(char * min(width, self.width), DIM)
-
-    def kv(self, label: str, value: str) -> str:
-        return f"{self.s(pad(label, 11), CYAN, BOLD)} {value}"
-
-    def section(self, title: str) -> str:
-        width = min(50, self.width)
-        label = f"── {title} "
-        if display_width(label) > width:
-            return self.s(truncate(label, width), DIM)
-        return self.s(label + "─" * (width - display_width(label)), DIM)
-
-    def table(
-        self, headers: list[str], rows: list[list[str]], cell_styles: list | None = None
-    ) -> str:
-        """Aligned, terminal-width-aware table with display-width styling."""
-        widths = [display_width(h) for h in headers]
-        for row in rows:
-            for i, cell in enumerate(row[:len(headers)]):
-                widths[i] = max(widths[i], display_width(cell))
-        spacing = "  " if self.width >= 3 * len(headers) else " "
-        available = max(1, self.width - display_width(spacing) * (len(headers) - 1))
-        overflow = max(0, sum(widths) - available)
-        for i in range(len(widths) - 1, -1, -1):
-            floor = min(widths[i], max(1, display_width(headers[i])))
-            reduction = min(overflow, widths[i] - floor)
-            widths[i] -= reduction
-            overflow -= reduction
-        for i in range(len(widths) - 1, -1, -1):
-            reduction = min(overflow, widths[i] - 1)
-            widths[i] -= reduction
-            overflow -= reduction
-        shown_headers = [truncate(h, widths[i]) for i, h in enumerate(headers)]
-        head = self.s(
-            spacing.join(pad(shown_headers[i], widths[i]) for i in range(len(headers))),
-            BOLD,
-            DIM,
-        )
-        sep = self.s(spacing.join("─" * w for w in widths), DIM)
-        lines = [head, sep]
-        for row in rows:
-            cells = []
-            for i, cell in enumerate(row[:len(headers)]):
-                shown = truncate(cell, widths[i])
-                styled = cell_styles[i](shown) if cell_styles and cell_styles[i] else shown
-                cells.append(pad(styled, widths[i]))
-            lines.append(spacing.join(cells))
-        return "\n".join(lines)
-
-    def status(self, text: str) -> str:
-        if text in _OK_STATES:
-            return self.s(text, GREEN)
-        if text in _BAD_STATES:
-            return self.s(text, RED)
-        if text in _WARN_STATES:
-            return self.s(text, YELLOW)
-        return text
-
-    def role(self, text: str) -> str:
-        return self.s(text, _ROLE_STYLES.get(text, DIM))
-
-    # -- events -------------------------------------------------------------
-
-    def delta(self, text: str) -> None:
-        print(text, end="", flush=True)
-
-    def assistant(self, text: str) -> None:
-        print(self.s(text, GREEN))
-
-    def tool_call(self, name: str, args: str) -> None:
-        prefix = f"  ⚒ {name} "
-        detail = truncate(args, max(8, self.width - display_width(prefix)))
-        print(f"  {self.s('⚒', CYAN)} {self.s(name, CYAN, BOLD)} {self.s(detail, DIM)}")
-
-    def tool_result(self, ok: bool, summary: str, elapsed: float | None) -> None:
-        mark = self.s("✓", GREEN) if ok else self.s("✗", RED)
-        tail = self.s(f" {elapsed:.1f}s", DIM) if elapsed is not None else ""
-        label = truncate(summary, max(8, self.width - 8 - display_width(tail)))
-        print(f"  {mark} {self.s(label, GREEN if ok else RED)}{tail}")
-
-    def error(self, msg: str) -> None:
-        print(f"  {self.s('!', RED)} {self.s(msg, RED)}")
-
-    def warn(self, msg: str) -> None:
-        print(f"  {self.s('~', YELLOW)} {self.s(msg, YELLOW)}")
-
-    def usage(self, prompt_tk, completion_tk, ctx_tk, ctx_pct) -> str:
-        return self.s(
-            f"  · tokens p{prompt_tk}/c{completion_tk} "
-            f"ctx={ctx_tk or '?'}tk ({ctx_pct}%)",
-            DIM,
-        )
-
-    def reasoning(self, digest: str) -> str:
-        return self.s(f"  ~ {digest}", DIM)
-
-    def footer(self, ev: dict) -> None:
-        """The one-line wrap-up after a run: status · steps · tokens · cost."""
-        parts = [self.status(str(ev.get("status", "?")))]
-        if ev.get("steps") is not None:
-            parts.append(f"steps {ev['steps']}")
-        tokens = ev.get("tokens")
-        if isinstance(tokens, dict):
-            tokens = tokens.get("total_tokens")
-        if tokens:
-            parts.append(f"tokens {tokens}")
-        cost = ev.get("cost")
-        if cost:
-            parts.append(f"cost {cost:.4f}")
-        print(f"{self.s('──', DIM)} {' · '.join(parts)}")
-
-    # -- chat ---------------------------------------------------------------
-
-    def banner(self, version: str, model: str, workspace: str) -> str:
-        rows = [
-            f"lithe {version} · command agent",
-            f"◆ model      {model}",
-            f"⌂ workspace  {workspace}",
-            "/help 查看会话命令 · /exit 退出",
-        ]
-        inner = max(8, self.width - 4)
-        rows = [truncate(row, inner - 2) for row in rows]
-        width = max(display_width(row) for row in rows) + 2
-        top = "╭" + "─" * width + "╮"
-        bot = "╰" + "─" * width + "╯"
-        body = "\n".join("│" + pad(" " + row, width) + "│" for row in rows)
-        art = "\n".join((top, body, bot))
-        return self.s(art, CYAN)
-
-    def prompt(self) -> str:
-        return self.s("lithe ❯ ", CYAN, BOLD)
-
-
-# Module-level singleton; main() reconfigures it from flags/env.
-ui = UI(default_color())
-
-
-def configure(color: bool | None = None) -> UI:
-    """(Re)configure the singleton; ``None`` means auto-detect."""
-    ui.color = default_color() if color is None else bool(color)
-    return ui