dscli-agent 0.1.0__py3-none-any.whl

dscli/tui.py

@@ -0,0 +1,574 @@
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING, Callable
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.history import FileHistory, InMemoryHistory
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.styles import Style
+from rich.console import Console, Group
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.text import Text
+
+from . import __version__
+from .config import Config, config_dir
+from .protocol import ToolCall
+from .tools import ToolResult
+
+if TYPE_CHECKING:
+    from .agent import AgentOutcome
+
+
+SLASH_COMMANDS = {
+    "/help": "Show commands and shortcuts",
+    "/new": "Start a fresh conversation",
+    "/exit": "Exit dscli",
+    "/quit": "Exit dscli",
+}
+
+_SPINNER_FRAMES = "✢✳✶✻✽✻✶✳"
+_THINKING_VERBS = (
+    "Thinking",
+    "Pondering",
+    "Working",
+    "Reasoning",
+    "Checking",
+    "Composing",
+)
+_TOOL_NAMES = {
+    "read_file": ("Reading", "Read"),
+    "write_file": ("Writing", "Write"),
+    "apply_patch": ("Updating", "Update"),
+    "list_files": ("Listing", "List"),
+    "delete_file": ("Deleting", "Delete"),
+    "run_command": ("Running", "Run"),
+}
+
+
+class TuiQuit(KeyboardInterrupt):
+    """The user chose q at an approval prompt; exit instead of continuing."""
+
+
+class SlashCompleter(Completer):
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        if not text.startswith("/") or " " in text or "\n" in text:
+            return
+        for name, description in SLASH_COMMANDS.items():
+            if name.startswith(text):
+                yield Completion(
+                    name,
+                    start_position=-len(text),
+                    display=name,
+                    display_meta=description,
+                )
+
+
+def _shorten(text: str, limit: int = 100) -> str:
+    text = text.replace("\r", " ").replace("\n", " ").strip()
+    return text if len(text) <= limit else text[: limit - 3] + "..."
+
+
+def _tool_target(name: str, args: dict | None, limit: int = 110) -> str:
+    args = args or {}
+    if name == "run_command":
+        return _shorten(str(args.get("command", "")), limit)
+    path = args.get("path")
+    if path is None:
+        return ""
+    extra = ""
+    if args.get("start_line") or args.get("end_line"):
+        extra = f" lines {args.get('start_line', '')}-{args.get('end_line', '')}".rstrip("-")
+    return f"{path}{extra}"
+
+
+def _tool_title(name: str) -> str:
+    return _TOOL_NAMES.get(name, ("", name))[1]
+
+
+class Tui:
+    def __init__(
+        self,
+        *,
+        workspace: Path,
+        auto_approve: bool = False,
+        quiet: bool = False,
+        console: Console | None = None,
+        prompt_session: PromptSession | None = None,
+        approval_session: PromptSession | None = None,
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        self.workspace = workspace
+        self.quiet = quiet
+        self._auto = auto_approve
+        self._clock = clock
+        self.console = console or Console(
+            highlight=False,
+            no_color=os.environ.get("NO_COLOR") is not None,
+        )
+        self._live: Live | None = None
+        self._answer_live: Live | None = None
+        self._status_text = ""
+        self._last_status_text = ""
+        self._status_started = 0.0
+        self._answer_target = ""
+        self._answer_visible = ""
+        self._answer_started = 0.0
+        self._answer_tick = 0.0
+        self._prompt_session = prompt_session or self._build_prompt_session()
+        self._approval_session = approval_session or self._build_approval_session()
+
+    # ---------------------------------------------------------------- prompt
+    def _history(self):
+        try:
+            path = config_dir() / "chat_history"
+            path.parent.mkdir(parents=True, exist_ok=True)
+            return FileHistory(str(path))
+        except OSError:
+            return InMemoryHistory()
+
+    def _style(self) -> Style:
+        if os.environ.get("NO_COLOR") is not None:
+            return Style.from_dict({})
+        return Style.from_dict(
+            {
+                "prompt": "ansicyan bold",
+                "bottom-toolbar": "bg:#202020 #909090",
+                "completion-menu.completion": "bg:#1c1c1c #d0d0d0",
+                "completion-menu.completion.current": "bg:#444444 #ffffff",
+                "completion-menu.meta.completion": "bg:#1c1c1c #888888",
+            }
+        )
+
+    def _key_bindings(self) -> KeyBindings:
+        bindings = KeyBindings()
+
+        @bindings.add("enter")
+        def _(event) -> None:
+            buffer = event.current_buffer
+            if buffer.complete_state and buffer.text.strip() not in SLASH_COMMANDS:
+                completion = buffer.complete_state.current_completion
+                if completion is not None:
+                    buffer.apply_completion(completion)
+                    return
+            buffer.validate_and_handle()
+
+        @bindings.add("escape", "enter")
+        def _(event) -> None:
+            event.current_buffer.insert_text("\n")
+
+        @bindings.add("c-j")
+        def _(event) -> None:
+            event.current_buffer.insert_text("\n")
+
+        @bindings.add("c-d")
+        def _(event) -> None:
+            buffer = event.current_buffer
+            if buffer.text:
+                buffer.delete()
+            else:
+                event.app.exit(exception=EOFError, style="class:exiting")
+
+        return bindings
+
+    def _build_prompt_session(self) -> PromptSession:
+        return PromptSession(
+            history=self._history(),
+            completer=SlashCompleter(),
+            complete_while_typing=True,
+            multiline=True,
+            key_bindings=self._key_bindings(),
+            style=self._style(),
+            bottom_toolbar=(
+                " /help commands  ·  Enter send  ·  Esc+Enter newline  ·  Ctrl+D exit "
+            ),
+            prompt_continuation="... ",
+            enable_open_in_editor=False,
+        )
+
+    def _build_approval_session(self) -> PromptSession:
+        return PromptSession(
+            history=InMemoryHistory(),
+            style=self._style(),
+            enable_open_in_editor=False,
+        )
+
+    def prompt(self) -> str:
+        self._stop_live()
+        # Playwright's sync API leaves an asyncio loop running on this thread,
+        # so prompt_toolkit needs its own loop in a worker thread.
+        return self._prompt_session.prompt(
+            [("class:prompt", "❯ ")], in_thread=True
+        )
+
+    # -------------------------------------------------------------- lifecycle
+    def banner(self, cfg: Config) -> None:
+        self._stop_live()
+        modes = []
+        if cfg.deepthink:
+            modes.append("deepthink")
+        if cfg.search:
+            modes.append("search")
+        if cfg.allow_shell:
+            modes.append("shell allowed")
+        mode_text = " · ".join(modes) if modes else ""
+        self.console.print()
+        self.console.print(
+            Text.assemble(
+                ("  ✻ ", "bold cyan"),
+                ("Welcome to dscli", "bold"),
+                (f" {__version__}", "dim"),
+            )
+        )
+        intro = Text("    local coding agent", style="dim")
+        if mode_text:
+            intro.append(f"  ·  {mode_text}", style="dim")
+        self.console.print(intro)
+        self.console.print(
+            Text.assemble(("    workspace  ", "dim"), (str(self.workspace), "bold"))
+        )
+        self.console.print(
+            Text("    /help for commands  ·  Ctrl+D to exit", style="dim")
+        )
+        self.console.print()
+
+    def print_help(self) -> None:
+        self._stop_live()
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        for name, description in SLASH_COMMANDS.items():
+            table.add_row(Text(name, style="cyan"), Text(description))
+        self.console.print(table)
+        self.console.print(
+            Text(
+                "Enter sends  ·  Esc+Enter or Ctrl+J adds a line  ·  "
+                "Ctrl+C interrupts while working or clears the prompt  ·  Ctrl+D exits",
+                style="dim",
+            )
+        )
+
+    def system(self, message: str) -> None:
+        self._stop_live()
+        self.console.print(Text(message, style="dim"))
+
+    def close(self) -> None:
+        self._stop_live()
+
+    def interrupted(self) -> None:
+        partial = self._answer_target
+        self._stop_live()
+        if partial.strip():
+            try:
+                self.console.print(Markdown(partial))
+            except Exception:
+                self.console.print(Text(partial))
+        self.console.print(
+            Text(
+                "  Interrupted. Session kept; send another message or use /new.",
+                style="yellow",
+            )
+        )
+
+    def turn_failed(self, message: str, changed: list[str]) -> None:
+        self._stop_live()
+        self.console.print(Text(f"Error: {message}", style="bold red"))
+        if changed:
+            self.console.print(
+                Text("Files changed: " + ", ".join(changed), style="dim")
+            )
+
+    # ---------------------------------------------------------------- status
+    def start_status(self, text: str) -> None:
+        self._start_status(text)
+
+    def update_status(self, text: str) -> None:
+        self._start_status(text)
+
+    def stop_status(self) -> None:
+        self._stop_status()
+
+    def _start_status(self, text: str) -> None:
+        if self.quiet or not text:
+            return
+        self._status_text = text
+        self._last_status_text = text
+        if self._live is not None:
+            try:
+                self._live.refresh()
+            except Exception:
+                self._stop_status()
+            return
+        self._status_started = self._clock()
+        self._live = Live(
+            get_renderable=self._render_status,
+            console=self.console,
+            transient=True,
+            refresh_per_second=12,
+            vertical_overflow="ellipsis",
+            redirect_stdout=False,
+            redirect_stderr=False,
+        )
+        try:
+            self._live.start(refresh=True)
+        except Exception:
+            self._live = None
+
+    def _frame(self, elapsed: float) -> str:
+        return _SPINNER_FRAMES[int(elapsed * 8) % len(_SPINNER_FRAMES)]
+
+    def _status_line(self, label: str, elapsed: float, detail: str = "") -> Text:
+        line = Text()
+        line.append(self._frame(elapsed), style="cyan")
+        line.append(f" {label}", style="bold")
+        line.append(f"  {elapsed:.0f}s", style="dim")
+        if detail:
+            line.append(f"  ·  {detail}", style="dim")
+        line.append("  ·  Ctrl+C to interrupt", style="dim")
+        return line
+
+    def _render_status(self):
+        elapsed = max(0.0, self._clock() - self._status_started)
+        label = self._status_text
+        if label == "Thinking":
+            label = _THINKING_VERBS[int(elapsed // 3.0) % len(_THINKING_VERBS)]
+        return self._status_line(f"{label}…", elapsed)
+
+    def _stop_status(self) -> None:
+        live = self._live
+        self._live = None
+        if live is not None:
+            try:
+                live.stop()
+            except Exception:
+                pass
+
+    def _stop_answer(self) -> None:
+        live = self._answer_live
+        self._answer_live = None
+        if live is not None:
+            try:
+                live.stop()
+            except Exception:
+                pass
+        self._answer_target = ""
+        self._answer_visible = ""
+
+    def _stop_live(self) -> None:
+        self._stop_status()
+        self._stop_answer()
+
+    # --------------------------------------------------------- agent display
+    def turn_started(
+        self, turn: int, max_steps: int, attachment_count: int
+    ) -> None:
+        self._start_status("Thinking")
+
+    def stream_started(self) -> None:
+        self._stop_status()
+
+    def ensure_line_break(self) -> None:
+        pass
+
+    def protocol_error(self, detail: str) -> None:
+        self._stop_live()
+        if self.quiet:
+            return
+        self.console.print(Text("  ↻ retrying with a corrected reply", style="yellow"))
+
+    def thought(self, text: str) -> None:
+        self._stop_status()
+        if self.quiet:
+            return
+        if text:
+            self.console.print(Text(f"  thought: {text}", style="dim italic"))
+
+    def tool_started(self, call: ToolCall) -> None:
+        progressive = _TOOL_NAMES.get(call.name, (call.name, call.name))[0]
+        target = _tool_target(call.name, call.arguments)
+        self._start_status(f"{progressive} {target}".strip())
+
+    def tool_finished(self, result: ToolResult, elapsed_sec: float) -> None:
+        self._stop_status()
+        if self.quiet:
+            return
+        ok = result.ok
+        style = "green" if ok else "red"
+        line = Text()
+        line.append("  ⏺ ", style="dim")
+        line.append(_tool_title(result.name), style=f"bold {'cyan' if ok else 'red'}")
+        target = _tool_target(result.name, result.arguments)
+        if target:
+            line.append(f"({target})")
+        line.append("  ")
+        line.append("✓" if ok else "✗", style=f"bold {style}")
+        line.append(f" {elapsed_sec:.1f}s", style="dim")
+        self.console.print(line)
+        if not ok:
+            for raw in (result.output or "").strip().splitlines()[:3]:
+                self.console.print(Text("    " + _shorten(raw, 160), style="red"))
+
+    def wrapup_started(self) -> None:
+        self._start_status("Wrapping up")
+
+    def budget_exhausted(self) -> None:
+        self._start_status("Wrapping up")
+
+    def finished(
+        self, changed: list[str], turns: int, *, show_status: bool
+    ) -> None:
+        self._stop_status()
+
+    def complete(self, outcome: "AgentOutcome", elapsed_sec: float) -> None:
+        self._stop_live()
+        final = outcome.final or "Done."
+        try:
+            self.console.print(Markdown(final))
+        except Exception:
+            self.console.print(Text(final))
+        if self.quiet:
+            return
+        steps = f"{outcome.turns} step" + ("" if outcome.turns == 1 else "s")
+        parts = [f"{elapsed_sec:.1f}s", steps]
+        if outcome.changed:
+            files = len(outcome.changed)
+            parts.append(f"{files} file" + ("" if files == 1 else "s") + " changed")
+        if outcome.limit_reached:
+            parts.append("budget reached")
+        if outcome.denied:
+            parts.append("action denied")
+        self.console.print(Text("  ✻ Done in " + " · ".join(parts), style="dim"))
+        if outcome.changed:
+            shown = outcome.changed[:6]
+            more = (
+                f" (+{len(outcome.changed) - 6} more)"
+                if len(outcome.changed) > 6
+                else ""
+            )
+            self.console.print(
+                Text("  changed: " + ", ".join(shown) + more, style="dim")
+            )
+
+    def answer_snapshot(self, text: str) -> None:
+        if not text:
+            return
+        if self._answer_live is None:
+            self._start_answer(text)
+            return
+        self._answer_target = text
+
+    def _start_answer(self, text: str) -> None:
+        self._stop_status()
+        self._answer_target = text
+        self._answer_visible = ""
+        self._answer_started = self._clock()
+        self._answer_tick = self._answer_started
+        live = Live(
+            get_renderable=self._render_answer,
+            console=self.console,
+            transient=True,
+            refresh_per_second=15,
+            vertical_overflow="ellipsis",
+            redirect_stdout=False,
+            redirect_stderr=False,
+        )
+        try:
+            live.start(refresh=True)
+        except Exception:
+            return
+        self._answer_live = live
+
+    def _render_answer(self):
+        now = self._clock()
+        target = self._answer_target
+        if not target.startswith(self._answer_visible):
+            self._answer_visible = ""
+        dt = max(0.0, now - self._answer_tick)
+        self._answer_tick = now
+        gap = len(target) - len(self._answer_visible)
+        if gap > 0:
+            # Reveal a little faster when a large chunk arrived at once so the
+            # text flows instead of jumping a paragraph at a time.
+            speed = 180 + min(gap, 1200) * 0.8
+            step = max(1, int(speed * max(dt, 0.05)))
+            self._answer_visible = target[: len(self._answer_visible) + step]
+        elapsed = max(0.0, now - self._answer_started)
+        header = self._status_line(
+            "Responding…", elapsed, f"{len(self._answer_visible)} chars"
+        )
+        shown = self._answer_visible
+        lines = shown.splitlines()
+        # Keep the newest lines in view while the answer grows past the screen.
+        if len(lines) > 24:
+            shown = "…\n" + "\n".join(lines[-24:])
+        try:
+            body = Markdown(shown) if shown else Text("")
+        except Exception:
+            body = Text(shown)
+        return Group(header, body)
+
+    # -------------------------------------------------------------- approval
+    def confirm(self, title: str, detail: str | None) -> bool:
+        self._stop_live()
+        self.console.print()
+        self.console.print(Text(title, style="bold yellow"))
+        if detail:
+            self._print_detail(detail)
+        approved = self._auto
+        if approved:
+            self.console.print(
+                Text("  auto-approved (-y or all)", style="dim green")
+            )
+        else:
+            try:
+                # Same running-loop constraint as prompt(); approvals happen
+                # while Playwright's loop is still active.
+                answer = (
+                    self._approval_session.prompt(
+                        "Approve? [y]es / [n]o / [a]ll / [q]uit ❯ ",
+                        in_thread=True,
+                    )
+                    or ""
+                ).strip().lower()
+            except EOFError:
+                answer = "n"
+            if answer in {"q", "quit"}:
+                raise TuiQuit
+            if answer in {"a", "all"}:
+                self._auto = True
+                approved = True
+            elif answer in {"y", "yes"}:
+                approved = True
+        self._resume_status()
+        return approved
+
+    def _resume_status(self) -> None:
+        if not self.quiet and self._last_status_text:
+            self._start_status(self._last_status_text)
+
+    def _print_detail(self, detail: str) -> None:
+        lines = detail.rstrip("\n").splitlines()
+        looks_like_diff = detail.lstrip().startswith("---") or "\n+++" in detail[:200]
+        for line in lines[:160]:
+            if looks_like_diff:
+                if line.startswith(("+++", "---")):
+                    style = "bold"
+                elif line.startswith("+"):
+                    style = "green"
+                elif line.startswith("-"):
+                    style = "red"
+                elif line.startswith("@@"):
+                    style = "cyan"
+                else:
+                    style = ""
+            else:
+                style = "yellow"
+            self.console.print(Text("  " + line, style=style))
+        if len(lines) > 160:
+            self.console.print(
+                Text(f"  ... [{len(lines) - 160} diff lines omitted] ...", style="dim")
+            )

dscli/ui.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import os
+import sys
+
+_COLOR = (
+    os.environ.get("NO_COLOR") is None
+    and sys.stderr.isatty()
+    and os.environ.get("TERM") != "dumb"
+)
+
+if os.name == "nt" and _COLOR:
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+        kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+    except Exception:
+        _COLOR = False
+
+
+def style(text: str, color: str) -> str:
+    if not _COLOR:
+        return text
+    codes = {
+        "dim": "2",
+        "red": "31",
+        "green": "32",
+        "yellow": "33",
+        "blue": "34",
+        "magenta": "35",
+        "cyan": "36",
+        "bold": "1",
+    }
+    return f"\033[{codes.get(color, '0')}m{text}\033[0m"
+
+
+def step(text: str) -> None:
+    print(style(text, "cyan"), file=sys.stderr, flush=True)
+
+
+def ok(text: str) -> None:
+    print(style("  ok  ", "green") + " " + text, file=sys.stderr, flush=True)
+
+
+def fail(text: str) -> None:
+    print(style(" fail ", "red") + " " + text, file=sys.stderr, flush=True)
+
+
+def info(text: str) -> None:
+    print(text, file=sys.stderr, flush=True)
+
+
+def warn(text: str) -> None:
+    print(style("warn", "yellow") + " " + text, file=sys.stderr, flush=True)
+
+
+def print_diff(diff_text: str, max_lines: int = 160) -> None:
+    lines = diff_text.splitlines()
+    for line in lines[:max_lines]:
+        if line.startswith("+++") or line.startswith("---"):
+            print(style(line, "bold"), file=sys.stderr)
+        elif line.startswith("+"):
+            print(style(line, "green"), file=sys.stderr)
+        elif line.startswith("-"):
+            print(style(line, "red"), file=sys.stderr)
+        elif line.startswith("@@"):
+            print(style(line, "cyan"), file=sys.stderr)
+        else:
+            print(line, file=sys.stderr)
+    if len(lines) > max_lines:
+        print(style(f"... diff truncated ({len(lines) - max_lines} more lines)", "dim"), file=sys.stderr)