aloop 0.1.0__py3-none-any.whl

utils/tui/model_ui.py

@@ -0,0 +1,204 @@
+"""TUI helpers for model selection and configuration editing."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import shlex
+import shutil
+import sys
+from pathlib import Path
+from typing import Protocol, Sequence
+
+import aiofiles.os
+from prompt_toolkit.application import Application
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import HSplit, Layout, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.styles import Style
+
+from utils.tui.theme import Theme
+
+
+class _Model(Protocol):
+    model_id: str
+
+
+class _ModelManager(Protocol):
+    config_path: str
+
+    def list_models(self) -> Sequence[_Model]: ...
+
+    def get_current_model(self) -> _Model | None: ...
+
+
+async def open_in_editor(path: str) -> tuple[bool, bool]:
+    """Open a file in an editor (best-effort).
+
+    Returns:
+        (opened, waited): waited indicates we blocked until editing likely finished.
+    """
+    path = str(Path(path))
+
+    editor = os.environ.get("EDITOR") or os.environ.get("VISUAL")
+    if editor:
+        cmd = shlex.split(editor) + [path]
+        try:
+            proc = await asyncio.create_subprocess_exec(*cmd)
+        except FileNotFoundError:
+            return False, False
+        return (await proc.wait()) == 0, True
+
+    if shutil.which("vi"):
+        proc = await asyncio.create_subprocess_exec("vi", path)
+        return (await proc.wait()) == 0, True
+
+    if shutil.which("code"):
+        # Don't use `-w` here; we prefer to return to the TUI after the file is saved
+        # (and auto-reloaded), without requiring the user to close the editor tab.
+        proc = await asyncio.create_subprocess_exec("code", "--reuse-window", path)
+        return (await proc.wait()) == 0, False
+
+    if sys.platform == "darwin" and shutil.which("open"):
+        # `open` returns immediately; we can't reliably wait for editing completion.
+        proc = await asyncio.create_subprocess_exec("open", "-t", path)
+        return (await proc.wait()) == 0, False
+
+    if shutil.which("xdg-open"):
+        # xdg-open returns immediately; we can't reliably wait for editing completion.
+        proc = await asyncio.create_subprocess_exec("xdg-open", path)
+        return (await proc.wait()) == 0, False
+
+    return False, False
+
+
+async def get_mtime(path: str) -> tuple[int, int] | None:
+    try:
+        stat = await aiofiles.os.stat(path)
+        return stat.st_mtime_ns, stat.st_size
+    except FileNotFoundError:
+        return None
+
+
+async def wait_for_file_change(path: str, old_mtime: tuple[int, int] | None) -> None:
+    while True:
+        new_mtime = await get_mtime(path)
+        if old_mtime is None:
+            if new_mtime is not None:
+                return
+        elif new_mtime is not None and new_mtime != old_mtime:
+            return
+        await asyncio.sleep(0.25)
+
+
+async def open_config_and_wait_for_save(config_path: str) -> bool:
+    """Open config file and return when it is likely saved at least once."""
+    before = await get_mtime(config_path)
+    ok, waited = await open_in_editor(config_path)
+    if not ok:
+        return False
+    if not waited:
+        await wait_for_file_change(config_path, before)
+    return True
+
+
+async def pick_model_id(model_manager: _ModelManager, title: str) -> str | None:
+    """Pick a model_id using a keyboard-only list (Codex-style)."""
+    models = list(model_manager.list_models())
+    if not models:
+        return None
+
+    colors = Theme.get_colors()
+    current = model_manager.get_current_model()
+    current_id = current.model_id if current else None
+
+    selected_index = 0
+    if current_id:
+        for i, m in enumerate(models):
+            if m.model_id == current_id:
+                selected_index = i
+                break
+
+    kb = KeyBindings()
+
+    @kb.add("up")
+    @kb.add("k")
+    def _up(event) -> None:
+        nonlocal selected_index
+        selected_index = (selected_index - 1) % len(models)
+
+    @kb.add("down")
+    @kb.add("j")
+    def _down(event) -> None:
+        nonlocal selected_index
+        selected_index = (selected_index + 1) % len(models)
+
+    @kb.add("enter")
+    def _enter(event) -> None:
+        event.app.exit(result=models[selected_index].model_id)
+
+    @kb.add("escape")
+    @kb.add("c-c")
+    def _cancel(event) -> None:
+        event.app.exit(result=None)
+
+    def _render() -> list[tuple[str, str]]:
+        lines: list[tuple[str, str]] = []
+        lines.append(("class:title", f"{title}\n"))
+        lines.append(("class:hint", "Use ↑/↓ and Enter to select, Esc to cancel.\n\n"))
+
+        for idx, m in enumerate(models, start=1):
+            is_selected = (idx - 1) == selected_index
+            is_current = m.model_id == current_id
+
+            prefix = "› " if is_selected else "  "
+            marker = "(current) " if is_current else ""
+            text = f"{prefix}{idx}. {marker}{m.model_id}\n"
+            style = "class:selected" if is_selected else "class:item"
+            lines.append((style, text))
+
+        return lines
+
+    control = FormattedTextControl(_render, focusable=True)
+    window = Window(content=control, dont_extend_height=True, always_hide_cursor=True)
+    layout = Layout(HSplit([window]))
+
+    style_dict = Theme.get_prompt_toolkit_style()
+    style_dict.update(
+        {
+            "title": f"{colors.primary} bold",
+            "hint": colors.text_muted,
+            "item": colors.text_primary,
+            "selected": f"bg:{colors.primary} {colors.bg_primary}",
+        }
+    )
+
+    app = Application(
+        layout=layout,
+        key_bindings=kb,
+        style=Style.from_dict(style_dict),
+        full_screen=False,
+        mouse_support=False,
+    )
+    return await app.run_async()
+
+
+def mask_secret(value: str | None) -> str:
+    if not value:
+        return "(not set)"
+    v = value.strip()
+    if len(v) <= 8:
+        return "*" * len(v)
+    return f"{v[:4]}…{v[-4:]}"
+
+
+def parse_kv_args(tokens: list[str]) -> tuple[dict[str, str], list[str]]:
+    kv: dict[str, str] = {}
+    rest: list[str] = []
+    for token in tokens:
+        if "=" in token:
+            k, _, v = token.partition("=")
+            kv[k.strip()] = v
+        else:
+            rest.append(token)
+    return kv, rest

utils/tui/progress.py

@@ -0,0 +1,292 @@
+"""Progress indicators and spinners for the TUI."""
+
+import time
+from contextlib import contextmanager
+from typing import Generator, Optional
+
+from rich import box
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.spinner import Spinner as RichSpinner
+
+from utils.tui.theme import Theme
+
+
+class Spinner:
+    """Animated spinner with context information."""
+
+    # Spinner animation frames
+    FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+    def __init__(
+        self,
+        console: Console,
+        message: str = "Processing...",
+        show_duration: bool = True,
+    ):
+        """Initialize spinner.
+
+        Args:
+            console: Rich console instance
+            message: Message to display with spinner
+            show_duration: Whether to show elapsed time
+        """
+        self.console = console
+        self.message = message
+        self.show_duration = show_duration
+        self._start_time: Optional[float] = None
+        self._live: Optional[Live] = None
+
+    def _render(self) -> Panel:
+        """Render the spinner panel.
+
+        Returns:
+            Rich Panel with spinner content
+        """
+        colors = Theme.get_colors()
+
+        # Build spinner text with optional duration
+        text = f"  {self.message}"
+        if self.show_duration and self._start_time is not None:
+            elapsed = time.time() - self._start_time
+            text += f"\n  └─ Duration: {elapsed:.1f}s"
+
+        # Create spinner with message
+        spinner = RichSpinner("dots", text=text, style=colors.primary)
+
+        return Panel(
+            spinner,
+            title=f"[{colors.thinking_accent}]Thinking[/{colors.thinking_accent}]",
+            title_align="left",
+            border_style=colors.text_muted,
+            box=box.ROUNDED,
+            padding=(0, 1),
+        )
+
+    @contextmanager
+    def __call__(self, message: Optional[str] = None) -> Generator[None, None, None]:
+        """Context manager for spinner display.
+
+        Args:
+            message: Optional message override
+
+        Yields:
+            None
+        """
+        if message:
+            self.message = message
+
+        self._start_time = time.time()
+        self._live = Live(
+            self._render(),
+            console=self.console,
+            refresh_per_second=10,
+            transient=True,
+        )
+
+        try:
+            with self._live:
+                yield
+        finally:
+            self._start_time = None
+            self._live = None
+
+    def update_message(self, message: str) -> None:
+        """Update the spinner message.
+
+        Args:
+            message: New message to display
+        """
+        self.message = message
+        if self._live is not None:
+            self._live.update(self._render())
+
+
+class ProgressContext:
+    """Context manager for showing progress during long operations."""
+
+    def __init__(
+        self,
+        console: Console,
+        title: str = "Processing",
+        show_steps: bool = True,
+    ):
+        """Initialize progress context.
+
+        Args:
+            console: Rich console instance
+            title: Title for the progress display
+            show_steps: Whether to show step count
+        """
+        self.console = console
+        self.title = title
+        self.show_steps = show_steps
+        self._current_step = 0
+        self._total_steps = 0
+        self._current_message = ""
+        self._start_time: Optional[float] = None
+        self._live: Optional[Live] = None
+
+    def _render(self) -> Panel:
+        """Render the progress panel.
+
+        Returns:
+            Rich Panel with progress content
+        """
+        colors = Theme.get_colors()
+
+        lines = []
+
+        # Current message
+        lines.append(f"  {self._current_message}")
+
+        # Step count
+        if self.show_steps and self._total_steps > 0:
+            lines.append(f"  Step {self._current_step}/{self._total_steps}")
+
+        # Duration
+        if self._start_time is not None:
+            elapsed = time.time() - self._start_time
+            lines.append(f"  [dim]Duration: {elapsed:.1f}s[/dim]")
+
+        content = "\n".join(lines)
+
+        return Panel(
+            content,
+            title=f"[{colors.primary}]{self.title}[/{colors.primary}]",
+            title_align="left",
+            border_style=colors.text_muted,
+            box=box.ROUNDED,
+            padding=(0, 1),
+        )
+
+    def set_total_steps(self, total: int) -> None:
+        """Set the total number of steps.
+
+        Args:
+            total: Total number of steps
+        """
+        self._total_steps = total
+
+    def advance(self, message: str) -> None:
+        """Advance to the next step.
+
+        Args:
+            message: Message for this step
+        """
+        self._current_step += 1
+        self._current_message = message
+        if self._live is not None:
+            self._live.update(self._render())
+
+    def update_message(self, message: str) -> None:
+        """Update the current message without advancing.
+
+        Args:
+            message: New message
+        """
+        self._current_message = message
+        if self._live is not None:
+            self._live.update(self._render())
+
+    @contextmanager
+    def __call__(
+        self, message: str = "Starting...", total_steps: int = 0
+    ) -> Generator["ProgressContext", None, None]:
+        """Context manager for progress display.
+
+        Args:
+            message: Initial message
+            total_steps: Total number of steps (0 for indeterminate)
+
+        Yields:
+            Self for updating progress
+        """
+        self._current_message = message
+        self._total_steps = total_steps
+        self._current_step = 0
+        self._start_time = time.time()
+
+        self._live = Live(
+            self._render(),
+            console=self.console,
+            refresh_per_second=4,
+            transient=True,
+        )
+
+        try:
+            with self._live:
+                yield self
+        finally:
+            self._start_time = None
+            self._live = None
+
+
+class AsyncSpinner:
+    """Async-compatible spinner for use in async contexts."""
+
+    def __init__(
+        self,
+        console: Console,
+        message: str = "Processing...",
+    ):
+        """Initialize async spinner.
+
+        Args:
+            console: Rich console instance
+            message: Message to display
+        """
+        self.console = console
+        self.message = message
+        self._start_time: Optional[float] = None
+        self._live: Optional[Live] = None
+        self._running = False
+
+    def _render(self) -> Panel:
+        """Render the spinner panel."""
+        colors = Theme.get_colors()
+
+        spinner = RichSpinner("dots", text=f"  {self.message}", style=colors.primary)
+
+        return Panel(
+            spinner,
+            title=f"[{colors.thinking_accent}]Thinking[/{colors.thinking_accent}]",
+            title_align="left",
+            border_style=colors.text_muted,
+            box=box.ROUNDED,
+            padding=(0, 1),
+        )
+
+    async def __aenter__(self) -> "AsyncSpinner":
+        """Async context manager entry."""
+        if self.console.quiet:
+            return self
+        self._start_time = time.time()
+        self._running = True
+        self._live = Live(
+            self._render(),
+            console=self.console,
+            refresh_per_second=10,
+            transient=True,
+        )
+        self._live.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Async context manager exit."""
+        self._running = False
+        if self._live is not None:
+            self._live.stop()
+            self._live = None
+        self._start_time = None
+
+    def update_message(self, message: str) -> None:
+        """Update the spinner message.
+
+        Args:
+            message: New message
+        """
+        self.message = message
+        if self._live is not None and self._running:
+            self._live.update(self._render())

