solohq-cli 0.1.0__py3-none-any.whl

solohq_cli/browser.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+
+import os
+import sys
+from io import StringIO
+from typing import TYPE_CHECKING
+
+from prompt_toolkit import Application
+from prompt_toolkit.formatted_text import ANSI, FormattedText, to_formatted_text
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout.containers import HSplit, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.layout import Layout
+from prompt_toolkit.styles import Style
+
+from .display import (
+    console,
+    print_artifact_detail,
+    print_context_detail,
+    print_episode_detail,
+    print_info,
+)
+
+if TYPE_CHECKING:
+    from solohq_agno import AgnoContextMemory
+    from solohq_memory import ContextMemoryManager
+
+MAX_VISIBLE = 15
+
+_STYLE = Style.from_dict({
+    "title": "#888888",
+    "selected": "bold #ffffff",
+    "item": "#aaaaaa",
+    "hint": "#666666",
+    "sep": "#555555",
+})
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _clear_up(n: int) -> None:
+    """Move cursor up n lines and clear everything below."""
+    sys.stdout.write(f"\033[{n}A\033[J")
+    sys.stdout.flush()
+
+
+def _term_height() -> int:
+    try:
+        return os.get_terminal_size().lines
+    except (ValueError, OSError):
+        return 24
+
+
+def _capture_rich(fn, *args, **kwargs) -> str:  # noqa: ANN001, ANN003
+    """Call a Rich display function and capture its ANSI output."""
+    from rich.console import Console as RichConsole
+
+    buf = StringIO()
+    capture = RichConsole(
+        file=buf,
+        force_terminal=True,
+        width=console.width or 80,
+        color_system=console.color_system or "256",
+    )
+    import solohq_cli.display as _display
+
+    old = _display.console
+    _display.console = capture
+    try:
+        fn(*args, **kwargs)
+    finally:
+        _display.console = old
+    return buf.getvalue()
+
+
+def _ansi_lines(text: str) -> list[list[tuple[str, str]]]:
+    """Parse ANSI text into lines of prompt_toolkit (style, text) fragments."""
+    raw = to_formatted_text(ANSI(text))
+    merged: list[tuple[str, str]] = []
+    for style, ch in raw:
+        if merged and merged[-1][0] == style:
+            merged[-1] = (style, merged[-1][1] + ch)
+        else:
+            merged.append((style, ch))
+    lines: list[list[tuple[str, str]]] = [[]]
+    for style, chunk in merged:
+        parts = chunk.split("\n")
+        for i, part in enumerate(parts):
+            if i > 0:
+                lines.append([])
+            if part:
+                lines[-1].append((style, part))
+    if lines and not lines[-1]:
+        lines.pop()
+    return lines
+
+
+# ---------------------------------------------------------------------------
+# Full-screen scrollable detail viewer
+# ---------------------------------------------------------------------------
+
+
+async def _show_detail(fn, *args, **kwargs) -> None:  # noqa: ANN001, ANN003
+    """Show Rich output in a full-screen scrollable view."""
+    captured = _capture_rich(fn, *args, **kwargs)
+    lines = _ansi_lines(captured)
+    total = len(lines)
+    if total == 0:
+        return
+
+    view_h = [_term_height() - 2]
+    scroll = [0]
+
+    def _max_scroll() -> int:
+        return max(0, total - view_h[0])
+
+    def get_fragments() -> FormattedText:
+        result: list[tuple[str, str]] = []
+        vis = lines[scroll[0] : scroll[0] + view_h[0]]
+        for line_frags in vis:
+            result.extend(line_frags)
+            result.append(("", "\n"))
+        ms = _max_scroll()
+        if ms > 0:
+            lo = scroll[0] + 1
+            hi = min(scroll[0] + view_h[0], total)
+            result.append(("class:hint", f" [{lo}-{hi}/{total}] \u2191\u2193 scroll  Esc back"))
+        else:
+            result.append(("class:hint", " Esc to go back"))
+        return FormattedText(result)
+
+    control = FormattedTextControl(get_fragments, focusable=True)
+    window = Window(content=control, always_hide_cursor=True)
+
+    kb = KeyBindings()
+
+    @kb.add("up")
+    @kb.add("k")
+    def _up(event) -> None:  # noqa: ANN001
+        if scroll[0] > 0:
+            scroll[0] -= 1
+
+    @kb.add("down")
+    @kb.add("j")
+    def _down(event) -> None:  # noqa: ANN001
+        if scroll[0] < _max_scroll():
+            scroll[0] += 1
+
+    @kb.add("pageup")
+    def _pgup(event) -> None:  # noqa: ANN001
+        scroll[0] = max(0, scroll[0] - view_h[0])
+
+    @kb.add("pagedown")
+    @kb.add(" ")
+    def _pgdn(event) -> None:  # noqa: ANN001
+        scroll[0] = min(_max_scroll(), scroll[0] + view_h[0])
+
+    @kb.add("escape")
+    def _dismiss(event) -> None:  # noqa: ANN001
+        event.app.exit()
+
+    app: Application[None] = Application(
+        layout=Layout(HSplit([window])),
+        key_bindings=kb,
+        style=_STYLE,
+        full_screen=True,
+    )
+    await app.run_async()
+
+
+# ---------------------------------------------------------------------------
+# Inline picker — renders in-place, erases on exit
+# ---------------------------------------------------------------------------
+
+
+async def pick_item(items: list[tuple[str, str]], title: str = "") -> str | None:
+    """Inline vertical picker (\u2191\u2193). Self-cleaning via save/restore."""
+    if not items:
+        return None
+
+    selected = [0]
+    offset = [0]
+
+    def get_fragments() -> FormattedText:
+        frags: list[tuple[str, str]] = []
+        if title:
+            frags.append(("class:title", f" {title}\n"))
+        vis_count = min(len(items), MAX_VISIBLE)
+        for i in range(offset[0], offset[0] + vis_count):
+            if i >= len(items):
+                break
+            _id, label = items[i]
+            if i == selected[0]:
+                frags.append(("class:selected", f" > {label}\n"))
+            else:
+                frags.append(("class:item", f"   {label}\n"))
+        frags.append(("class:hint", " \u2191\u2193 navigate  Enter select  Esc back"))
+        return FormattedText(frags)
+
+    kb = KeyBindings()
+
+    @kb.add("up")
+    @kb.add("k")
+    def _up(event) -> None:  # noqa: ANN001
+        if selected[0] > 0:
+            selected[0] -= 1
+            if selected[0] < offset[0]:
+                offset[0] = selected[0]
+
+    @kb.add("down")
+    @kb.add("j")
+    def _down(event) -> None:  # noqa: ANN001
+        if selected[0] < len(items) - 1:
+            selected[0] += 1
+            if selected[0] >= offset[0] + MAX_VISIBLE:
+                offset[0] = selected[0] - MAX_VISIBLE + 1
+
+    @kb.add("enter")
+    def _select(event) -> None:  # noqa: ANN001
+        event.app.exit(result=items[selected[0]][0])
+
+    @kb.add("escape")
+    def _cancel(event) -> None:  # noqa: ANN001
+        event.app.exit(result=None)
+
+    control = FormattedTextControl(get_fragments, focusable=True)
+    window = Window(content=control, always_hide_cursor=True)
+
+    app: Application[str | None] = Application(
+        layout=Layout(HSplit([window])),
+        key_bindings=kb,
+        style=_STYLE,
+        full_screen=False,
+    )
+
+    result = await app.run_async()
+
+    # Erase picker: title + visible items + hint line.
+    height = (1 if title else 0) + min(len(items), MAX_VISIBLE) + 1
+    _clear_up(height)
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Browse functions
+# ---------------------------------------------------------------------------
+
+
+async def browse_contexts(
+    memory: ContextMemoryManager, user_id: str, plugin: AgnoContextMemory
+) -> None:
+    """Interactive context browser."""
+    contexts = await memory._storage.list_contexts(user_id)
+    if not contexts:
+        print_info("No contexts found.")
+        return
+
+    items = [
+        (ctx.id, f"{ctx.title}  {ctx.updated_at:%m-%d %H:%M}")
+        for ctx in contexts
+    ]
+    while True:
+        chosen = await pick_item(items, title="Contexts")
+        if not chosen:
+            return
+        ctx = await memory._storage.get_context(chosen)
+        if not ctx:
+            continue
+        loaded = await memory.load_context(chosen)
+        await _ctx_menu(ctx, loaded, memory, plugin)
+
+
+async def browse_current(
+    ctx, loaded, memory: ContextMemoryManager, plugin: AgnoContextMemory  # noqa: ANN001
+) -> None:
+    """Entry point for /current."""
+    await _ctx_menu(ctx, loaded, memory, plugin)
+
+
+async def _ctx_menu(
+    ctx, loaded, memory: ContextMemoryManager, plugin: AgnoContextMemory  # noqa: ANN001
+) -> None:
+    """Context sub-menu — inline picker with drill-down options."""
+    ep_count = len(loaded.episodes)
+    art_count = len(loaded.artifacts)
+    options: list[tuple[str, str]] = [
+        ("detail", "View details"),
+        ("episodes", f"{ep_count} episodes"),
+        ("artifacts", f"{art_count} artifacts"),
+    ]
+    while True:
+        choice = await pick_item(options, title=ctx.title)
+        match choice:
+            case "detail":
+                await _show_detail(print_context_detail, ctx, loaded)
+            case "episodes":
+                await _episodes_view(loaded.episodes, memory)
+            case "artifacts":
+                await _artifacts_view(loaded.artifacts, memory)
+            case _:
+                return
+
+
+async def browse_artifacts(memory: ContextMemoryManager, ctx_id: str) -> None:
+    """Interactive artifact browser for /artifacts."""
+    artifacts = await memory._storage.list_artifacts_for_context(ctx_id)
+    if not artifacts:
+        print_info("No artifacts in current context.")
+        return
+    await _artifacts_view(list(artifacts), memory)
+
+
+async def _artifacts_view(artifacts: list, memory: ContextMemoryManager) -> None:
+    """Artifact list -> scrollable detail."""
+    if not artifacts:
+        print_info("No artifacts.")
+        return
+    items = [
+        (art.id, f"{art.title}  ({art.type}, v{art.current_version})")
+        for art in artifacts
+    ]
+    while True:
+        chosen = await pick_item(items, title="Artifacts")
+        if not chosen:
+            return
+        art = await memory._storage.get_artifact(chosen)
+        if art:
+            await _show_detail(print_artifact_detail, art)
+
+
+async def browse_episodes(memory: ContextMemoryManager, ctx_id: str) -> None:
+    """Interactive episode browser for /episodes."""
+    episodes = await memory._storage.list_episodes(ctx_id)
+    if not episodes:
+        print_info("No episodes in current context.")
+        return
+    await _episodes_view(list(episodes), memory)
+
+
+async def _episodes_view(episodes: list, memory: ContextMemoryManager) -> None:
+    """Episode list -> scrollable detail."""
+    if not episodes:
+        print_info("No episodes.")
+        return
+    items = [
+        (ep.id, f"{ep.summary[:60]}  {ep.time_start:%m-%d %H:%M}")
+        for ep in episodes
+    ]
+    while True:
+        chosen = await pick_item(items, title="Episodes")
+        if not chosen:
+            return
+        ep = await memory._storage.get_episode(chosen)
+        if ep:
+            messages = await memory._storage.list_messages(ep.id)
+            await _show_detail(print_episode_detail, ep, messages)