induscode 0.1.0__py3-none-any.whl

induscode/console/overlays/sessions.py

@@ -0,0 +1,232 @@
+"""Session overlays — the transcript navigation dialogs.
+
+Port of TS ``src/console/overlays/sessions.tsx``. This module owns the three
+modal kinds that browse persisted or in-flight transcript state: the session
+resume/list picker (``sessions``), the transcript-tree navigator (``tree``),
+and the prior-user-turn picker (``userTurns``) used when branching or
+forking.
+
+Each flow maps the app's session vocabulary onto the framework dialog
+shapes — a :class:`~induscode.sessions.SavedSession` becomes a
+:class:`~indusagi.react_ink.SessionInfo`, a
+:class:`~induscode.sessions.BranchNode` becomes a ``SessionTreeOption``, and
+a :class:`~induscode.sessions.PriorTurn` becomes a ``UserMessageOption``.
+
+Dialog-API inversion (port plan analysis 02, risk 1): the TS bodies loaded
+their catalog/tree/turn data in ``useEffect`` and confirmed through callback
+props; here each flow awaits its data load *before* pushing the dialog,
+awaits the ``ModalScreen``'s dismissal result, and drives the matching
+conductor verb (``resume`` / ``navigate_tree`` / ``fork``) after the await.
+The session picker's mutating callbacks (deep re-list, delete, rename)
+remain callbacks — the framework :class:`~indusagi.react_ink.SessionDialog`
+invokes them mid-flight and maintains its own local list copy.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Sequence
+
+from indusagi.react_ink import (
+    SessionDialog,
+    SessionInfo,
+    SessionTreeOption,
+    TreeDialog,
+    UserMessageDialog,
+    UserMessageOption,
+)
+
+from induscode.console.contract import ConsoleEvent, OverlayServices
+
+if TYPE_CHECKING:
+    from textual.app import App
+
+    from induscode.sessions import BranchNode, PriorTurn, SavedSession
+
+__all__ = [
+    "run_prior_turns",
+    "run_session_picker",
+    "run_tree_navigator",
+    "to_session_info",
+    "to_tree_option",
+    "to_turn_option",
+]
+
+
+# ---------------------------------------------------------------------------
+# App → framework shape mappers
+# ---------------------------------------------------------------------------
+
+
+def to_session_info(row: "SavedSession") -> SessionInfo:
+    """Project a catalog row onto the framework session-info shape a picker
+    lists (the TS ``toSessionInfo``; an absent ``lastModified`` reads as 0)."""
+    last_modified = row.lastModified if row.lastModified is not None else 0
+    return SessionInfo(
+        id=row.id,
+        path=row.path,
+        name=row.name,
+        modified=datetime.fromtimestamp(last_modified / 1000.0),
+        lastModified=int(last_modified),
+        size=row.size,
+        messageCount=row.messageCount,
+        firstMessage=row.preview,
+    )
+
+
+def to_tree_option(node: "BranchNode") -> SessionTreeOption:
+    """Project a navigator row onto the framework tree-option shape."""
+    return SessionTreeOption(
+        id=node.id,
+        label=node.label,
+        depth=node.depth,
+        isLeaf=node.isLeaf,
+        isCurrent=node.isCurrent,
+    )
+
+
+def to_turn_option(turn: "PriorTurn") -> UserMessageOption:
+    """Project a fork candidate onto the framework user-message shape."""
+    return UserMessageOption(entryId=turn.entryId, text=turn.text, preview=turn.preview)
+
+
+# ---------------------------------------------------------------------------
+# sessions — the resume / list picker
+# ---------------------------------------------------------------------------
+
+
+async def run_session_picker(
+    app: "App[Any]",
+    payload: object | None,
+    services: OverlayServices | None,
+) -> tuple[ConsoleEvent, ...]:
+    """The session resume/list picker flow.
+
+    The shallow current-folder listing seeds the dialog; the all-scope toggle
+    loads the deep listing on demand. Picking a row resumes that session on
+    the conductor (faults stay silent — the conductor emits a fault signal);
+    delete/rename go through the :class:`~induscode.sessions.SessionLibrary`.
+    """
+    if services is None:
+        return ()
+
+    try:
+        rows = await services.sessions.list()
+        infos = [to_session_info(row) for row in rows]
+    except Exception:
+        infos = []
+
+    try:
+        current_path: str | None = services.sessions.path_of(
+            services.conductor.snapshot().head.sessionId
+        )
+    except Exception:
+        current_path = None
+
+    async def load_all(progress: object | None = None) -> Sequence[SessionInfo]:
+        try:
+            deep = await services.sessions.list(deep=True)
+            return [to_session_info(row) for row in deep]
+        except Exception:
+            return []
+
+    async def delete(session: SessionInfo) -> None:
+        try:
+            await services.sessions.remove(session.id)
+        except Exception:
+            # Ignore — a missing file is already gone.
+            pass
+
+    async def rename(session: SessionInfo, name: str) -> None:
+        try:
+            await services.sessions.rename(session.id, name)
+        except Exception:
+            # Ignore — collision / missing source surfaces via the unchanged list.
+            pass
+
+    chosen = await app.push_screen_wait(
+        SessionDialog(
+            current_sessions=infos,
+            current_session_path=current_path,
+            on_load_all_sessions=load_all,
+            on_delete_session=delete,
+            on_rename_session=rename,
+        )
+    )
+    if chosen is not None:
+        try:
+            await services.conductor.resume(chosen.id)
+        except Exception:
+            # Surface nothing here; the conductor emits a fault signal.
+            pass
+    return ()
+
+
+# ---------------------------------------------------------------------------
+# tree — the branch navigator
+# ---------------------------------------------------------------------------
+
+
+async def run_tree_navigator(
+    app: "App[Any]",
+    payload: object | None,
+    services: OverlayServices | None,
+) -> tuple[ConsoleEvent, ...]:
+    """The transcript-tree navigator flow for the active session: open the
+    active transcript, flatten it to depth-annotated tree options, and jump
+    the conductor's head to whichever node the user picks."""
+    if services is None:
+        return ()
+
+    items: list[SessionTreeOption] = []
+    try:
+        session_id = services.conductor.snapshot().head.sessionId
+        store = await services.sessions.open(session_id)
+        if store is not None:
+            items = [to_tree_option(node) for node in services.sessions.tree(store)]
+    except Exception:
+        items = []
+
+    node = await app.push_screen_wait(TreeDialog(items=items))
+    if node is not None and node.id is not None:
+        try:
+            await services.conductor.navigate_tree(node.id)
+        except Exception:
+            # Surface nothing here; the conductor emits a fault signal.
+            pass
+    return ()
+
+
+# ---------------------------------------------------------------------------
+# userTurns — the prior-turn fork picker
+# ---------------------------------------------------------------------------
+
+
+async def run_prior_turns(
+    app: "App[Any]",
+    payload: object | None,
+    services: OverlayServices | None,
+) -> tuple[ConsoleEvent, ...]:
+    """The prior-user-turn picker flow for the active session: list the past
+    user turns as fork candidates and fork the transcript at whichever entry
+    the user picks."""
+    if services is None:
+        return ()
+
+    items: list[UserMessageOption] = []
+    try:
+        session_id = services.conductor.snapshot().head.sessionId
+        store = await services.sessions.open(session_id)
+        if store is not None:
+            items = [to_turn_option(turn) for turn in services.sessions.prior_turns(store)]
+    except Exception:
+        items = []
+
+    turn = await app.push_screen_wait(UserMessageDialog(items=items))
+    if turn is not None:
+        try:
+            await services.conductor.fork(turn.entryId)
+        except Exception:
+            # Surface nothing here; the conductor emits a fault signal.
+            pass
+    return ()