utils/tui/status_bar.py

@@ -0,0 +1,178 @@
+"""Persistent status bar for the TUI."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from rich import box
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+
+from utils.tui.theme import Theme
+
+
+@dataclass
+class StatusBarState:
+    """State for the status bar."""
+
+    mode: str = "REACT"
+    input_tokens: int = 0
+    output_tokens: int = 0
+    context_tokens: int = 0
+    cost: float = 0.0
+    is_processing: bool = False
+    status_message: str = ""
+    model_name: str = ""
+
+
+class StatusBar:
+    """Persistent status bar displayed at the bottom of the terminal."""
+
+    def __init__(self, console: Console):
+        """Initialize status bar.
+
+        Args:
+            console: Rich console instance
+        """
+        self.console = console
+        self.state = StatusBarState()
+        self._live: Optional[Live] = None
+
+    def _format_tokens(self, count: int) -> str:
+        """Format token count for display.
+
+        Args:
+            count: Token count
+
+        Returns:
+            Formatted string (e.g., "12.5K" or "1.2M")
+        """
+        if count >= 1_000_000:
+            return f"{count / 1_000_000:.1f}M"
+        elif count >= 1_000:
+            return f"{count / 1_000:.1f}K"
+        else:
+            return str(count)
+
+    def _render(self) -> Panel:
+        """Render the status bar panel.
+
+        Returns:
+            Rich Panel with status bar content
+        """
+        colors = Theme.get_colors()
+
+        # Build status items
+        items = []
+
+        # Model name (if set)
+        if self.state.model_name:
+            items.append(
+                f"[{colors.text_secondary}]Model:[/{colors.text_secondary}] [{colors.primary}]{self.state.model_name}[/{colors.primary}]"
+            )
+
+        # Mode
+        items.append(
+            f"[{colors.text_secondary}]Mode:[/{colors.text_secondary}] [{colors.primary}]{self.state.mode}[/{colors.primary}]"
+        )
+
+        # Total Tokens (in/out)
+        total_in = self._format_tokens(self.state.input_tokens)
+        total_out = self._format_tokens(self.state.output_tokens)
+        items.append(
+            f"[{colors.text_secondary}]Total:[/{colors.text_secondary}] {total_in}↓ {total_out}↑"
+        )
+
+        # Context Tokens
+        ctx_tokens = self._format_tokens(self.state.context_tokens)
+        items.append(f"[{colors.text_secondary}]Context:[/{colors.text_secondary}] {ctx_tokens}")
+
+        # Cost
+        items.append(
+            f"[{colors.text_secondary}]Cost:[/{colors.text_secondary}] ${self.state.cost:.4f}"
+        )
+
+        # Processing indicator
+        if self.state.is_processing:
+            items.append(f"[{colors.warning}]●[/{colors.warning}]")
+        else:
+            items.append(f"[{colors.success}]◉[/{colors.success}]")
+
+        # Join with separator
+        content = " │ ".join(items)
+
+        return Panel(
+            Text.from_markup(content),
+            box=box.DOUBLE,
+            border_style=colors.text_muted,
+            padding=(0, 1),
+        )
+
+    def update(
+        self,
+        mode: Optional[str] = None,
+        input_tokens: Optional[int] = None,
+        output_tokens: Optional[int] = None,
+        context_tokens: Optional[int] = None,
+        cost: Optional[float] = None,
+        is_processing: Optional[bool] = None,
+        status_message: Optional[str] = None,
+        model_name: Optional[str] = None,
+    ) -> None:
+        """Update status bar state.
+
+        Args:
+            mode: Agent mode (REACT, PLAN, etc.)
+            input_tokens: Total input tokens used
+            output_tokens: Total output tokens used
+            context_tokens: Current context window tokens
+            cost: Current cost
+            is_processing: Whether currently processing
+            status_message: Optional status message
+            model_name: Current model name
+        """
+        if mode is not None:
+            self.state.mode = mode
+        if input_tokens is not None:
+            self.state.input_tokens = input_tokens
+        if output_tokens is not None:
+            self.state.output_tokens = output_tokens
+        if context_tokens is not None:
+            self.state.context_tokens = context_tokens
+        if cost is not None:
+            self.state.cost = cost
+        if is_processing is not None:
+            self.state.is_processing = is_processing
+        if status_message is not None:
+            self.state.status_message = status_message
+        if model_name is not None:
+            self.state.model_name = model_name
+
+        # Refresh live display if active
+        if self._live is not None:
+            self._live.update(self._render())
+
+    def show(self) -> None:
+        """Display the status bar (non-live version)."""
+        self.console.print(self._render())
+
+    def start_live(self) -> Live:
+        """Start live updating status bar.
+
+        Returns:
+            Live context manager
+        """
+        self._live = Live(
+            self._render(),
+            console=self.console,
+            refresh_per_second=4,
+            transient=True,
+        )
+        return self._live
+
+    def stop_live(self) -> None:
+        """Stop live updating."""
+        if self._live is not None:
+            self._live.stop()
+            self._live = None