pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/ui/shell/replay.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from collections import deque
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import cast
+
+from pythinker_core.message import ContentPart, Message
+from pythinker_core.tooling import ToolError, ToolOk
+
+from pythinker_code.notifications.llm import is_notification_message
+from pythinker_code.soul.message import is_system_reminder_message
+from pythinker_code.ui.shell.console import console
+from pythinker_code.ui.shell.echo import render_user_echo
+from pythinker_code.ui.shell.visualize import visualize
+from pythinker_code.utils.aioqueue import QueueShutDown
+from pythinker_code.utils.logging import logger
+from pythinker_code.utils.message import message_stringify
+from pythinker_code.utils.slashcmd import parse_slash_command_call
+from pythinker_code.wire import Wire
+from pythinker_code.wire.file import WireFile
+from pythinker_code.wire.types import (
+    Event,
+    StatusUpdate,
+    SteerInput,
+    StepBegin,
+    TextPart,
+    ToolResult,
+    TurnBegin,
+    is_event,
+)
+
+MAX_REPLAY_TURNS = 5
+
+
+@dataclass(slots=True)
+class _ReplayTurn:
+    user_message: Message
+    events: list[Event]
+    n_steps: int = 0
+
+
+async def replay_recent_history(
+    history: Sequence[Message],
+    *,
+    wire_file: WireFile | None = None,
+    show_thinking_stream: bool = False,
+) -> None:
+    """
+    Replay the most recent user-initiated turns from the provided message history or wire file.
+    """
+    if not history:
+        # if the context history is empty,either this is a new session
+        # or the context has been cleared
+        return
+
+    start_idx = _find_replay_start(history)
+    history_turns = (
+        [] if start_idx is None else _build_replay_turns_from_history(history[start_idx:])
+    )
+    turns = await _build_replay_turns_from_wire(wire_file)
+    if not turns or (history_turns and not _same_user_turns(turns, history_turns)):
+        turns = history_turns
+    if not turns:
+        return
+
+    for turn in turns:
+        wire = Wire()
+        console.print(render_user_echo(turn.user_message))
+        ui_task = asyncio.create_task(
+            visualize(
+                wire.ui_side(merge=False),
+                initial_status=StatusUpdate(),
+                show_thinking_stream=show_thinking_stream,
+            )
+        )
+        for event in turn.events:
+            wire.soul_side.send(event)
+            await asyncio.sleep(0)  # yield to UI loop
+        wire.shutdown()
+        with contextlib.suppress(QueueShutDown):
+            await ui_task
+
+
+async def _build_replay_turns_from_wire(wire_file: WireFile | None) -> list[_ReplayTurn]:
+    if wire_file is None or not wire_file.path.exists():
+        return []
+
+    size = wire_file.path.stat().st_size
+    if size > 20 * 1024 * 1024:
+        logger.info(
+            "Wire file too large for replay, skipping: {file} ({size} bytes)",
+            file=wire_file.path,
+            size=size,
+        )
+        return []
+
+    turns: deque[_ReplayTurn] = deque(maxlen=MAX_REPLAY_TURNS)
+    try:
+        async for record in wire_file.iter_records():
+            wire_msg = record.to_wire_message()
+
+            if isinstance(wire_msg, TurnBegin):
+                if _is_clear_command_input(wire_msg.user_input):
+                    turns.clear()
+                    continue
+                turns.append(
+                    _ReplayTurn(
+                        user_message=_message_from_user_input(wire_msg.user_input),
+                        events=[],
+                    )
+                )
+                continue
+
+            if isinstance(wire_msg, SteerInput):
+                turns.append(
+                    _ReplayTurn(
+                        user_message=_message_from_user_input(wire_msg.user_input),
+                        events=[],
+                    )
+                )
+                continue
+
+            if not is_event(wire_msg) or not turns:
+                continue
+
+            current_turn = turns[-1]
+            if isinstance(wire_msg, StepBegin):
+                current_turn.n_steps = wire_msg.n
+            current_turn.events.append(wire_msg)
+    except Exception:
+        logger.exception("Failed to build replay turns from wire file {file}:", file=wire_file.path)
+        return []
+    return list(turns)
+
+
+def _message_from_user_input(user_input: str | list[ContentPart]) -> Message:
+    content = cast(
+        list[ContentPart],
+        list(user_input) if isinstance(user_input, list) else [TextPart(text=user_input)],
+    )
+    return Message(role="user", content=content)
+
+
+def _same_user_turns(lhs: Sequence[_ReplayTurn], rhs: Sequence[_ReplayTurn]) -> bool:
+    return [message_stringify(turn.user_message) for turn in lhs] == [
+        message_stringify(turn.user_message) for turn in rhs
+    ]
+
+
+def _is_clear_command_input(user_input: str | list[ContentPart]) -> bool:
+    if isinstance(user_input, list):
+        text = Message(role="user", content=user_input).extract_text(" ").strip()
+    else:
+        text = str(user_input).strip()
+    call = parse_slash_command_call(text)
+    if call is None:
+        return False
+    return call.name in {"clear", "reset"}
+
+
+def _is_user_message(message: Message) -> bool:
+    # FIXME: should consider non-text tool call results which are sent as user messages
+    if message.role != "user":
+        return False
+    if message.extract_text().startswith("<system>CHECKPOINT"):
+        return False
+    if is_notification_message(message):
+        return False
+    return not is_system_reminder_message(message)
+
+
+def _find_replay_start(history: Sequence[Message]) -> int | None:
+    indices = [idx for idx, message in enumerate(history) if _is_user_message(message)]
+    if not indices:
+        return None
+    # only replay last MAX_REPLAY_TURNS messages
+    return indices[max(0, len(indices) - MAX_REPLAY_TURNS)]
+
+
+def _build_replay_turns_from_history(history: Sequence[Message]) -> list[_ReplayTurn]:
+    turns: list[_ReplayTurn] = []
+    current_turn: _ReplayTurn | None = None
+    for message in history:
+        if _is_user_message(message):
+            # start a new turn
+            if current_turn is not None:
+                turns.append(current_turn)
+            current_turn = _ReplayTurn(user_message=message, events=[])
+        elif message.role == "assistant":
+            if current_turn is None:
+                continue
+            current_turn.n_steps += 1
+            current_turn.events.append(StepBegin(n=current_turn.n_steps))
+            current_turn.events.extend(message.content)
+            current_turn.events.extend(message.tool_calls or [])
+        elif message.role == "tool":
+            if current_turn is None:
+                continue
+            assert message.tool_call_id is not None
+            if any(
+                isinstance(part, TextPart) and part.text.startswith("<system>ERROR")
+                for part in message.content
+            ):
+                result = ToolError(message="", output="", brief="")
+            else:
+                result = ToolOk(output=message.content)
+            current_turn.events.append(
+                ToolResult(tool_call_id=message.tool_call_id, return_value=result)
+            )
+    if current_turn is not None:
+        turns.append(current_turn)
+    return turns

