turnloop 0.1.0__py3-none-any.whl

turnloop/tui/widgets/permission.py

@@ -0,0 +1,131 @@
+"""The approval modal.
+
+Answerable with one key. The options are deliberately asymmetric: approving once
+is `y`, approving a *narrow* rule for the session is `a`, and there is no
+"always allow everything" — a blanket grant made in a hurry is how a permission
+system stops meaning anything.
+"""
+
+from __future__ import annotations
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Static
+
+from turnloop.permissions.engine import PermissionDecision, PermissionRequest, Scope
+
+
+class PermissionModal(ModalScreen[PermissionDecision]):
+    BINDINGS = [
+        ("y", "approve_once", "Allow once"),
+        ("enter", "approve_once", "Allow once"),
+        ("a", "approve_session", "Allow for session"),
+        ("s", "approve_project", "Save to settings"),
+        ("n", "reject", "Decline"),
+        ("escape", "reject", "Decline"),
+    ]
+
+    def __init__(self, request: PermissionRequest):
+        super().__init__()
+        self.request = request
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="permission-box"):
+            yield Static(self._body(), id="permission-body")
+            yield Static(self._keys(), id="permission-keys")
+
+    def _body(self) -> Text:
+        req = self.request
+        text = Text()
+        text.append("Permission required\n\n", style="bold yellow")
+        text.append(f"{req.tool_name}  ", style="bold")
+        text.append(f"{req.summary}\n\n", style="cyan")
+        if req.reason:
+            text.append(f"{req.reason}\n\n", style="dim")
+        preview = req.args_preview.strip()
+        if preview and preview != req.summary:
+            text.append(preview[:800] + "\n", style="dim")
+        return text
+
+    def _keys(self) -> Text:
+        text = Text()
+        text.append("\n[y] ", style="bold green")
+        text.append("allow once   ")
+        if self.request.suggested_rule:
+            text.append("[a] ", style="bold green")
+            text.append(f"allow {self.request.suggested_rule} this session   ")
+            text.append("[s] ", style="bold")
+            text.append("save that rule   ")
+        text.append("[n] ", style="bold red")
+        text.append("decline")
+        return text
+
+    # --- actions ----------------------------------------------------------
+
+    def action_approve_once(self) -> None:
+        self.dismiss(PermissionDecision(approved=True, scope=Scope.ONCE))
+
+    def action_approve_session(self) -> None:
+        self.dismiss(
+            PermissionDecision(
+                approved=True, scope=Scope.SESSION, rule=self.request.suggested_rule
+            )
+        )
+
+    def action_approve_project(self) -> None:
+        self.dismiss(
+            PermissionDecision(
+                approved=True, scope=Scope.PROJECT, rule=self.request.suggested_rule
+            )
+        )
+
+    def action_reject(self) -> None:
+        self.dismiss(
+            PermissionDecision(approved=False, reason="the user declined this call")
+        )
+
+
+class ChoiceModal(ModalScreen[PermissionDecision]):
+    """AskUserQuestion's presentation: numbered options, one keystroke each."""
+
+    BINDINGS = [("escape", "dismiss_none", "Skip")]
+
+    def __init__(self, request: PermissionRequest):
+        super().__init__()
+        self.request = request
+        self.options = _parse_options(request.args_preview)
+        for index, label in enumerate(self.options[:9], start=1):
+            self._bind_option(str(index), label)
+
+    def _bind_option(self, key: str, label: str) -> None:
+        self._bindings.bind(key, f"choose('{label}')", label)
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="permission-box"):
+            yield Static(self._body(), id="permission-body")
+
+    def _body(self) -> Text:
+        text = Text()
+        text.append(f"{self.request.summary}\n\n", style="bold")
+        for index, label in enumerate(self.options[:9], start=1):
+            text.append(f" [{index}] ", style="bold green")
+            text.append(f"{label}\n")
+        text.append("\n[esc] skip", style="dim")
+        return text
+
+    def action_choose(self, label: str) -> None:
+        self.dismiss(PermissionDecision(approved=True, reason=label))
+
+    def action_dismiss_none(self) -> None:
+        self.dismiss(PermissionDecision(approved=False, reason=""))
+
+
+def _parse_options(preview: str) -> list[str]:
+    options: list[str] = []
+    for line in preview.splitlines():
+        stripped = line.strip()
+        if stripped[:1].isdigit() and "." in stripped[:3]:
+            options.append(stripped.split(".", 1)[1].strip())
+    return options

turnloop/tui/widgets/status.py

