induscode 0.1.0__py3-none-any.whl

induscode/settings/contract.py

@@ -0,0 +1,313 @@
+"""Settings contract — the typed surface of the user-tunable preferences an
+interactive coding-agent session reads at startup and while it runs.
+
+This module declares *only* shapes and frozen defaults — no I/O, no store, no
+filesystem. It is the single place every preference key is named, typed, and
+given a fallback. The two-tier store (:mod:`.manager`) is written against the
+:class:`Preferences` record declared here, and any console surface that
+toggles a preference reads its value through the same record.
+
+Design stance
+-------------
+- Every field is optional (``None`` plays the TS ``undefined`` "key not
+  present" role — no preference legally holds null as a real value) so a
+  partially-written file is a legal :class:`Preferences` value; the store
+  fills the gaps from :data:`DEFAULT_PREFERENCES` when a reader asks for a
+  concrete value.
+- Reasoning-effort vocabulary is borrowed from the framework
+  (``indusagi.agent.ThinkingLevel``) rather than re-declared, so the agent
+  and the UI speak the same words.
+- The other small string unions (the colour scheme is a free string, while
+  :data:`EscapeAction` / :data:`DeliveryMode` are pinned) name the surfaces a
+  console reads.
+
+Port notes (TS ``src/settings/contract.ts``)
+--------------------------------------------
+- The TS ``Preferences`` interface (23 optional camelCase keys) becomes a
+  frozen dataclass with snake_case fields. The on-disk JSON keeps the TS
+  camelCase spelling verbatim — a settings file written by the TS agent reads
+  back unchanged — and the explicit :data:`FIELD_TO_JSON_KEY` /
+  :data:`JSON_TO_FIELD_KEY` maps are the single place the two spellings are
+  tied together (no mechanical case converter to silently drift).
+- List-typed values are tuples so :data:`DEFAULT_PREFERENCES` is deeply
+  immutable and safe to share without a defensive copy (the TS record relied
+  on ``Object.freeze`` plus discipline).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, fields
+from types import MappingProxyType
+from typing import Any, Final, Literal, TypeAlias, TypeGuard, get_args
+
+from indusagi.agent import ThinkingLevel
+
+__all__ = [
+    "DEFAULT_PREFERENCES",
+    "DELIVERY_MODES",
+    "DeliveryMode",
+    "ESCAPE_ACTIONS",
+    "EscapeAction",
+    "FIELD_TO_JSON_KEY",
+    "JSON_TO_FIELD_KEY",
+    "Preferences",
+    "SETTING_KEYS",
+    "SettingKey",
+    "ThinkingLevel",
+    "canonical_key",
+    "is_delivery_mode",
+    "is_escape_action",
+]
+
+
+# ---------------------------------------------------------------------------
+# Narrow vocabularies
+# ---------------------------------------------------------------------------
+
+#: What a double-tap of the escape key does in the interactive console.
+#:
+#: - ``tree``  — open the turn history as a navigable tree of branches.
+#: - ``fork``  — open the prior-turn picker to branch off an earlier turn.
+#: - ``clear`` — wipe the composer buffer.
+#:
+#: The legacy ``rewind`` / ``branch`` aliases are still accepted and treated
+#: as ``fork`` / ``tree`` respectively, so an older preference file keeps
+#: working. They are part of the type but not of :data:`ESCAPE_ACTIONS`.
+EscapeAction: TypeAlias = Literal["tree", "fork", "clear", "rewind", "branch"]
+
+#: Every canonical :data:`EscapeAction` value (legacy aliases excluded), as a
+#: frozen tuple for menus and guards.
+ESCAPE_ACTIONS: Final[tuple[EscapeAction, ...]] = ("tree", "fork", "clear")
+
+
+def is_escape_action(value: object) -> TypeGuard[EscapeAction]:
+    """Narrow an arbitrary value to a known (canonical) :data:`EscapeAction`."""
+    return isinstance(value, str) and value in ESCAPE_ACTIONS
+
+
+#: How a queue of pending turns (steering corrections or follow-up prompts)
+#: is drained back into the run.
+#:
+#: - ``all``           — release every queued turn at once on the next handoff.
+#: - ``one-at-a-time`` — release a single queued turn per handoff.
+DeliveryMode: TypeAlias = Literal["all", "one-at-a-time"]
+
+#: Every :data:`DeliveryMode` value, as a frozen tuple for menus and guards.
+DELIVERY_MODES: Final[tuple[DeliveryMode, ...]] = ("all", "one-at-a-time")
+
+
+def is_delivery_mode(value: object) -> TypeGuard[DeliveryMode]:
+    """Narrow an arbitrary value to a known :data:`DeliveryMode`."""
+    return isinstance(value, str) and value in DELIVERY_MODES
+
+
+# ---------------------------------------------------------------------------
+# Preference record
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class Preferences:
+    """Every preference an interactive coding-agent session reads, as one
+    flat, fully-optional record.
+
+    A value of this type may be all-``None`` (a brand-new install), a sparse
+    project override, or a fully-populated snapshot — all three are legal.
+    Concrete reads always go through the store, which layers the project file
+    over the global file over :data:`DEFAULT_PREFERENCES`, so a reader never
+    sees ``None`` for a key with a default.
+    """
+
+    # Named colour scheme the console renders with (e.g. "midnight").
+    colour_scheme: str | None = None
+    # Whether inline image content is rendered in the transcript.
+    show_images: bool | None = None
+    # Whether the model's reasoning / thinking text is shown as it streams.
+    show_reasoning: bool | None = None
+    # When True, the reasoning block is folded away even if the model emits one.
+    hide_thinking: bool | None = None
+    # Whether oversized images are shrunk to fit before reaching a provider.
+    image_auto_resize: bool | None = None
+    # When True, image content is withheld from providers entirely.
+    block_images: bool | None = None
+    # Whether discovered skills are surfaced as their own slash commands.
+    enable_skill_commands: bool | None = None
+    # How queued steering corrections are released back into the run.
+    steering_mode: DeliveryMode | None = None
+    # How queued follow-up prompts are released back into the run.
+    follow_up_mode: DeliveryMode | None = None
+    # Prefer a condensed changelog after the console updates itself.
+    collapse_changelog: bool | None = None
+    # Reveal the terminal's own cursor instead of the software-drawn caret.
+    show_hardware_cursor: bool | None = None
+    # Horizontal padding, in columns, around the prompt editor.
+    editor_padding_x: int | None = None
+    # Glob / id patterns selecting picker models; empty means all.
+    enabled_models: tuple[str, ...] | None = None
+    # Provider id the session defaults to when none is named.
+    default_provider: str | None = None
+    # Model id the session opens with under ``default_provider``.
+    default_model: str | None = None
+    # Reasoning effort the session requests by default.
+    default_thinking_level: ThinkingLevel | None = None
+    # Suppress the banner / tips shown on a normal interactive launch.
+    quiet_startup: bool | None = None
+    # The last product version whose full masthead the user has already seen;
+    # the banner auto-condenses when this equals the running version.
+    last_seen_version: str | None = None
+    # Opt-in static colour-sweep flourish tinting the startup wordmark.
+    logo_sweep: bool | None = None
+    # When set, motion-flavoured flourishes (e.g. the logo sweep) are off.
+    reduced_motion: bool | None = None
+    # Whether the window-budget manager compacts the transcript automatically.
+    auto_compact: bool | None = None
+    # What a double-escape does in the console.
+    double_escape_action: EscapeAction | None = None
+    # Extension-package sources the launcher installs (npm / git / local).
+    extension_packages: tuple[str, ...] | None = None
+
+
+#: The set of legal preference keys (snake_case field names), as a Literal
+#: union — the Python analogue of the TS ``keyof Preferences``.
+SettingKey: TypeAlias = Literal[
+    "colour_scheme",
+    "show_images",
+    "show_reasoning",
+    "hide_thinking",
+    "image_auto_resize",
+    "block_images",
+    "enable_skill_commands",
+    "steering_mode",
+    "follow_up_mode",
+    "collapse_changelog",
+    "show_hardware_cursor",
+    "editor_padding_x",
+    "enabled_models",
+    "default_provider",
+    "default_model",
+    "default_thinking_level",
+    "quiet_startup",
+    "last_seen_version",
+    "logo_sweep",
+    "reduced_motion",
+    "auto_compact",
+    "double_escape_action",
+    "extension_packages",
+]
+
+#: Every preference key, as a frozen tuple for iteration and validation
+#: (derived from :data:`SettingKey` so the two can never drift).
+SETTING_KEYS: Final[tuple[str, ...]] = get_args(SettingKey)
+
+
+# ---------------------------------------------------------------------------
+# Field ↔ JSON-key alias maps
+# ---------------------------------------------------------------------------
+
+#: Explicit snake_case-field → camelCase-JSON-key map, in declaration order.
+#: The on-disk spelling is the TS one, kept verbatim; this map is the single
+#: tie between the two namings.
+FIELD_TO_JSON_KEY: Final[MappingProxyType[str, str]] = MappingProxyType(
+    {
+        "colour_scheme": "colourScheme",
+        "show_images": "showImages",
+        "show_reasoning": "showReasoning",
+        "hide_thinking": "hideThinking",
+        "image_auto_resize": "imageAutoResize",
+        "block_images": "blockImages",
+        "enable_skill_commands": "enableSkillCommands",
+        "steering_mode": "steeringMode",
+        "follow_up_mode": "followUpMode",
+        "collapse_changelog": "collapseChangelog",
+        "show_hardware_cursor": "showHardwareCursor",
+        "editor_padding_x": "editorPaddingX",
+        "enabled_models": "enabledModels",
+        "default_provider": "defaultProvider",
+        "default_model": "defaultModel",
+        "default_thinking_level": "defaultThinkingLevel",
+        "quiet_startup": "quietStartup",
+        "last_seen_version": "lastSeenVersion",
+        "logo_sweep": "logoSweep",
+        "reduced_motion": "reducedMotion",
+        "auto_compact": "autoCompact",
+        "double_escape_action": "doubleEscapeAction",
+        "extension_packages": "extensionPackages",
+    }
+)
+
+#: The reverse map: camelCase JSON key → snake_case field name.
+JSON_TO_FIELD_KEY: Final[MappingProxyType[str, str]] = MappingProxyType(
+    {json_key: field for field, json_key in FIELD_TO_JSON_KEY.items()}
+)
+
+
+def canonical_key(key: str) -> str:
+    """Normalise a preference key to its canonical snake_case field name.
+
+    Accepts either the snake_case field name (the Python surface) or the
+    camelCase JSON spelling (the on-disk surface). Raises :class:`KeyError`
+    for anything else, so a typo is a loud error rather than a silent miss.
+    """
+    if key in FIELD_TO_JSON_KEY:
+        return key
+    field = JSON_TO_FIELD_KEY.get(key)
+    if field is not None:
+        return field
+    raise KeyError(f"unknown preference key: {key!r}")
+
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+
+#: The fallback value for every preference, used whenever neither the project
+#: nor the global tier supplies a key.
+#:
+#: Frozen (and tuple-valued where the TS used arrays) so it can be shared
+#: without a defensive copy. Every field carries a concrete (non-``None``)
+#: value — the analogue of the TS ``Required<Preferences>`` — which is what
+#: lets a typed reader resolve a guaranteed result. Values are the TS
+#: fallbacks, verbatim.
+DEFAULT_PREFERENCES: Final[Preferences] = Preferences(
+    colour_scheme="default",
+    show_images=True,
+    show_reasoning=True,
+    hide_thinking=False,
+    image_auto_resize=True,
+    block_images=False,
+    enable_skill_commands=True,
+    steering_mode="all",
+    follow_up_mode="all",
+    collapse_changelog=False,
+    show_hardware_cursor=False,
+    editor_padding_x=1,
+    enabled_models=(),
+    default_provider="anthropic",
+    default_model="",
+    default_thinking_level="medium",
+    quiet_startup=False,
+    last_seen_version="",
+    logo_sweep=False,
+    reduced_motion=False,
+    auto_compact=True,
+    double_escape_action="clear",
+    extension_packages=(),
+)
+
+
+def _default_value(field: str) -> Any:
+    """The concrete default for one canonical field name."""
+    return getattr(DEFAULT_PREFERENCES, field)
+
+
+# The dataclass, the SettingKey union, and the alias map must always describe
+# the same 23-key set, and the defaults must be fully populated; assert it
+# once at import so a drift is an immediate, loud error (the Python analogue
+# of the TS `Required<Preferences>` / `keyof` constraints).
+_FIELD_NAMES = {field.name for field in fields(Preferences)}
+assert set(SETTING_KEYS) == _FIELD_NAMES, "SettingKey must match Preferences fields"
+assert set(FIELD_TO_JSON_KEY) == _FIELD_NAMES, "alias map must cover Preferences fields"
+assert len(JSON_TO_FIELD_KEY) == len(FIELD_TO_JSON_KEY), "alias map must be one-to-one"
+assert all(
+    _default_value(name) is not None for name in SETTING_KEYS
+), "DEFAULT_PREFERENCES must populate every key"

induscode/settings/manager.py

@@ -0,0 +1,268 @@
+"""Settings manager — the two-tier reader/writer over the preference record.
+
+Two files back the same :class:`~.contract.Preferences` shape:
+
+- the **global** file, one per machine, living in the resolved workspace
+  profile directory (``Workspace.settings_path`` — ``<profile_root>/settings.json``);
+- the **project** file, one per checkout, living beside the working tree in
+  the brand-named config directory (``<cwd>/.pindusagi/settings.json``).
+
+A read layers the project tier over the global tier over
+:data:`~.contract.DEFAULT_PREFERENCES`: a key set in the project file wins,
+then the global file, then the built-in default — so a reader of
+:meth:`PreferenceStore.get` always receives a concrete value. A write through
+:meth:`PreferenceStore.set` lands in the **project** tier only; the global
+file is left untouched, which keeps a per-checkout override from silently
+leaking machine-wide.
+
+Loading is tolerant: a missing file is the empty record, and a corrupt file
+(bad JSON, or a JSON value that is not an object) degrades to the empty
+record rather than raising, so one mangled file never blocks startup.
+
+Construction is injectable. :meth:`PreferenceStore.from_workspace` resolves
+the two paths from a :class:`~induscode.workspace.Workspace` and the working
+directory; :meth:`PreferenceStore.at_paths` pins both paths directly, which
+is what the tests drive against a temp dir so the real home is never read or
+written.
+
+Port notes (TS ``src/settings/manager.ts``)
+-------------------------------------------
+- The on-disk JSON keys are the TS camelCase spellings; tiers are held in
+  memory under the canonical snake_case field names and translated through
+  the contract's explicit alias maps on load and save.
+- JSON ``null`` is treated as "key not present" (the closest analogue of the
+  TS ``undefined`` hole), and clearing a staged override is done by setting
+  it to ``None`` (TS: ``undefined``).
+- Unknown JSON keys are preserved verbatim through a load → save round-trip
+  (as the TS shallow-copy semantics did), but never surface through
+  :meth:`PreferenceStore.get` / :meth:`PreferenceStore.snapshot`.
+- JSON arrays are coerced to tuples on load so tier values compare equal to
+  the tuple-valued defaults.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from ..workspace import BRAND, Workspace
+
+from .contract import (
+    DEFAULT_PREFERENCES,
+    FIELD_TO_JSON_KEY,
+    SETTING_KEYS,
+    Preferences,
+    canonical_key,
+)
+
+__all__ = [
+    "PreferenceLocations",
+    "PreferenceStore",
+]
+
+
+# ---------------------------------------------------------------------------
+# Locations
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class PreferenceLocations:
+    """The resolved location of the two preference tiers.
+
+    Both are absolute paths. Either file may be absent on disk — the store
+    treats a missing file as the empty record. (The TS record's ``global`` /
+    ``project`` member names gain a ``_path`` suffix because ``global`` is a
+    Python keyword.)
+    """
+
+    # Machine-wide preference file (the global tier).
+    global_path: Path
+    # Per-checkout preference file (the project tier).
+    project_path: Path
+
+
+# ---------------------------------------------------------------------------
+# Tolerant load / write
+# ---------------------------------------------------------------------------
+
+
+def _freeze(value: Any) -> Any:
+    """Coerce a JSON array to a tuple so tier values match the tuple-valued
+    defaults; everything else passes through unchanged."""
+    if isinstance(value, list):
+        return tuple(value)
+    return value
+
+
+def _load_tier(file_path: Path) -> dict[str, Any]:
+    """Read one preference file, degrading to the empty record on any problem.
+
+    A path that does not exist, a file that fails to parse as JSON, or a JSON
+    value that is not an object all resolve to ``{}`` — never a raise. Known
+    keys (camelCase or snake_case) are stored under their canonical
+    snake_case field name; unknown keys are kept verbatim so a save does not
+    strip them; ``null`` values are dropped (a null is "key not present").
+    """
+    try:
+        raw = file_path.read_text(encoding="utf-8")
+    except OSError:
+        return {}
+    try:
+        parsed = json.loads(raw)
+    except ValueError:
+        return {}
+    if not isinstance(parsed, dict):
+        return {}
+    tier: dict[str, Any] = {}
+    for key, value in parsed.items():
+        if value is None:
+            continue
+        try:
+            tier[canonical_key(key)] = _freeze(value)
+        except KeyError:
+            tier[key] = _freeze(value)
+    return tier
+
+
+def _write_tier(file_path: Path, tier: dict[str, Any]) -> None:
+    """Write one preference tier as pretty JSON (camelCase keys), creating
+    the parent directory if needed. Pure side effect; the caller owns the
+    in-memory tier."""
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {FIELD_TO_JSON_KEY.get(key, key): value for key, value in tier.items()}
+    file_path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# Two-tier store
+# ---------------------------------------------------------------------------
+
+
+class PreferenceStore:
+    """Two-tier preference store: project-over-global-over-default on read,
+    and a project-tier write on save.
+
+    Construct via :meth:`from_workspace` (resolve from the workspace + cwd)
+    or :meth:`at_paths` (pin both files explicitly, as the tests do).
+    Internally the two tiers are held in memory and refreshed from disk on
+    construction and on :meth:`reload`; :meth:`set` stages a change into the
+    in-memory project tier and :meth:`save` flushes it.
+    """
+
+    def __init__(self, locations: PreferenceLocations) -> None:
+        self._locations = locations
+        self._global_tier = _load_tier(locations.global_path)
+        self._project_tier = _load_tier(locations.project_path)
+
+    @classmethod
+    def at_paths(
+        cls,
+        global_path: str | os.PathLike[str],
+        project_path: str | os.PathLike[str],
+    ) -> PreferenceStore:
+        """Build a store whose two tiers are pinned to explicit paths.
+
+        The direct seam used by tests: point both files at a temp dir and the
+        real home is never touched. Neither file needs to exist yet.
+        """
+        return cls(
+            PreferenceLocations(
+                global_path=Path(global_path),
+                project_path=Path(project_path),
+            )
+        )
+
+    @classmethod
+    def from_workspace(
+        cls,
+        workspace: Workspace,
+        cwd: str | os.PathLike[str] | None = None,
+    ) -> PreferenceStore:
+        """Build a store from a resolved workspace (global tier) and a
+        working directory (project tier).
+
+        The global file is ``workspace.settings_path``; the project file is
+        ``<cwd>/<brand profile dir>/settings.json`` (``.pindusagi``), so a
+        checkout carries its own overrides next to its source. ``cwd``
+        defaults to the process working directory.
+        """
+        base = Path(cwd) if cwd is not None else Path.cwd()
+        return cls(
+            PreferenceLocations(
+                global_path=workspace.settings_path,
+                project_path=base / BRAND.profile_dir_name / "settings.json",
+            )
+        )
+
+    def paths(self) -> PreferenceLocations:
+        """The two resolved file locations this store reads and writes."""
+        return self._locations
+
+    def reload(self) -> None:
+        """Re-read both tiers from disk, discarding any unsaved staged change."""
+        self._global_tier = _load_tier(self._locations.global_path)
+        self._project_tier = _load_tier(self._locations.project_path)
+
+    def get(self, key: str) -> Any:
+        """Read one preference, resolved across the tiers.
+
+        Precedence is project → global → :data:`DEFAULT_PREFERENCES`: the
+        first tier that defines the key wins. ``key`` may be the snake_case
+        field name or the camelCase JSON spelling; an unknown key raises
+        :class:`KeyError`. The result is always a concrete value, so callers
+        never branch on ``None``.
+        """
+        field = canonical_key(key)
+        if field in self._project_tier:
+            return self._project_tier[field]
+        if field in self._global_tier:
+            return self._global_tier[field]
+        return getattr(DEFAULT_PREFERENCES, field)
+
+    def set(self, key: str, value: Any) -> None:
+        """Stage a preference into the in-memory **project** tier.
+
+        Does not write to disk on its own — call :meth:`save` to persist.
+        Setting a key to ``None`` clears the project-tier override for it,
+        letting the value fall back to the global tier or the default on the
+        next read (the TS ``undefined``-clears semantics).
+        """
+        field = canonical_key(key)
+        if value is None:
+            self._project_tier.pop(field, None)
+            return
+        self._project_tier[field] = _freeze(value)
+
+    def snapshot(self) -> Preferences:
+        """The fully-resolved snapshot: defaults under global under project."""
+        merged: dict[str, Any] = {
+            field: getattr(DEFAULT_PREFERENCES, field) for field in SETTING_KEYS
+        }
+        for tier in (self._global_tier, self._project_tier):
+            for field in SETTING_KEYS:
+                if field in tier:
+                    merged[field] = tier[field]
+        return Preferences(**merged)
+
+    def project_overrides(self) -> dict[str, Any]:
+        """The raw in-memory project tier (the keys a checkout overrides),
+        as a copy keyed by canonical field name."""
+        return dict(self._project_tier)
+
+    def global_defaults(self) -> dict[str, Any]:
+        """The raw in-memory global tier (machine-wide keys), as a copy
+        keyed by canonical field name."""
+        return dict(self._global_tier)
+
+    def save(self) -> None:
+        """Persist the staged in-memory **project** tier to its file.
+
+        Writes the project tier only; the global file is never rewritten
+        here, so a per-checkout :meth:`set` cannot mutate machine-wide
+        preferences. Creates the containing directory if it is missing.
+        """
+        _write_tier(self._locations.project_path, self._project_tier)