pythinker_code/ui/shell/selector.py

@@ -0,0 +1,364 @@
+"""Reusable selector framework for Pythinker.
+
+Provides a generic, prompt_toolkit-backed selector that mirrors the shape of
+the existing :mod:`pythinker_code.ui.shell.model_picker` but works on any
+list of items. Specific dialogs (theme, thinking, settings, oauth-provider)
+build on this so they all share the same key bindings, search filter
+behavior, header/footer chrome, and theme tokens.
+
+Why a new framework rather than reuse ``prompt_toolkit.shortcuts.choice_input``?
+
+* ChoiceInput doesn't support type-to-filter, which we want for any
+  selector with > 5 items.
+* It doesn't theme via Pythinker's :func:`get_prompt_style` palette so the
+  visual treatment drifts from the rest of the shell.
+* It doesn't expose a header line for explanatory text or a hint footer.
+
+Public API:
+
+* :class:`SelectorItem` — one row.
+* :class:`SelectorConfig` — title + items + optional preselection / hint.
+* :func:`run_selector` — async; returns the selected value or ``None``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.formatted_text import StyleAndTextTuples
+from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
+from prompt_toolkit.layout import HSplit, Layout, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.dimension import Dimension
+
+from pythinker_code.ui.theme import get_prompt_style
+
+__all__ = [
+    "SelectorConfig",
+    "SelectorHeader",
+    "SelectorItem",
+    "run_selector",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class SelectorItem[T]:
+    """A row in a selector.
+
+    Attributes:
+        value: Returned by :func:`run_selector` when this item is chosen.
+        label: Bold primary column, e.g. ``"dark"`` or ``"claude-opus-4-7"``.
+        description: Optional muted secondary column shown to the right.
+        is_current: Marks the item as the active selection — pre-selected
+            on open and labelled ``(current)`` in the description.
+    """
+
+    value: T
+    label: str
+    description: str = ""
+    is_current: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class SelectorHeader:
+    """A non-selectable divider row in a selector."""
+
+    label: str
+
+
+@dataclass(frozen=True, slots=True)
+class SelectorConfig[T]:
+    """Static configuration for a selector dialog."""
+
+    title: str
+    items: Sequence[SelectorItem[T] | SelectorHeader]
+    """Source rows. May be empty — the selector will show a placeholder."""
+
+    hint: str = "↑↓ navigate · Enter select · Esc cancel · type to filter"
+    """Footer shown below the item list."""
+
+    enable_filter: bool = True
+    """When False, type-to-filter is disabled (useful for tiny selectors)."""
+
+    on_change: Callable[[T], None] | None = None
+    """Called whenever the cursor moves to a different SelectorItem."""
+
+
+def _format_item_line[T](
+    item: SelectorItem[T],
+    *,
+    is_selected: bool,
+    width: int,
+) -> StyleAndTextTuples:
+    """One row in the selector — marker + label + description.
+
+    Reuses the same ``slash-completion-menu`` style classes as the prompt's
+    completion menu so the visual treatment is consistent.
+    """
+    marker = "› " if is_selected else "  "
+    marker_style = (
+        "class:slash-completion-menu.marker.current"
+        if is_selected
+        else "class:slash-completion-menu.marker"
+    )
+    label_style = (
+        "class:slash-completion-menu.command.current"
+        if is_selected
+        else "class:slash-completion-menu.command"
+    )
+    meta_style = (
+        "class:slash-completion-menu.meta.current"
+        if is_selected
+        else "class:slash-completion-menu.meta"
+    )
+    row_bg = (
+        "class:slash-completion-menu.row.current" if is_selected else "class:slash-completion-menu"
+    )
+
+    desc_parts: list[str] = []
+    if item.is_current:
+        desc_parts.append("(current)")
+    if item.description:
+        desc_parts.append(item.description)
+    description = " ".join(desc_parts)
+
+    label = item.label
+    gap = "  "
+    # Width budget: marker(2) + label + gap(2) + description + trailing pad
+    used = len(marker) + len(label) + len(gap) + len(description)
+    pad = max(0, width - used)
+    return [
+        (marker_style, marker),
+        (label_style, label),
+        (row_bg, gap),
+        (meta_style, description),
+        (row_bg, " " * pad),
+        ("", "\n"),
+    ]
+
+
+class _SelectorState[T]:
+    """Internal state for the selector application."""
+
+    def __init__(self, config: SelectorConfig[T]) -> None:
+        self.config = config
+        self.filter = ""
+        self.selected_idx = 0
+        self.visible: list[SelectorItem[T] | SelectorHeader] = []
+        self.result: T | None = None
+        self.cancelled = False
+        self._refilter(initial=True)
+
+    def _matches(self, item: SelectorItem[T]) -> bool:
+        if not self.filter:
+            return True
+        needle = self.filter.lower()
+        return needle in item.label.lower() or needle in item.description.lower()
+
+    def _selectable_indices(self) -> list[int]:
+        return [i for i, item in enumerate(self.visible) if isinstance(item, SelectorItem)]
+
+    def _refilter(self, *, initial: bool = False) -> None:
+        previous_value: T | None = None
+        if not initial and self.visible and 0 <= self.selected_idx < len(self.visible):
+            current = self.visible[self.selected_idx]
+            if isinstance(current, SelectorItem):
+                previous_value = current.value
+
+        if not self.filter:
+            self.visible = list(self.config.items)
+        else:
+            self.visible = [
+                item
+                for item in self.config.items
+                if isinstance(item, SelectorItem) and self._matches(item)
+            ]
+
+        selectable = self._selectable_indices()
+        if not selectable:
+            self.selected_idx = 0
+            return
+
+        if previous_value is not None:
+            for i, item in enumerate(self.visible):
+                if isinstance(item, SelectorItem) and item.value == previous_value:
+                    self.selected_idx = i
+                    return
+
+        if initial:
+            for i, item in enumerate(self.visible):
+                if isinstance(item, SelectorItem) and item.is_current:
+                    self.selected_idx = i
+                    return
+
+        self.selected_idx = selectable[0]
+
+    def move(self, delta: int) -> None:
+        selectable = self._selectable_indices()
+        if not selectable:
+            return
+        try:
+            pos = selectable.index(self.selected_idx)
+        except ValueError:
+            pos = 0
+        new_idx = selectable[(pos + delta) % len(selectable)]
+        changed = new_idx != self.selected_idx
+        self.selected_idx = new_idx
+        if changed and self.config.on_change is not None:
+            item = self.visible[new_idx]
+            if isinstance(item, SelectorItem):
+                self.config.on_change(item.value)
+
+    def commit(self) -> bool:
+        if not self.visible or self.selected_idx >= len(self.visible):
+            return False
+        item = self.visible[self.selected_idx]
+        if not isinstance(item, SelectorItem):
+            return False
+        self.result = item.value
+        return True
+
+    def append_filter(self, ch: str) -> None:
+        self.filter += ch
+        self._refilter()
+
+    def backspace_filter(self) -> None:
+        if self.filter:
+            self.filter = self.filter[:-1]
+            self._refilter()
+
+    def clear_filter(self) -> None:
+        if self.filter:
+            self.filter = ""
+            self._refilter()
+
+
+def _build_application[T](state: _SelectorState[T]) -> Application[None]:
+    config = state.config
+
+    def header_text() -> StyleAndTextTuples:
+        out: StyleAndTextTuples = [
+            ("class:slash-completion-menu.command.current", config.title),
+            ("", "\n"),
+        ]
+        if config.enable_filter:
+            filter_display = state.filter or "(type to filter)"
+            out.append(("class:slash-completion-menu.meta", f"filter: {filter_display}"))
+            out.append(("", "\n"))
+        return out
+
+    def items_text() -> StyleAndTextTuples:
+        if not state.visible:
+            return [
+                ("class:slash-completion-menu.meta", "  no matches"),
+                ("", "\n"),
+            ]
+        width = 80
+        rows: StyleAndTextTuples = []
+        for i, item in enumerate(state.visible):
+            if isinstance(item, SelectorHeader):
+                rows.extend(
+                    [
+                        ("class:slash-completion-menu.meta", f"  {item.label}"),
+                        ("", "\n"),
+                    ]
+                )
+            else:
+                rows.extend(
+                    _format_item_line(item, is_selected=i == state.selected_idx, width=width)
+                )
+        return rows
+
+    def hint_text() -> StyleAndTextTuples:
+        return [("class:slash-completion-menu.meta", config.hint)]
+
+    bindings = KeyBindings()
+
+    def on_up(event: KeyPressEvent) -> None:
+        state.move(-1)
+        event.app.invalidate()
+
+    def on_down(event: KeyPressEvent) -> None:
+        state.move(1)
+        event.app.invalidate()
+
+    def on_enter(event: KeyPressEvent) -> None:
+        if state.commit():
+            event.app.exit()
+
+    def on_cancel(event: KeyPressEvent) -> None:
+        state.cancelled = True
+        event.app.exit()
+
+    bindings.add("up")(on_up)
+    bindings.add("down")(on_down)
+    bindings.add("enter")(on_enter)
+    bindings.add("escape", eager=True)(on_cancel)
+    bindings.add("c-c")(on_cancel)
+    bindings.add("c-d")(on_cancel)
+
+    if config.enable_filter:
+
+        def on_backspace(event: KeyPressEvent) -> None:
+            state.backspace_filter()
+            event.app.invalidate()
+
+        def on_clear(event: KeyPressEvent) -> None:
+            state.clear_filter()
+            event.app.invalidate()
+
+        def on_any(event: KeyPressEvent) -> None:
+            ch = event.data
+            if ch and len(ch) == 1 and ch.isprintable():
+                state.append_filter(ch)
+                event.app.invalidate()
+
+        bindings.add("backspace")(on_backspace)
+        bindings.add("c-u")(on_clear)
+        bindings.add("<any>")(on_any)
+
+    layout = Layout(
+        HSplit(
+            [
+                Window(
+                    FormattedTextControl(header_text),
+                    height=Dimension(min=2, max=2),
+                    style="class:slash-completion-menu",
+                ),
+                Window(
+                    FormattedTextControl(items_text),
+                    style="class:slash-completion-menu",
+                ),
+                Window(
+                    FormattedTextControl(hint_text),
+                    height=Dimension(min=1, max=1),
+                    style="class:slash-completion-menu",
+                ),
+            ]
+        )
+    )
+
+    return Application(
+        layout=layout,
+        key_bindings=bindings,
+        full_screen=False,
+        style=get_prompt_style(),
+        mouse_support=False,
+    )
+
+
+async def run_selector[T](config: SelectorConfig[T]) -> T | None:
+    """Show *config* as an interactive selector. Returns the chosen value
+    or ``None`` if the user cancelled.
+
+    Empty selectors (no items, no items match the filter) still let the user
+    cancel — they just can't commit.
+    """
+    state: _SelectorState[T] = _SelectorState(config)
+    app = _build_application(state)
+    await app.run_async()
+    if state.cancelled or state.result is None:
+        return None
+    return state.result

pythinker_code/ui/shell/selectors/__init__.py

@@ -0,0 +1,38 @@
+"""Selector dialogs for Pythinker.
+
+Each sub-module exposes one run_*() async function. Import from this package:
+
+    from pythinker_code.ui.shell.selectors import run_theme_selector
+"""
+
+from pythinker_code.ui.shell.selectors.extension import run_extension_selector
+from pythinker_code.ui.shell.selectors.oauth import (
+    OAuthProviderEntry,
+    OAuthProviderStatus,
+    run_oauth_selector,
+)
+from pythinker_code.ui.shell.selectors.settings import (
+    apply_settings_changes,
+    run_settings_selector,
+)
+from pythinker_code.ui.shell.selectors.show_images import run_show_images_selector
+from pythinker_code.ui.shell.selectors.theme import run_theme_selector
+from pythinker_code.ui.shell.selectors.thinking import (
+    LEVEL_DESCRIPTIONS,
+    ThinkingLevel,
+    run_thinking_selector,
+)
+
+__all__ = [
+    "LEVEL_DESCRIPTIONS",
+    "OAuthProviderEntry",
+    "OAuthProviderStatus",
+    "ThinkingLevel",
+    "apply_settings_changes",
+    "run_extension_selector",
+    "run_oauth_selector",
+    "run_settings_selector",
+    "run_show_images_selector",
+    "run_theme_selector",
+    "run_thinking_selector",
+]

pythinker_code/ui/shell/selectors/extension.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import asyncio
+
+from pythinker_code.ui.shell.selector import SelectorConfig, SelectorItem, run_selector
+
+
+def _build_extension_config(
+    title: str,
+    options: list[str],
+    *,
+    current: str | None = None,
+) -> SelectorConfig[str]:
+    return SelectorConfig(
+        title=title,
+        items=[SelectorItem(value=opt, label=opt, is_current=(opt == current)) for opt in options],
+    )
+
+
+async def run_extension_selector(
+    title: str,
+    options: list[str],
+    *,
+    current: str | None = None,
+    timeout: float | None = None,
+) -> str | None:
+    coro = run_selector(_build_extension_config(title, options, current=current))
+    if timeout is not None:
+        try:
+            return await asyncio.wait_for(coro, timeout=timeout)
+        except TimeoutError:
+            # Real ``asyncio.wait_for`` cancels/awaits the coroutine on timeout;
+            # tests may monkeypatch it to raise directly, so close the coroutine
+            # here to avoid an un-awaited-coroutine warning.
+            coro.close()
+            return None
+    return await coro