@@ -0,0 +1,110 @@
+"""The status bar.
+
+Computes nothing. Everything it shows arrives in a StatusUpdate, so a slow status
+line can never slow the agent loop down.
+
+The GPU segment is the part that earns its space: a self-hosted endpoint bills by
+wall clock and only scales down after ten idle minutes, so an open session quietly
+costs $18.16/hour. Showing the running total, in amber, is the difference between
+noticing and finding out from a bill.
+"""
+
+from __future__ import annotations
+
+from rich.text import Text
+from textual.reactive import reactive
+from textual.widgets import Static
+
+
+class StatusBar(Static):
+    provider = reactive("")
+    model = reactive("")
+    mode = reactive("default")
+    context_tokens = reactive(0)
+    context_max = reactive(1)
+    cost_usd = reactive(0.0)
+    tokens_in = reactive(0)
+    tokens_out = reactive(0)
+    gpu_seconds = reactive(0.0)
+    cost_per_hour = reactive(0.0)
+    note = reactive("")
+
+    def render(self) -> Text:
+        line = Text()
+        line.append(f" {self.provider}", style="bold")
+        if self.model:
+            line.append(f":{self.model}", style="dim")
+        line.append("  ")
+
+        pressure = self.context_tokens / max(1, self.context_max)
+        style = "green" if pressure < 0.5 else ("yellow" if pressure < 0.8 else "red")
+        line.append(
+            f"ctx {_k(self.context_tokens)}/{_k(self.context_max)} ({pressure * 100:.0f}%)",
+            style=style,
+        )
+
+        line.append("  ")
+        line.append(f"{_k(self.tokens_in)} in / {_k(self.tokens_out)} out", style="dim")
+
+        if self.cost_per_hour and self.gpu_seconds:
+            gpu_cost = self.gpu_seconds / 3600 * self.cost_per_hour
+            line.append("  ")
+            line.append(
+                f"GPU {_clock(self.gpu_seconds)} ≈ ${gpu_cost:.2f} (idle-stop 10m)",
+                style="bold yellow",
+            )
+        elif self.cost_usd:
+            line.append("  ")
+            line.append(f"${self.cost_usd:.4f}", style="dim")
+
+        if self.mode != "default":
+            line.append("  ")
+            line.append(
+                f"[{self.mode}]",
+                style="bold magenta" if self.mode == "plan" else "bold red",
+            )
+
+        if self.note:
+            line.append("  ")
+            line.append(self.note, style="italic dim")
+
+        return line
+
+
+def _k(n: int) -> str:
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f}M"
+    if n >= 1_000:
+        return f"{n / 1_000:.1f}k"
+    return str(n)
+
+
+def _clock(seconds: float) -> str:
+    total = int(seconds)
+    return f"{total // 3600:02d}:{total % 3600 // 60:02d}:{total % 60:02d}"
+
+
+class BootPanel(Static):
+    """Shown while a self-hosted endpoint cold-boots.
+
+    Twenty-nine minutes of silence is indistinguishable from a hang, and the
+    natural reaction is to kill it — which throws away the boot and starts another
+    one. So the wait is narrated with elapsed time and an expectation.
+    """
+
+    def show(self, text: str, elapsed: float) -> None:
+        body = Text()
+        body.append("Waiting for the model endpoint\n\n", style="bold")
+        body.append(text + "\n", style="yellow")
+        body.append(f"\nelapsed {_clock(elapsed)}\n", style="dim")
+        body.append(
+            "\nThis endpoint is a 744B model on 4xH200 that scales to zero when idle.\n"
+            "A cold boot loads 388GB of weights and JIT-compiles attention kernels:\n"
+            "roughly 29 minutes cold, 13 with a warm compile cache. It is not stuck.\n",
+            style="dim",
+        )
+        self.update(body)
+        self.display = True
+
+    def hide(self) -> None:
+        self.display = False

turnloop/tui/widgets/transcript.py