induscode/console/reducer.py

@@ -0,0 +1,145 @@
+"""Console reducer — the single pure fold over :class:`ConsoleState`.
+
+Port of TS ``src/console/reducer.ts``. The terminal surface's UI-local state
+is reduced from one immutable :class:`~induscode.console.contract.ConsoleState`
+value, mutated only by dispatching a
+:data:`~induscode.console.contract.ConsoleEvent` into
+:func:`console_reducer`. This module is the one place those transitions live:
+it is a pure function (no Textual, no I/O, no timers) that, given a prior
+state and an event, returns a *fresh* state — it never mutates its input.
+That makes every transition unit-testable in isolation and keeps the surface
+a thin shell that only wires events in and renders the result out.
+
+The transitions fall into two families, mirroring the event grouping:
+
+- **Transcript view** (``rows:*``, ``block:append``, ``blocks:clear``)
+  appends and patches the rendered rows projected from the conductor's
+  ``SessionSignal`` stream (the surface translates each signal into a row
+  event).
+- **Overlays / status / theme / toggles / busy** flip the small UI-local
+  flags the surface reads to decide what chrome to render.
+
+Port delta (locked; analysis 02 §7): the TS composer-edit and history-recall
+families (``buffer:*``, ``caret:*``, ``history:*`` — ~40% of the TS file) are
+gone. The framework ``EditorCore`` owns the buffer, caret, and history ring,
+so the console reducer keeps only the rows/blocks/modal/status/scheme/
+toggles/busy slices.
+
+Live session data (messages, usage, model) is *not* stored here — it is read
+straight from the conductor snapshot — so this state stays purely UI-local
+and the reducer never needs to know about the agent loop.
+"""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import Any
+
+from .contract import (
+    EMPTY_CONSOLE_STATE,
+    NO_MODAL,
+    ConsoleEvent,
+    ConsoleState,
+    transition_modal,
+)
+
+__all__ = [
+    "console_reducer",
+    "init_console_state",
+]
+
+
+# ---------------------------------------------------------------------------
+# Transcript-view transitions
+# ---------------------------------------------------------------------------
+
+
+def _patch_row(state: ConsoleState, row_id: str, text: str) -> ConsoleState:
+    """Replace the text of the row matching ``row_id``.
+
+    Used to grow a streaming ``answer``/``reason`` row in place: the row
+    keeps its id (so the renderer reconciles) while its text is swapped. A
+    missing id is a no-op rather than an error — the *same* state object is
+    returned — so a late patch for a pruned row is harmless.
+    """
+    found = False
+    rows = []
+    for row in state.rows:
+        if row.id != row_id:
+            rows.append(row)
+            continue
+        found = True
+        rows.append(replace(row, text=text))
+    return replace(state, rows=tuple(rows)) if found else state
+
+
+# ---------------------------------------------------------------------------
+# The reducer
+# ---------------------------------------------------------------------------
+
+
+def console_reducer(state: ConsoleState, event: ConsoleEvent) -> ConsoleState:
+    """Fold a :data:`ConsoleEvent` into a :class:`ConsoleState`, returning a
+    fresh state.
+
+    Pure and total: every event has a defined transition, and the input state
+    is never mutated. The TS ``switch`` was compiler-exhaustive over the
+    event union; the Python port fails loud on an unknown tag and a
+    key-coverage test pins every member of ``CONSOLE_EVENT_TYPES`` to a
+    transition (cross-cutting rule 1).
+
+    :param state: the prior console state (left untouched)
+    :param event: the action to apply
+    :raises ValueError: on an event outside the :data:`ConsoleEvent` union
+    """
+    tag = event.type
+
+    # Transcript view --------------------------------------------------------
+    if tag == "rows:set":
+        return replace(state, rows=tuple(event.rows))
+    if tag == "rows:append":
+        return replace(state, rows=(*state.rows, event.row))
+    if tag == "rows:patch":
+        return _patch_row(state, event.id, event.text)
+    if tag == "block:append":
+        return replace(state, blocks=(*state.blocks, event.block))
+    if tag == "blocks:clear":
+        return state if len(state.blocks) == 0 else replace(state, blocks=())
+
+    # Overlays, status, theme, toggles, busy ---------------------------------
+    if tag == "modal:open":
+        return replace(state, modal=transition_modal(event.kind, event.payload))
+    if tag == "modal:close":
+        return replace(state, modal=NO_MODAL)
+    if tag == "status:set":
+        return replace(state, status=event.status)
+    if tag == "status:clear":
+        return state if state.status is None else replace(state, status=None)
+    if tag == "scheme:set":
+        return replace(state, scheme=event.scheme)
+    if tag == "toggle:reasoning":
+        return replace(state, show_reasoning=not state.show_reasoning)
+    if tag == "toggle:images":
+        return replace(state, show_images=not state.show_images)
+    if tag == "busy:set":
+        return replace(state, busy=event.busy)
+    if tag == "tick":
+        return replace(state, tick=state.tick + 1)
+
+    raise ValueError(f"unknown console event: {tag!r}")
+
+
+def init_console_state(**overrides: Any) -> ConsoleState:
+    """Build the initial :class:`ConsoleState` a console mounts with.
+
+    Starts from the frozen :data:`EMPTY_CONSOLE_STATE` seed and overlays any
+    caller-supplied UI preferences (scheme, the display toggles). Pure and
+    deterministic — no runtime is consulted — so the first render is stable.
+    With no overrides the shared empty constant itself is returned, matching
+    the TS identity behaviour.
+
+    :param overrides: optional UI-local preference fields to seed
+    """
+    if not overrides:
+        return EMPTY_CONSOLE_STATE
+    return replace(EMPTY_CONSOLE_STATE, **overrides)

