induscode 0.1.0__py3-none-any.whl

induscode/console/overlays/pickers.py

@@ -0,0 +1,526 @@
+"""Picker overlays — the selection dialogs raised over the transcript.
+
+Port of TS ``src/console/overlays/pickers.tsx``. This module owns the four
+modal kinds that present a list to pick from: the single-model picker
+(``models``), the per-scope model picker (``scopedModels``), the
+colour-scheme picker (``theme``), and the settings list (``settings``).
+
+Dialog-API inversion (port plan analysis 02, risk 1) — the TS group was an
+always-mounted component routed by ``ModalState.kind``, feeding callback
+props (``onSelect``/``onSave``/``onClose``) into dialogs that stayed mounted
+until the host dropped the modal state. The Python framework dialogs are
+``ModalScreen[Result]`` values dismissed *with* a result, so each kind here
+is an awaited ``push_screen_wait`` flow instead:
+
+- every flow is ``async def run_*(app, payload, services) -> events`` — it
+  pushes the framework dialog, awaits the dismissal result, applies the side
+  effects (conductor / preference-store writes) *after* the await, and
+  returns the reducer events the App folds once the overlay closes;
+- the TS ``useEffect`` one-shots (the scoped-models ``{intent: "reset"}``
+  fire-on-mount path) become a plain early return before any screen is
+  pushed;
+- the theme picker's preview-before-commit machinery (TS: ``onHighlight`` →
+  ``scheme:set`` dispatch re-rendering the whole surface) collapses into the
+  framework ``ThemeDialog`` itself — highlight sets ``app.theme`` live,
+  Esc restores the captured original, Enter dismisses with the committed
+  scheme token; only the *persist + reducer bookkeeping* remains here;
+- the auth-probe race the TS model picker tolerated (``null`` until the
+  vault probe settled → "show all") collapses: the probe is awaited before
+  the dialog ever opens;
+- the TS settings rows dispatched ``toggle:*`` / ``scheme:set`` live while
+  the dialog was up; here each row writes the preference store immediately
+  and appends the matching event to an accumulator the flow returns, folded
+  by the App after the dialog closes (the modal covers the surface in the
+  meantime; the colour-scheme row still re-themes live via ``app.theme``).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Final, cast
+
+from indusagi.llmgateway.contract import CostSheet, ModelCard
+from indusagi.react_ink import (
+    ModelDialog,
+    ScopedModelsDialog,
+    SettingsDialog,
+    SettingsDialogItem,
+    ThemeDialog,
+    ThemeDialogItem,
+)
+
+from induscode.console.contract import (
+    ConsoleEvent,
+    OverlayServices,
+    SchemeSet,
+    StatusMessage,
+    StatusSet,
+    ToggleImages,
+    ToggleReasoning,
+    is_theme_scheme,
+)
+from induscode.settings import DELIVERY_MODES, is_delivery_mode
+
+if TYPE_CHECKING:
+    from textual.app import App
+
+    from induscode.conductor import ModelCardRef
+
+__all__ = [
+    "THEME_CHOICES",
+    "THEME_NAMES",
+    "TOGGLE_VALUES",
+    "authenticated_providers",
+    "build_settings_items",
+    "card_catalog_id",
+    "list_model_refs",
+    "read_scoped_payload",
+    "ref_to_card",
+    "run_model_picker",
+    "run_scoped_models",
+    "run_settings_picker",
+    "run_theme_picker",
+]
+
+
+# ---------------------------------------------------------------------------
+# Theme choices (TS THEME_CHOICES verbatim, already in the dialog item shape)
+# ---------------------------------------------------------------------------
+
+#: The colour schemes the theme picker offers, in listing order — the two
+#: base schemes followed by their daltonized (color-blind-safe) counterparts.
+THEME_CHOICES: Final[tuple[ThemeDialogItem, ...]] = (
+    ThemeDialogItem(id="midnight", label="Midnight", description="dark terminals"),
+    ThemeDialogItem(id="daylight", label="Daylight", description="light terminals"),
+    ThemeDialogItem(
+        id="midnight-cb",
+        label="Midnight (color-blind)",
+        description="deuteran-safe, dark",
+    ),
+    ThemeDialogItem(
+        id="daylight-cb",
+        label="Daylight (color-blind)",
+        description="deuteran-safe, light",
+    ),
+)
+
+#: The scheme tokens the theme picker offers, derived from THEME_CHOICES.
+THEME_NAMES: Final[tuple[str, ...]] = tuple(choice.id for choice in THEME_CHOICES)
+
+#: The on/off vocabulary the boolean settings rows toggle between.
+TOGGLE_VALUES: Final[tuple[str, ...]] = ("on", "off")
+
+
+# ---------------------------------------------------------------------------
+# Catalog → framework-card mapping (TS refToModel)
+# ---------------------------------------------------------------------------
+
+
+def ref_to_card(ref: "ModelCardRef") -> ModelCard:
+    """Lift a catalog :class:`ModelCardRef` into the framework
+    :class:`ModelCard` shape the model dialogs render.
+
+    The dialogs read identity/label/reasoning and hand the value back through
+    their dismissal result; the numeric/capability fields are seeded to inert
+    defaults since the picker never consults them (the TS ``refToModel``
+    seeded the same way). The card carries the provider-scoped ``modelId`` as
+    its ``id`` so the framework row label renders ``provider/modelId`` —
+    :func:`card_catalog_id` reassembles the canonical catalog key.
+    """
+    return ModelCard(
+        id=ref.modelId,
+        provider=cast(Any, ref.provider),
+        api=cast(Any, ""),
+        display_name=ref.name,
+        context_window=0,
+        max_output_tokens=0,
+        modalities=("text",),
+        reasoning=ref.reasoning,
+        cost=CostSheet(input_per_mtok=0.0, output_per_mtok=0.0),
+        # An empty wire_id would be normalized to ``id``; seed it explicitly
+        # so the inert card stays inert.
+        wire_id=ref.modelId,
+    )
+
+
+def card_catalog_id(card: ModelCard) -> str:
+    """The canonical ``provider/modelId`` catalog key for a picker card —
+    exactly how the conductor catalog builds :attr:`ModelCardRef.id`."""
+    return f"{card.provider}/{card.id}"
+
+
+def list_model_refs(services: OverlayServices) -> list["ModelCardRef"]:
+    """Read the catalog as :class:`ModelCardRef` rows, tolerant of any fault
+    (the TS ``listModels`` try/catch)."""
+    try:
+        return list(services.conductor.available_models())
+    except Exception:
+        return []
+
+
+async def authenticated_providers(services: OverlayServices) -> set[str]:
+    """The set of provider ids the user has authenticated (any saved account
+    in the vault), probed live so a mid-session ``/login`` is reflected.
+
+    Port delta (risk-1 redesign): the TS hook returned ``null`` until the
+    async probe settled and the picker showed the whole catalog meanwhile;
+    here the probe is simply awaited before the dialog opens, so the race
+    disappears. A provider that cannot be read is not counted; a directory
+    fault yields the set gathered so far.
+    """
+    found: set[str] = set()
+    try:
+        providers = services.list_login_providers()
+    except Exception:
+        return found
+    for provider in providers:
+        try:
+            if len(await services.vault.list_accounts(provider.id)) > 0:
+                found.add(provider.id)
+        except Exception:
+            # A provider that cannot be read is simply not counted.
+            continue
+    return found
+
+
+# ---------------------------------------------------------------------------
+# models — the single-model picker
+# ---------------------------------------------------------------------------
+
+
+async def run_model_picker(
+    app: "App[Any]",
+    payload: object | None,
+    services: OverlayServices | None,
+) -> tuple[ConsoleEvent, ...]:
+    """The single-model picker flow.
+
+    Restricted to models from providers the user has signed into (so the
+    list shows only callable models); if none are authenticated, the whole
+    catalog is offered rather than an empty picker. Selecting a card binds it
+    on the conductor; Esc leaves the session untouched.
+    """
+    if services is None:
+        return ()
+    refs = list_model_refs(services)
+    authed = await authenticated_providers(services)
+    pool = [ref for ref in refs if ref.provider in authed] if authed else refs
+    chosen = await app.push_screen_wait(ModelDialog([ref_to_card(ref) for ref in pool]))
+    if chosen is not None:
+        try:
+            services.conductor.select_model(card_catalog_id(chosen))
+        except Exception:
+            # Selection faults must not crash the overlay.
+            pass
+    return ()
+
+
+# ---------------------------------------------------------------------------
+# scopedModels — the per-scope model picker
+# ---------------------------------------------------------------------------
+
+
+def read_scoped_payload(payload: object | None) -> dict[str, str]:
+    """Narrow the opaque modal payload to the per-scope picker's known fields.
+
+    The ``/scoped-models`` sub-verbs raise the picker with: ``show`` →
+    ``{"focus": "summary"}``; ``reset`` → ``{"intent": "reset"}``; ``edit``
+    (and a bare chord) → nothing. Unknown shapes narrow to ``{}``.
+    """
+    if not isinstance(payload, dict):
+        return {}
+    out: dict[str, str] = {}
+    if payload.get("focus") == "summary":
+        out["focus"] = "summary"
+    if payload.get("intent") == "reset":
+        out["intent"] = "reset"
+    return out
+
+
+async def run_scoped_models(
+    app: "App[Any]",
+    payload: object | None,
+    services: OverlayServices | None,
+) -> tuple[ConsoleEvent, ...]:
+    """The per-scope model picker flow.
+
+    The current enabled-models preference seeds the selection (empty means
+    every model); saving persists the chosen ids. The ``{"intent": "reset"}``
+    payload clears the override, persists, reports, and returns *without*
+    presenting the list (the TS fire-once ``useEffect`` becomes this early
+    return); ``{"focus": "summary"}`` opens the picker normally (parity: the
+    dialog exposes no read-only summary affordance to target).
+    """
+    if services is None:
+        return ()
+    request = read_scoped_payload(payload)
+
+    if request.get("intent") == "reset":
+        try:
+            services.settings.set("enabledModels", [])
+            services.settings.save()
+            status = StatusMessage(kind="info", text="Per-scope model overrides cleared.")
+        except Exception:
+            status = StatusMessage(
+                kind="error", text="Could not clear per-scope model overrides."
+            )
+        return (StatusSet(status=status),)
+
+    refs = list_model_refs(services)
+    try:
+        enabled = list(services.settings.get("enabledModels"))
+    except Exception:
+        enabled = []
+    selected = enabled if len(enabled) > 0 else [ref.id for ref in refs]
+
+    ids = await app.push_screen_wait(
+        ScopedModelsDialog([ref_to_card(ref) for ref in refs], selected_ids=selected)
+    )
+    if ids is not None:
+        try:
+            # Everything selected means "no restriction" — store empty.
+            next_ids = [] if len(ids) == len(refs) else list(ids)
+            services.settings.set("enabledModels", next_ids)
+            services.settings.save()
+        except Exception:
+            # Persistence faults must not crash the overlay.
+            pass
+    return ()
+
+
+# ---------------------------------------------------------------------------
+# theme — the colour-scheme picker with preview-before-commit
+# ---------------------------------------------------------------------------
+
+
+async def run_theme_picker(
+    app: "App[Any]",
+    payload: object | None,
+    services: OverlayServices | None,
+) -> tuple[ConsoleEvent, ...]:
+    """The colour-scheme picker flow, preview-before-commit (TS item #13).
+
+    The TS select-and-persist split into open/highlight/Enter/Esc moments
+    maps onto the framework :class:`ThemeDialog` natively (risk-1 redesign):
+
+    - **open**      — the dialog captures ``app.theme`` as the revert target
+      on its first highlight (it, not the settings file, is what was on
+      screen — better fidelity than the TS ``currentScheme`` settings read);
+    - **highlight** — the dialog sets ``app.theme`` immediately (Textual
+      themes re-skin live; only registered schemes are applied);
+    - **Enter**     — the dialog dismisses with the scheme token; *this flow*
+      persists it and returns the ``scheme:set`` event for the reducer;
+    - **Esc**       — the dialog restores the original ``app.theme`` and
+      dismisses ``None``; nothing is written, no event is returned.
+    """
+    if services is None:
+        return ()
+    token = await app.push_screen_wait(ThemeDialog(list(THEME_CHOICES)))
+    if isinstance(token, str) and is_theme_scheme(token):
+        try:
+            services.settings.set("colourScheme", token)
+            services.settings.save()
+        except Exception:
+            # Persistence faults must not crash the overlay.
+            pass
+        return (SchemeSet(scheme=token),)
+    return ()
+
+
+# ---------------------------------------------------------------------------
+# settings — the settings list
+# ---------------------------------------------------------------------------
+
+
+def build_settings_items(
+    services: OverlayServices,
+    events: list[ConsoleEvent],
+    app: "App[Any] | None" = None,
+) -> list[SettingsDialogItem]:
+    """The settings rows, mapped onto the framework :class:`SettingsDialogItem`.
+
+    Each row reads its current value from the preference store and its
+    ``on_change`` writes the chosen value back, persisting immediately.
+    Reducer-backed rows also append their event to ``events`` (the TS live
+    ``dispatch`` becomes this accumulator, folded by the App after the dialog
+    closes); the colour-scheme row additionally re-themes ``app`` live when a
+    registered scheme is chosen. Row ids, labels, descriptions, ordering and
+    the on/off vocabulary are the TS rows verbatim.
+    """
+    settings = services.settings
+
+    def on_off(flag: object) -> str:
+        return "on" if flag else "off"
+
+    def toggle_row(
+        id: str,
+        key: str,
+        label: str,
+        description: str,
+        live: ConsoleEvent | None = None,
+    ) -> SettingsDialogItem:
+        def on_change(value: str) -> None:
+            settings.set(key, value == "on")
+            settings.save()
+            if live is not None:
+                events.append(live)
+
+        return SettingsDialogItem(
+            id=id,
+            label=label,
+            description=description,
+            value=on_off(settings.get(key)),
+            values=list(TOGGLE_VALUES),
+            on_change=on_change,
+        )
+
+    def delivery_row(id: str, key: str, label: str, description: str) -> SettingsDialogItem:
+        def on_change(value: str) -> None:
+            if is_delivery_mode(value):
+                settings.set(key, value)
+                settings.save()
+
+        return SettingsDialogItem(
+            id=id,
+            label=label,
+            description=description,
+            value=str(settings.get(key)),
+            values=list(DELIVERY_MODES),
+            on_change=on_change,
+        )
+
+    def on_scheme_change(value: str) -> None:
+        settings.set("colourScheme", value)
+        settings.save()
+        if is_theme_scheme(value):
+            if app is not None and app.get_theme(value) is not None:
+                app.theme = value
+            events.append(SchemeSet(scheme=value))
+
+    def on_padding_change(value: str) -> None:
+        try:
+            parsed = int(value, 10)
+        except ValueError:
+            return
+        settings.set("editorPaddingX", parsed)
+        settings.save()
+
+    return [
+        SettingsDialogItem(
+            id="colour-scheme",
+            label="Colour scheme",
+            description="The terminal colour scheme the console renders in.",
+            value=str(settings.get("colourScheme")),
+            values=list(THEME_NAMES),
+            on_change=on_scheme_change,
+        ),
+        toggle_row(
+            "show-images",
+            "showImages",
+            "Show images",
+            "Render inline image content in the transcript.",
+            live=ToggleImages(),
+        ),
+        toggle_row(
+            "image-auto-resize",
+            "imageAutoResize",
+            "Auto-resize images",
+            "Shrink oversized images to fit before handing them to a provider.",
+        ),
+        toggle_row(
+            "block-images",
+            "blockImages",
+            "Block images",
+            "Withhold image content from providers entirely.",
+        ),
+        toggle_row(
+            "show-reasoning",
+            "showReasoning",
+            "Show reasoning",
+            "Stream the model's reasoning / thinking text as it arrives.",
+            live=ToggleReasoning(),
+        ),
+        toggle_row(
+            "skill-commands",
+            "enableSkillCommands",
+            "Skill commands",
+            "Surface discovered skills as their own slash commands.",
+        ),
+        delivery_row(
+            "steering-mode",
+            "steeringMode",
+            "Steering mode",
+            "Whether queued steering corrections release one at a time or all at once.",
+        ),
+        delivery_row(
+            "follow-up-mode",
+            "followUpMode",
+            "Follow-up mode",
+            "Whether queued follow-up prompts release one at a time or all at once.",
+        ),
+        toggle_row(
+            "auto-compact",
+            "autoCompact",
+            "Auto-compact",
+            "Condense the transcript automatically as it nears the window.",
+        ),
+        toggle_row(
+            "collapse-changelog",
+            "collapseChangelog",
+            "Collapse changelog",
+            "Prefer a condensed changelog after the console updates itself.",
+        ),
+        toggle_row(
+            "quiet-startup",
+            "quietStartup",
+            "Quiet startup",
+            "Suppress the banner and tips shown on a normal interactive launch.",
+        ),
+        toggle_row(
+            "logo-sweep",
+            "logoSweep",
+            "Logo sweep",
+            "Tint the startup wordmark and emblem along a static colour gradient.",
+        ),
+        toggle_row(
+            "reduced-motion",
+            "reducedMotion",
+            "Reduced motion",
+            "Suppress motion-flavoured flourishes such as the logo colour sweep.",
+        ),
+        toggle_row(
+            "hardware-cursor",
+            "showHardwareCursor",
+            "Hardware cursor",
+            "Reveal the terminal's own cursor instead of the software-drawn caret.",
+        ),
+        SettingsDialogItem(
+            id="editor-padding",
+            label="Editor padding",
+            description="Horizontal padding, in columns, around the prompt editor.",
+            value=str(settings.get("editorPaddingX")),
+            values=["0", "1", "2", "3"],
+            on_change=on_padding_change,
+        ),
+    ]
+
+
+async def run_settings_picker(
+    app: "App[Any]",
+    payload: object | None,
+    services: OverlayServices | None,
+) -> tuple[ConsoleEvent, ...]:
+    """The settings-list flow: build the rows, present the framework dialog
+    (Enter/Left/Right cycle a row, Esc closes), and return the reducer events
+    the row edits accumulated while the dialog was up.
+
+    A row-building fault yields no dialog at all (the TS ``catch → null``).
+    """
+    if services is None:
+        return ()
+    events: list[ConsoleEvent] = []
+    try:
+        items = build_settings_items(services, events, app)
+    except Exception:
+        return ()
+    await app.push_screen_wait(SettingsDialog(items))
+    return tuple(events)

induscode/console/overlays/router.py

@@ -0,0 +1,129 @@
+"""Overlay router — the single dispatch point for every modal overlay.
+
+Port of TS ``src/console/overlays/host.tsx`` under the dialog-API inversion
+(port plan analysis 02, risk 1). The TS ``OverlayHost`` mounted three group
+components unconditionally and routed by ``ModalState.kind``, with each
+dialog driving callback props until the host dropped the modal state. The
+Python framework dialogs are ``ModalScreen[Result]`` values, so the router
+becomes a *table of awaited flows*: :func:`open_overlay` looks the requested
+:data:`~induscode.console.contract.ModalKind` up in
+:data:`OVERLAY_HANDLERS`, awaits the matching ``push_screen_wait`` flow, and
+boxes whatever reducer events the flow accumulated into a typed
+:class:`OverlayOutcome`.
+
+The reducer stays the modal bookkeeping authority: the App dispatches
+``modal:open`` *before* awaiting :func:`open_overlay` and ``modal:close``
+after folding the outcome's events, so :class:`ConsoleState.modal` mirrors
+the screen stack exactly as the TS reducer mirrored the mounted dialog —
+one open/close pair per user-raised overlay, even for the TS flows that
+re-dispatched mid-dialog (sign-in → oauth is an awaited sub-flow now; see
+``auth.py``).
+
+``push_screen_wait`` requires an active Textual worker, so the App awaits
+:func:`open_overlay` from a worker (``app.run_worker``), never from a
+message handler directly.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Final, Mapping, TypeAlias
+
+from induscode.console.contract import ConsoleEvent, ModalKind, OverlayServices
+
+from .auth import run_oauth_flow, run_plugin, run_sign_in, run_sign_out
+from .pickers import (
+    run_model_picker,
+    run_scoped_models,
+    run_settings_picker,
+    run_theme_picker,
+)
+from .sessions import run_prior_turns, run_session_picker, run_tree_navigator
+
+if TYPE_CHECKING:
+    from textual.app import App
+
+__all__ = [
+    "OVERLAY_HANDLERS",
+    "OverlayFlow",
+    "OverlayOutcome",
+    "open_overlay",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class OverlayOutcome:
+    """What one overlay flow settles with — the typed result the App folds.
+
+    ``kind`` names the overlay that ran; ``events`` are the reducer events
+    the flow accumulated (a committed ``scheme:set``, settings ``toggle:*``
+    flips, sign-in ``status:set`` reports — never ``modal:*``, which stay the
+    App's bookkeeping around the await).
+    """
+
+    #: The modal kind this outcome settles.
+    kind: ModalKind
+    #: Reducer events to fold once the overlay has closed, oldest first.
+    events: tuple[ConsoleEvent, ...] = ()
+
+
+#: One overlay flow: push the dialog(s) for a kind, await dismissal, apply
+#: side effects, and return the reducer events to fold.
+OverlayFlow: TypeAlias = Callable[
+    ["App[Any]", object | None, OverlayServices | None],
+    Awaitable[tuple[ConsoleEvent, ...]],
+]
+
+
+async def _run_none(
+    app: "App[Any]",
+    payload: object | None,
+    services: OverlayServices | None,
+) -> tuple[ConsoleEvent, ...]:
+    """The inert ``none`` kind: nothing to raise (the TS host's
+    ``kind === "none"`` short-circuit)."""
+    return ()
+
+
+#: The closed kind → flow dispatch table (TS routed by union exhaustiveness;
+#: the key-coverage test pins this table against ``MODAL_KINDS``).
+OVERLAY_HANDLERS: Final[Mapping[ModalKind, OverlayFlow]] = {
+    "none": _run_none,
+    "settings": run_settings_picker,
+    "models": run_model_picker,
+    "scopedModels": run_scoped_models,
+    "theme": run_theme_picker,
+    "sessions": run_session_picker,
+    "tree": run_tree_navigator,
+    "userTurns": run_prior_turns,
+    "signIn": run_sign_in,
+    "signOut": run_sign_out,
+    "oauth": run_oauth_flow,
+    "plugin": run_plugin,
+}
+
+
+async def open_overlay(
+    app: "App[Any]",
+    kind: ModalKind,
+    payload: object | None = None,
+    services: OverlayServices | None = None,
+) -> OverlayOutcome:
+    """Run the overlay flow for ``kind`` and settle with its outcome.
+
+    The single entry point the App's modal plumbing awaits (from a worker —
+    ``push_screen_wait`` demands one). An unknown kind, the ``none`` kind,
+    and any kind opened without the runtime ``services`` it needs all settle
+    inert — the TS groups rendered nothing for exactly those cases.
+
+    :param app: the Textual app the dialogs are pushed onto
+    :param kind: which overlay to raise
+    :param payload: the opaque per-modal payload, narrowed by each flow
+    :param services: the runtime handles overlays drive; absent on headless
+        mount paths
+    """
+    handler = OVERLAY_HANDLERS.get(kind)
+    if handler is None:
+        return OverlayOutcome(kind=kind)
+    events = await handler(app, payload, services)
+    return OverlayOutcome(kind=kind, events=events)