induscode/transcript_export/__init__.py

@@ -0,0 +1,109 @@
+"""Transcript-export subsystem — public barrel.
+
+The HTML transcript publisher and its supporting machinery: the table-driven
+SGR painter (:func:`paint_sgr`) that turns terminal-styled output into safe
+HTML spans, the :class:`ThemeBridge` that computes export colors from an
+:class:`ExportTheme` via a WCAG luminance LUT, the regenerated page-shell
+:data:`PAGE_SHELL` template with its ``{{TOKEN}}`` slots and :func:`fill`
+helper, and :func:`publish_transcript` which renders a session transcript to
+a standalone HTML document using markdown-it-py, Pygments, and the painter.
+
+Port note: the TS build rendered with ``marked`` + ``highlight.js`` and kept
+this subsystem's shared types on the briefing contract; the Python build
+renders with **markdown-it-py** + **Pygments** (license notices in the
+emitted page swapped accordingly) and owns its types locally in
+``transcript_export/contract.py`` (only :class:`BriefingFault` stays
+briefing-owned).
+
+Consumers import the publish surface from ``induscode.transcript_export``
+rather than reaching into individual modules.
+"""
+
+from .contract import (
+    FALLBACK_EXPORT_THEME,
+    SGR_INITIAL_STATE,
+    SHELL_SLOTS,
+    BriefingFault,
+    BriefingFaultKind,
+    ExportTheme,
+    ImageContent,
+    LuminanceLut,
+    MessagePart,
+    PublishEntry,
+    PublishMessage,
+    PublishOptions,
+    PublishRole,
+    Rgb,
+    SgrCommandToken,
+    SgrMutation,
+    SgrState,
+    SgrTextToken,
+    SgrToken,
+    ShellSlot,
+    TextContent,
+    ThemeBridge,
+    ThemeMode,
+    ThinkingPart,
+    ToolCallPart,
+    TranscriptPart,
+    WidgetRender,
+    briefing_fault,
+)
+from .publish import HIGHLIGHT_LICENSE, MARKDOWN_LICENSE, publish_transcript
+from .sgr import SGR_CODE_TABLE, fold_sgr, paint_sgr, tokenize_sgr
+from .template import CLIENT_SCRIPT, PAGE_SHELL, PAGE_STYLES, SlotValues, fill
+from .theme_bridge import (
+    DefaultThemeBridge,
+    build_luminance_lut,
+    create_theme_bridge,
+    format_color,
+    parse_color,
+)
+
+__all__ = [
+    "BriefingFault",
+    "BriefingFaultKind",
+    "CLIENT_SCRIPT",
+    "DefaultThemeBridge",
+    "ExportTheme",
+    "FALLBACK_EXPORT_THEME",
+    "HIGHLIGHT_LICENSE",
+    "ImageContent",
+    "LuminanceLut",
+    "MARKDOWN_LICENSE",
+    "MessagePart",
+    "PAGE_SHELL",
+    "PAGE_STYLES",
+    "PublishEntry",
+    "PublishMessage",
+    "PublishOptions",
+    "PublishRole",
+    "Rgb",
+    "SGR_CODE_TABLE",
+    "SGR_INITIAL_STATE",
+    "SHELL_SLOTS",
+    "SgrCommandToken",
+    "SgrMutation",
+    "SgrState",
+    "SgrTextToken",
+    "SgrToken",
+    "ShellSlot",
+    "SlotValues",
+    "TextContent",
+    "ThemeBridge",
+    "ThemeMode",
+    "ThinkingPart",
+    "ToolCallPart",
+    "TranscriptPart",
+    "WidgetRender",
+    "briefing_fault",
+    "build_luminance_lut",
+    "create_theme_bridge",
+    "fill",
+    "fold_sgr",
+    "format_color",
+    "paint_sgr",
+    "parse_color",
+    "publish_transcript",
+    "tokenize_sgr",
+]