@@ -0,0 +1,146 @@
+"""The conversation view.
+
+The one performance decision that matters: **token deltas are buffered and
+flushed on a timer, not applied on arrival.** A model streaming 60 tokens per
+second would otherwise trigger 60 full repaints per second, and the UI ends up
+stuttering worse than the model streams. Buffering at 50 ms makes streaming look
+smooth and costs nothing perceptible.
+
+Assistant text is a single Static that gets updated in place, which is what makes
+text appear to grow rather than scrolling line by line.
+"""
+
+from __future__ import annotations
+
+from rich.markdown import Markdown
+from rich.text import Text
+from textual.containers import VerticalScroll
+from textual.widgets import Static
+
+FLUSH_INTERVAL = 0.05
+
+
+class Transcript(VerticalScroll):
+    """Append-only conversation log with an in-place streaming block."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._buffer: list[str] = []
+        self._live: Static | None = None
+        self._live_text = ""
+        self._thinking: Static | None = None
+        self._thinking_text = ""
+        self._flush_timer = None
+        self._tool_blocks: dict[str, Static] = {}
+
+    def on_mount(self) -> None:
+        self._flush_timer = self.set_interval(FLUSH_INTERVAL, self._flush, pause=False)
+
+    # --- user / system lines ----------------------------------------------
+
+    async def add_user(self, text: str) -> None:
+        await self._close_live()
+        await self.mount(Static(Text(f"› {text}", style="bold"), classes="msg user"))
+        self.scroll_end(animate=False)
+
+    async def add_note(self, text: str, classes: str = "note") -> None:
+        await self._close_live()
+        await self.mount(Static(Text(text, style="dim"), classes=f"msg {classes}"))
+        self.scroll_end(animate=False)
+
+    async def add_error(self, text: str) -> None:
+        await self._close_live()
+        await self.mount(Static(Text(text, style="bold red"), classes="msg error"))
+        self.scroll_end(animate=False)
+
+    # --- streaming --------------------------------------------------------
+
+    def append_delta(self, text: str) -> None:
+        """Called once per token. Must stay cheap — it only appends to a list."""
+        self._buffer.append(text)
+
+    def append_thinking(self, text: str) -> None:
+        self._thinking_text += text
+
+    def _flush(self) -> None:
+        if self._thinking_text and self._thinking is None:
+            self._thinking = Static(classes="msg thinking")
+            self.mount(self._thinking)
+        if self._thinking is not None and self._thinking_text:
+            self._thinking.update(Text(_collapse(self._thinking_text), style="italic dim"))
+
+        if not self._buffer:
+            return
+        chunk = "".join(self._buffer)
+        self._buffer.clear()
+        self._live_text += chunk
+
+        if self._live is None:
+            self._live = Static(classes="msg assistant")
+            self.mount(self._live)
+        # Plain Text while streaming: partial markdown (an unclosed code fence) is
+        # rendered wrongly and flickers as the fence completes.
+        self._live.update(Text(self._live_text))
+        self.scroll_end(animate=False)
+
+    async def _close_live(self) -> None:
+        self._flush()
+        if self._live is not None:
+            # Re-render as markdown now that the text is complete.
+            self._live.update(_render_final(self._live_text))
+            self._live = None
+            self._live_text = ""
+        if self._thinking is not None:
+            self._thinking.add_class("collapsed")
+            self._thinking = None
+            self._thinking_text = ""
+
+    async def end_message(self) -> None:
+        await self._close_live()
+
+    # --- tools ------------------------------------------------------------
+
+    async def add_tool_start(self, tool_use_id: str, summary: str,
+                             subagent_id: str | None = None) -> None:
+        await self._close_live()
+        prefix = "  └ " if subagent_id else ""
+        block = Static(Text(f"{prefix}⏵ {summary}", style="cyan"), classes="msg tool running")
+        self._tool_blocks[tool_use_id] = block
+        await self.mount(block)
+        self.scroll_end(animate=False)
+
+    def update_tool(self, tool_use_id: str, name: str, is_error: bool,
+                    display: str | None, duration: float) -> None:
+        block = self._tool_blocks.pop(tool_use_id, None)
+        mark = "✗" if is_error else "✓"
+        style = "red" if is_error else "green"
+        detail = (display or "").strip().splitlines()
+        head = detail[0] if detail else name
+        text = Text(f"{mark} {head}", style=style)
+        if duration > 1:
+            text.append(f"  ({duration:.1f}s)", style="dim")
+        if block is not None:
+            block.remove_class("running")
+            block.update(text)
+        else:
+            self.mount(Static(text, classes="msg tool"))
+        self.scroll_end(animate=False)
+
+    def tool_progress(self, tool_use_id: str, text: str) -> None:
+        block = self._tool_blocks.get(tool_use_id)
+        if block is None:
+            return
+        # Only the latest line is shown: a build's full output belongs in the
+        # transcript's tool result, not scrolling live through the UI.
+        block.update(Text(f"⏵ {text[:160]}", style="cyan dim"))
+
+
+def _collapse(text: str, limit: int = 400) -> str:
+    flat = " ".join(text.split())
+    return flat if len(flat) <= limit else "…" + flat[-limit:]
+
+
+def _render_final(text: str):
+    if any(marker in text for marker in ("```", "\n- ", "\n* ", "\n#", "**")):
+        return Markdown(text)
+    return Text(text)