induscode/console/resume_picker.py

@@ -0,0 +1,156 @@
+"""Startup resume picker — the ``--resume`` Textual mount.
+
+Port of the picker half of TS ``src/launch/pickers.ts``
+``defaultResumeDeps().mountPicker``. The TS flow rendered the framework
+React-Ink ``StartupSessionPicker`` on a real TTY *before* the main console
+mounted and resolved with the session the user chose. This module is the
+Python counterpart: it runs a tiny, dedicated Textual app that hosts the
+framework :class:`~indusagi.react_ink.StartupSessionPicker` modal, awaits the
+user's selection, and resolves it back to the launch layer's
+:class:`~induscode.launch.contract.ResumeRef`.
+
+Why a dedicated app rather than the in-console ``/resume`` overlay: the
+``--resume`` flag is honoured by the boot ``repl_runner`` *before* the
+:class:`~induscode.console.app.ConsoleApp` exists (the restored transcript
+must be in place from the console's first frame), so there is no running
+Textual app to ``push_screen`` onto yet. This host app exists only to show
+the one picker and exit with the choice — the same UX the TS Ink mount gave:
+the picker is shown, the user selects, and that session is the one the runner
+resumes.
+
+Shape bridge: the launch layer's ``ResumeRef`` is an
+:class:`indusagi.agent.SessionInfo`; the framework picker consumes the
+distinct (but field-compatible) :class:`indusagi.react_ink.SessionInfo`. The
+mount converts each row for display and keeps a path-keyed index so the chosen
+react-ink row is resolved back to the originating ``ResumeRef`` — exactly the
+``byPath`` round-trip the TS ``mountPicker`` performed.
+
+This module performs a real Textual mount, so the boot layer imports it
+lazily (through the injected :class:`~induscode.launch.pickers.ResumeDeps`)
+and never pays the Textual import cost on a headless / non-interactive path.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from textual.app import App, ComposeResult
+from textual.widgets import Static
+
+from indusagi.react_ink import SessionInfo as PickerSessionInfo
+from indusagi.react_ink import StartupSessionPicker
+
+from induscode.launch.contract import ResumeRef
+from induscode.launch.pickers import ResumeDeps
+
+__all__ = [
+    "StartupResumeDeps",
+    "default_startup_resume_deps",
+    "to_picker_session_info",
+]
+
+
+def to_picker_session_info(ref: ResumeRef) -> PickerSessionInfo:
+    """Project a launch-layer :class:`ResumeRef`
+    (:class:`indusagi.agent.SessionInfo`) onto the framework picker's
+    :class:`indusagi.react_ink.SessionInfo`. The two carry the same fields;
+    this copies them across so the picker renders the row exactly as the
+    in-console session dialog does."""
+    return PickerSessionInfo(
+        id=ref.id,
+        path=ref.path,
+        modified=ref.modified,
+        lastModified=ref.lastModified,
+        name=ref.name,
+        size=ref.size,
+        cwd=ref.cwd,
+        messageCount=ref.messageCount,
+        firstMessage=ref.firstMessage,
+        allMessagesText=ref.allMessagesText,
+    )
+
+
+class _StartupPickerApp(App[None]):
+    """A throwaway Textual app whose only job is to push the resume picker as
+    a modal screen, capture the chosen session, and exit. Nothing is rendered
+    on the base screen — the picker fills it."""
+
+    CSS = """
+    Screen {
+        align: center middle;
+    }
+    """
+
+    def __init__(
+        self, sessions: Sequence[PickerSessionInfo], total_count: int
+    ) -> None:
+        super().__init__()
+        self._sessions = list(sessions)
+        self._total_count = total_count
+        #: The path of the row the user chose, or ``None`` on dismissal.
+        self.chosen_path: str | None = None
+
+    def compose(self) -> ComposeResult:
+        # An empty base; the picker modal is pushed on mount.
+        yield Static("")
+
+    def on_mount(self) -> None:
+        self.push_screen(
+            StartupSessionPicker(
+                sessions=self._sessions, total_count=self._total_count
+            ),
+            self._on_picked,
+        )
+
+    def _on_picked(self, chosen: PickerSessionInfo | None) -> None:
+        """The picker dismissed — stash the choice and tear the host app
+        down so :meth:`run_async` returns control to the runner."""
+        self.chosen_path = None if chosen is None else chosen.path
+        self.exit(None)
+
+
+@dataclass(frozen=True, slots=True)
+class StartupResumeDeps:
+    """A live :class:`~induscode.launch.pickers.ResumeDeps` that mounts the
+    real Textual picker.
+
+    The TTY probe is the same one the launch default used (stdin *and* stdout
+    must be terminals); the picker mount runs the dedicated
+    :class:`_StartupPickerApp` and resolves the chosen
+    :class:`ResumeRef`. This replaces the launch layer's raising default on
+    the interactive ``--resume`` path while leaving the non-TTY
+    newest-session fast path — which never reaches ``mount_picker`` — exactly
+    as it was.
+    """
+
+    def is_interactive(self) -> bool:
+        return bool(sys.stdin.isatty() and sys.stdout.isatty())
+
+    async def mount_picker(
+        self, sessions: Sequence[ResumeRef], total_count: int
+    ) -> ResumeRef | None:
+        """Mount the framework picker over ``sessions`` and resolve with the
+        chosen row, or ``None`` when the user dismisses it.
+
+        Mirrors the TS ``mountPicker``: the picker is handed framework
+        session-info records and reports the one the user selected; the chosen
+        path is resolved back to the originating ``ResumeRef`` so the runner
+        maps it to the session id it resumes by."""
+        by_path = {ref.path: ref for ref in sessions}
+        picker_rows = [to_picker_session_info(ref) for ref in sessions]
+
+        app = _StartupPickerApp(picker_rows, total_count)
+        await app.run_async()
+
+        if app.chosen_path is None:
+            return None
+        return by_path.get(app.chosen_path)
+
+
+def default_startup_resume_deps() -> ResumeDeps:
+    """Build the live, Textual-backed :class:`ResumeDeps` the repl runner
+    injects into :func:`~induscode.launch.pickers.pick_resume_target` so the
+    interactive ``--resume`` picker actually mounts."""
+    return StartupResumeDeps()

induscode/console/slash_commands/__init__.py

@@ -0,0 +1,78 @@
+"""Slash command groups — the console's command catalog, by topic (M5 wave 1).
+
+Port of the TS ``src/console/slash/commands/`` directory plus the catalog
+assembly from ``src/console/slash/builtins.ts``. Each group is its own
+module exporting an ordered command list written against the M1
+:mod:`induscode.console_slash` framework (contracts, ``family_runner``,
+``info``/``warn``, ``HANDLED``); the assembler (:mod:`.builtins`) splices
+the groups, in order, into the catalog.
+
+Landed groups:
+
+- :mod:`.transcript` — 11 session-control verbs (``/clear`` ``/new``
+  ``/summarize-context`` ``/resume`` ``/session`` ``/branch`` ``/timeline``
+  ``/name`` ``/reload`` ``/quit`` ``/exit``).
+- :mod:`.workbench` — 7 picker/help/diagnostics verbs (``/model``
+  ``/models-for`` ``/settings`` ``/help`` ``/keys`` ``/whats-new``
+  ``/debug``). The catalog assembler calls
+  :func:`set_help_registry_provider` with the assembled registry so
+  ``/help`` lists dynamic rows too (the late-bound provider replacing the
+  TS dynamic-import cycle-breaker).
+- :mod:`.integrations` — 8 auth/bridge/I-O verbs (``/login`` ``/logout``
+  ``/mcp`` ``/memory`` ``/composio`` ``/copy`` ``/export`` ``/share``),
+  minted per console over an :class:`IntegrationsRuntime` holder.
+- :mod:`.dynamic` — the discovered ``/skill:<name>`` and
+  ``/<template-name>`` row builders.
+- :mod:`.builtins` — the explicit :func:`build_catalog` ``(cwd, home)``
+  assembly (transcript → workbench → integrations → dynamic; no import-time
+  fs scans) plus the lazily-built ``SLASH_COMMANDS`` /
+  ``DEFAULT_SLASH_REGISTRY`` defaults, re-exported lazily here.
+"""
+
+from induscode.console.slash_commands.builtins import (
+    build_catalog,
+    build_default_registry,
+    discover_dynamic_sources,
+    reset_default_registry,
+)
+from induscode.console.slash_commands.dynamic import (
+    DynamicCommandSources,
+    build_dynamic_commands,
+)
+from induscode.console.slash_commands.integrations import (
+    IntegrationsRuntime,
+    build_integration_commands,
+)
+from induscode.console.slash_commands.transcript import transcript_commands
+from induscode.console.slash_commands.workbench import (
+    HelpRegistryProvider,
+    set_help_registry_provider,
+    workbench_commands,
+)
+
+__all__ = [
+    "DEFAULT_SLASH_REGISTRY",
+    "DynamicCommandSources",
+    "HelpRegistryProvider",
+    "IntegrationsRuntime",
+    "SLASH_COMMANDS",
+    "build_catalog",
+    "build_default_registry",
+    "build_dynamic_commands",
+    "build_integration_commands",
+    "discover_dynamic_sources",
+    "reset_default_registry",
+    "set_help_registry_provider",
+    "transcript_commands",
+    "workbench_commands",
+]
+
+
+def __getattr__(name: str) -> object:
+    """Lazily re-export the default catalog/registry from :mod:`.builtins`
+    (minted on first access, never at import — plan cross-cutting rule 4)."""
+    if name in ("SLASH_COMMANDS", "DEFAULT_SLASH_REGISTRY"):
+        from induscode.console.slash_commands import builtins as _builtins
+
+        return getattr(_builtins, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")