induscode 0.1.0__py3-none-any.whl

induscode/console/startup.py

@@ -0,0 +1,434 @@
+"""Startup gathering — the pure resource/notices/changelog reader the banner
+draws.
+
+Port of TS ``src/console/startup.ts``. The interactive console opens with a
+one-shot survey of what the session has to work with: which context documents
+the agent will read, which capability cards (skills) and prompt templates
+(commands) were discovered on disk, and a count of each. This module
+*gathers* that survey and nothing else — it returns a small, render-agnostic
+:class:`StartupMap` the banner turns into a bordered panel. It performs only
+read-only filesystem probes (existence checks plus the briefing loaders) and
+holds no state; given the same disk it returns the same value, so a test can
+drive it against a temp tree.
+
+It also reads (when present) a ``CHANGELOG.md`` at the app root and folds it
+into a :class:`StartupChangelog` the banner shows on a version bump — full on
+the first sight of a new version, a one-line "updated to" note otherwise. The
+decision of *which* of those to show is the gatherer's: it is handed the
+running version and the last-seen version and reports a ``mode``, so the
+banner stays a dumb renderer.
+
+Nothing here imports Textual or Rich. The banner imports the *shapes* below
+and the surface calls :func:`gather_startup` once at mount; the two never
+share mutable state.
+
+Port note: the TS module hardcoded its brand profile directory
+(``.indusagi``); the Python build sources it from the single
+:data:`~induscode.workspace.BRAND` record (``.pindusagi``) so a rebrand edits
+one file, per the workspace contract.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from typing import Final, Literal, TypeAlias
+
+from induscode.briefing import Macro, MacroOrigin, SkillCard, SkillRoot
+from induscode.briefing import gather_skill_cards, load_macros
+from induscode.workspace import BRAND
+
+__all__ = [
+    "StartupChangelog",
+    "StartupChangelogMode",
+    "StartupInputs",
+    "StartupMap",
+    "StartupNotice",
+    "StartupNoticeKind",
+    "StartupSection",
+    "gather_changelog",
+    "gather_startup",
+]
+
+
+# ---------------------------------------------------------------------------
+# Shapes
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class StartupSection:
+    """One labelled group inside the startup map.
+
+    A section is a title, the per-entry display lines (already shortened for
+    the terminal), and the *full* count the lines were derived from — which
+    may exceed the number of lines when the renderer elides a long list. A
+    section with no entries is omitted by :func:`gather_startup` rather than
+    emitted empty.
+    """
+
+    # The group heading (e.g. ``"Context"``, ``"Skills"``).
+    title: str
+    # The display lines, one per surfaced entry, already path-shortened.
+    lines: tuple[str, ...]
+    # How many entries the section spans (>= ``len(lines)``).
+    count: int
+
+
+@dataclass(frozen=True, slots=True)
+class StartupMap:
+    """The gathered survey the banner renders as the "Startup Map" panel.
+
+    A flat ordered list of :class:`StartupSection` values. Empty when nothing
+    was found, in which case the banner renders no panel at all.
+    """
+
+    # The discovered sections, in display order.
+    sections: tuple[StartupSection, ...]
+
+
+#: The changelog survey the banner may render as a "What is new" block.
+#:
+#: - ``none``      — no changelog to show (no file, or no version change).
+#: - ``full``      — the running version is newer than last-seen *and* the
+#:   full body is worth showing; ``markdown`` carries it.
+#: - ``condensed`` — a version change with no body to expand (or the body
+#:   suppressed); only the one-line note is shown.
+StartupChangelogMode: TypeAlias = Literal["none", "full", "condensed"]
+
+
+@dataclass(frozen=True, slots=True)
+class StartupChangelog:
+    """The gathered changelog survey, with the running version it was keyed
+    to."""
+
+    # Which of the three presentations the banner should render.
+    mode: StartupChangelogMode
+    # The running product version this survey was computed against.
+    version: str
+    # The condensed changelog body (present for ``full``), markdown source.
+    markdown: str | None = None
+
+
+#: The per-line tone a startup notice carries.
+StartupNoticeKind: TypeAlias = Literal["error", "warning", "info"]
+
+
+@dataclass(frozen=True, slots=True)
+class StartupNotice:
+    """One out-of-band notice the banner renders above the wordmark region."""
+
+    # The tone the line is themed with.
+    kind: StartupNoticeKind
+    # The notice text.
+    text: str
+
+
+@dataclass(frozen=True, slots=True)
+class StartupInputs:
+    """What :func:`gather_startup` is handed to compute the survey."""
+
+    # The working directory the session is scoped to.
+    cwd: str
+    # The user's home directory (where global resources live).
+    home: str
+    # The running product version (for the changelog survey).
+    version: str
+    # The last version the user has already seen a changelog for, if any.
+    last_seen_version: str | None = None
+    # Absolute path of the app-root ``CHANGELOG.md``, if the app knows one.
+    changelog_path: str | None = None
+
+
+# ---------------------------------------------------------------------------
+# Roots
+# ---------------------------------------------------------------------------
+
+#: The brand profile directory the standard resource roots sit under
+#: (``.pindusagi``; sourced from the brand record — see the module docstring).
+_PROFILE_DIR: Final[str] = BRAND.profile_dir_name
+
+#: The context filenames the agent reads from a directory, in display order.
+_CONTEXT_FILES: Final[tuple[str, ...]] = ("AGENTS.md", "CLAUDE.md")
+
+
+def _skill_roots(cwd: str, home: str) -> list[SkillRoot]:
+    """The skill roots to scan, project before user so a project-local card
+    shadows a user-global one of the same name. Every root is optional."""
+    return [
+        SkillRoot(dir=os.path.join(cwd, _PROFILE_DIR, "skills"), origin="project"),
+        SkillRoot(dir=os.path.join(home, _PROFILE_DIR, "skills"), origin="user"),
+    ]
+
+
+@dataclass(frozen=True, slots=True)
+class _MacroRoot:
+    """One prompt-template root, with its origin tag and display label."""
+
+    dir: str
+    origin: MacroOrigin
+    label: str
+
+
+def _macro_roots(cwd: str, home: str) -> list[_MacroRoot]:
+    """The prompt-template (command) roots to scan, project before user."""
+    return [
+        _MacroRoot(
+            dir=os.path.join(cwd, _PROFILE_DIR, "commands"),
+            origin="project",
+            label="project",
+        ),
+        _MacroRoot(
+            dir=os.path.join(home, _PROFILE_DIR, "commands"),
+            origin="user",
+            label="user",
+        ),
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Path display
+# ---------------------------------------------------------------------------
+
+
+def _shorten_path(path: str, cwd: str, home: str) -> str:
+    """Shorten an absolute path for display: collapse the cwd to ``./…`` and
+    the home directory to ``~/…``, leaving anything outside both untouched."""
+    if len(cwd) > 0 and path.startswith(cwd):
+        rest = path[len(cwd) :].lstrip("/\\")
+        return f"./{rest}" if len(rest) > 0 else "."
+    if len(home) > 0 and path.startswith(home):
+        return f"~{path[len(home):]}"
+    return path
+
+
+#: The longest list a single section surfaces before the renderer elides it.
+_MAX_SECTION_LINES: Final[int] = 6
+
+
+def _cap_lines(lines: list[str]) -> list[str]:
+    """Cap a line list, replacing the overflow tail with a single "… N more"
+    marker so a section with many entries stays a few lines tall."""
+    if len(lines) <= _MAX_SECTION_LINES:
+        return list(lines)
+    head = lines[:_MAX_SECTION_LINES]
+    return [*head, f"... {len(lines) - _MAX_SECTION_LINES} more"]
+
+
+def _section(title: str, lines: list[str]) -> StartupSection | None:
+    """Build a section from a title and its raw lines, returning ``None``
+    when the group is empty (so the caller can drop it). ``count`` is the
+    full pre-cap span."""
+    filtered = [line.strip() for line in lines]
+    filtered = [line for line in filtered if len(line) > 0]
+    if len(filtered) == 0:
+        return None
+    return StartupSection(title=title, lines=tuple(_cap_lines(filtered)), count=len(filtered))
+
+
+# ---------------------------------------------------------------------------
+# Resource discovery
+# ---------------------------------------------------------------------------
+
+
+def _gather_context(cwd: str, home: str) -> list[str]:
+    """The context documents the agent reads, gathered from the cwd and the
+    home directory. Each surfaced as a shortened path; duplicates (the same
+    file resolved via two roots) are not possible since cwd and home are
+    distinct roots, but a path seen twice is de-duplicated defensively."""
+    seen: set[str] = set()
+    out: list[str] = []
+    for root in (cwd, home):
+        if len(root) == 0:
+            continue
+        for name in _CONTEXT_FILES:
+            path = os.path.join(root, name)
+            if path in seen:
+                continue
+            seen.add(path)
+            if os.path.exists(path):
+                out.append(_shorten_path(path, cwd, home))
+    return out
+
+
+def _gather_skills(cwd: str, home: str) -> list[str]:
+    """The capability cards discovered under the skill roots, each rendered
+    as its name plus shortened location. Never throws — a missing or
+    unreadable root yields nothing."""
+    cards: list[SkillCard]
+    try:
+        cards = list(gather_skill_cards(_skill_roots(cwd, home)).cards)
+    except Exception:
+        cards = []
+    return [f"{card.name}  {_shorten_path(card.location, cwd, home)}" for card in cards]
+
+
+def _gather_prompts(cwd: str, home: str) -> list[str]:
+    """The prompt templates discovered under the command roots, each rendered
+    as a slash token plus shortened source. Deduped by name across roots
+    (project wins). Never throws."""
+    lines: list[str] = []
+    claimed: set[str] = set()
+    for root in _macro_roots(cwd, home):
+        loaded: list[Macro]
+        try:
+            loaded = load_macros(root.dir, origin=root.origin, label=root.label)
+        except Exception:
+            loaded = []
+        for macro in loaded:
+            if macro.name in claimed:
+                continue
+            claimed.add(macro.name)
+            lines.append(f"/{macro.name}  {_shorten_path(macro.source, cwd, home)}")
+    return lines
+
+
+# ---------------------------------------------------------------------------
+# The survey
+# ---------------------------------------------------------------------------
+
+
+def gather_startup(inputs: StartupInputs) -> StartupMap:
+    """Gather the startup map: the context documents, skills, and prompt
+    templates the session opens with, each as a :class:`StartupSection`.
+    Empty sections are dropped, so a brand-new checkout with nothing on disk
+    yields ``StartupMap(sections=())`` and the banner renders no panel.
+
+    Pure with respect to its :class:`StartupInputs`: only read-only
+    filesystem probes, no writes, no caching.
+
+    :param inputs: the roots and version context to survey against
+    """
+    cwd, home = inputs.cwd, inputs.home
+    sections: list[StartupSection] = []
+
+    context = _section("Context", _gather_context(cwd, home))
+    if context is not None:
+        sections.append(context)
+
+    skills = _section("Skills", _gather_skills(cwd, home))
+    if skills is not None:
+        sections.append(skills)
+
+    prompts = _section("Prompts", _gather_prompts(cwd, home))
+    if prompts is not None:
+        sections.append(prompts)
+
+    return StartupMap(sections=tuple(sections))
+
+
+# ---------------------------------------------------------------------------
+# Changelog
+# ---------------------------------------------------------------------------
+
+#: One top-level release heading (``## 1.2.3`` or ``## [1.2.3] …``).
+_ENTRY_HEADING_RE: Final[re.Pattern[str]] = re.compile(r"^##\s+\[?(\d+\.\d+\.\d+)\]?")
+
+
+def _condense_changelog(markdown: str, last_seen: str | None) -> str:
+    """Condense a changelog markdown body to the entries above the last-seen
+    version.
+
+    The body is split on top-level ``## `` headings (one per release).
+    Entries are kept until the first heading whose version matches
+    ``last_seen``; that and everything older is dropped. With no last-seen
+    version, or no matching heading, the whole body is returned.
+    """
+    if last_seen is None or len(last_seen) == 0:
+        return markdown.strip()
+    kept: list[str] = []
+    for line in markdown.split("\n"):
+        heading = _ENTRY_HEADING_RE.match(line)
+        if heading is not None and heading.group(1) == last_seen:
+            break
+        kept.append(line)
+    joined = "\n".join(kept).strip()
+    return joined if len(joined) > 0 else markdown.strip()
+
+
+def _reverse_changelog_entries(markdown: str) -> str:
+    """Reorder the release entries in a changelog body so the NEWEST is last.
+
+    The condensed body arrives newest-first (matching the on-disk
+    ``CHANGELOG.md``). At startup we want the latest release rendered at the
+    BOTTOM of the "What is new" block — closest to the prompt — so this
+    splits the body on top-level ``## `` release headings, preserves any
+    leading preamble (e.g. the ``# Changelog`` title) at the top, reverses
+    the order of the release blocks, and rejoins. Each block's internal
+    content order is left untouched.
+    """
+
+    def is_entry_heading(line: str) -> bool:
+        return _ENTRY_HEADING_RE.match(line) is not None
+
+    lines = markdown.split("\n")
+    first_entry = next((i for i, line in enumerate(lines) if is_entry_heading(line)), -1)
+    if first_entry == -1:
+        return markdown.strip()
+
+    preamble = "\n".join(lines[:first_entry]).strip()
+    blocks: list[list[str]] = []
+    for line in lines[first_entry:]:
+        if is_entry_heading(line):
+            blocks.append([line])
+        elif len(blocks) > 0:
+            blocks[-1].append(line)
+    blocks.reverse()
+
+    body = "\n\n".join(
+        joined for joined in ("\n".join(block).strip() for block in blocks) if len(joined) > 0
+    )
+    return f"{preamble}\n\n{body}" if len(preamble) > 0 else body
+
+
+def gather_changelog(inputs: StartupInputs) -> StartupChangelog:
+    """Gather the changelog survey for the banner.
+
+    The presentation depends on the version delta:
+
+    - no ``CHANGELOG.md``, or the running version equals the last-seen
+      version → ``mode="none"`` (nothing shown);
+    - a version change with a non-empty condensed body → ``mode="full"`` and
+      the body in ``markdown``;
+    - a version change whose condensed body is empty → ``mode="condensed"``
+      (only the one-line "updated to" note).
+
+    When the app does not track a last-seen version (``last_seen_version``
+    absent), a present ``CHANGELOG.md`` is always surfaced condensed so the
+    note still appears.
+
+    :param inputs: the version context and optional changelog path
+    """
+    version = inputs.version
+    last_seen_version = inputs.last_seen_version
+    changelog_path = inputs.changelog_path
+
+    none = StartupChangelog(mode="none", version=version)
+
+    if changelog_path is None or not os.path.exists(changelog_path):
+        return none
+    if last_seen_version is not None and last_seen_version == version:
+        return none
+
+    try:
+        with open(changelog_path, encoding="utf-8") as handle:
+            raw = handle.read()
+    except Exception:
+        return none
+
+    condensed = _condense_changelog(raw, last_seen_version)
+    if len(condensed) == 0:
+        return StartupChangelog(mode="condensed", version=version)
+    # With no last-seen anchor we cannot tell a true bump from a first
+    # launch, so the body is surfaced condensed (one-line) rather than as a
+    # full block.
+    if last_seen_version is None:
+        return StartupChangelog(mode="condensed", version=version)
+    # Render newest-at-bottom in the startup "What is new" block (closest to
+    # the prompt), even though CHANGELOG.md is stored newest-first.
+    return StartupChangelog(
+        mode="full",
+        version=version,
+        markdown=_reverse_changelog_entries(condensed),
+    )

induscode/console/theme/__init__.py

@@ -0,0 +1,44 @@
+"""Console theme engine — public barrel.
+
+Port of TS ``src/console/theme/index.ts``. The theme engine turns the
+console's own re-derived accent ramps into the framework theme projection
+every component renders against. The pipeline is: a raw
+:class:`~induscode.console.contract.ThemePalette` (this package's own hex
+ramps) → semantic :class:`~induscode.console.contract.ThemeTokens` via
+:func:`derive_tokens` → a framework :class:`~indusagi.react_ink.ThemeBundle`
+(painter adapter + Textual Theme + Pygments style) via :func:`theme_bundle` →
+a fully resolved :class:`~induscode.console.contract.ConsoleTheme`. The four
+built-in schemes are assembled once into :data:`THEMES` and obtained through
+:func:`resolve_theme`.
+
+Consumers import from ``induscode.console.theme`` (or the ``induscode.console``
+barrel) and never reach into the individual palette/tokens/adapter/resolve
+modules.
+"""
+
+from .adapter import framework_colors, theme_adapter, theme_bundle
+from .palette import (
+    DAYLIGHT_CB_PALETTE,
+    DAYLIGHT_PALETTE,
+    MIDNIGHT_CB_PALETTE,
+    MIDNIGHT_PALETTE,
+    PALETTES,
+)
+from .resolve import THEME_SCHEMES, THEMES, resolve_theme
+from .tokens import derive_tokens, luminance
+
+__all__ = [
+    "DAYLIGHT_CB_PALETTE",
+    "DAYLIGHT_PALETTE",
+    "MIDNIGHT_CB_PALETTE",
+    "MIDNIGHT_PALETTE",
+    "PALETTES",
+    "THEMES",
+    "THEME_SCHEMES",
+    "derive_tokens",
+    "framework_colors",
+    "luminance",
+    "resolve_theme",
+    "theme_adapter",
+    "theme_bundle",
+]

induscode/console/theme/adapter.py

@@ -0,0 +1,168 @@
+"""Theme adapter binding — the single boundary where the console's semantic
+tokens become concrete terminal colours.
+
+Port of TS ``src/console/theme/adapter.ts``. The framework renders colour
+through a :class:`~indusagi.react_ink.ThemeAdapter` (TS-name alias
+``InkThemeAdapter``): a flat ``colors`` mapping plus Rich-backed
+``color(key, text)`` / ``background(key, …)`` / ``dim`` / ``muted`` painters,
+all produced by ``create_theme_adapter(name, colors)``. The framework
+components look colours up by *their* key vocabulary (``accent``, ``error``,
+``success``, ``warning``, ``borderMuted``, ``bashBorder``, ``userMessage``,
+``customMessage``, ``text``, ``dim``, ``muted``). This module is the one
+place those framework keys are populated — each from a console
+:class:`~induscode.console.contract.ThemeTokens` role — so the rest of the
+console never speaks the framework's key names and the framework never sees a
+console role name. The key strings are kept VERBATIM from TS (camelCase):
+they are the framework's wire vocabulary, not Python identifiers.
+
+Port delta (locked; analysis 02 §5): the Python boundary call is
+``create_theme_bundle``, which yields the adapter **plus** a
+``textual.theme.Theme`` (every key/role as a CSS variable like
+``$user-message`` / ``$diff-added-bg``) and a Pygments style — so registering
+the four schemes as Textual Themes gives live preview-before-commit for free.
+:func:`theme_adapter` is kept for parity (the TS boundary) and for tests that
+only need the painter surface.
+"""
+
+from __future__ import annotations
+
+from indusagi.react_ink import (
+    InkThemeAdapter,
+    ThemeBundle,
+    create_theme_adapter,
+    create_theme_bundle,
+)
+
+from ..contract import ThemeTokens
+
+__all__ = [
+    "framework_colors",
+    "theme_adapter",
+    "theme_bundle",
+]
+
+
+# ---------------------------------------------------------------------------
+# Framework colour-key projection
+# ---------------------------------------------------------------------------
+
+
+def framework_colors(tokens: ThemeTokens) -> dict[str, str]:
+    """Project the console's semantic tokens onto the framework's colour-key
+    mapping.
+
+    The keys here are the framework's own (the names its react-ink components
+    pass to ``theme.color(...)`` / ``theme.background(...)``), each filled
+    from a console role. The framework's ``create_theme_adapter`` falls back
+    gracefully for any key it asks for that is absent, but we populate every
+    key the shipped components are known to request so nothing degrades to a
+    default grey.
+
+    .. code-block:: text
+
+        framework key   ← console role
+        --------------    ------------------------------------------------
+        text            ← body_text      (default foreground / fallback)
+        dim             ← muted_text     (the adapter's dim() source)
+        muted           ← muted_text     (the adapter's muted() source)
+        accent          ← signal         (primary accent highlight)
+        borderMuted     ← quiet_frame    (de-emphasised borders/separators)
+        bashBorder      ← frame          (the bash-block border tone)
+        userMessage     ← prompt_surface (user-turn background tint)
+        customMessage   ← card_accent    (custom/plugin message tint)
+        success         ← affirm
+        warning         ← caution
+        error           ← alarm
+        info            ← notice         (informational status tone)
+        highlight       ← ink_text       (high-contrast on-accent text)
+
+    Plus the markdown / diff / syntax-highlight role keys the framework's
+    rich render path (``theme.role(...)`` / ``theme.role_background(...)``)
+    resolves. These key names match the framework adapter's default
+    role → key map exactly (``DEFAULT_ROLE_KEYS``), so the styled transcript,
+    colored diffs, and fenced-code highlighting resolve their colours
+    straight from the console's derived tokens:
+
+    .. code-block:: text
+
+        codeInline      ← code_inline       (inline code foreground)
+        heading         ← heading           (markdown heading foreground)
+        blockquoteBar   ← blockquote_bar    (dim quote bar)
+        diffAddedBg     ← diff_added_bg     (added-line background tint)
+        diffRemovedBg   ← diff_removed_bg   (removed-line background tint)
+        diffAddedText   ← diff_added_text   (added foreground / ``+``)
+        diffRemovedText ← diff_removed_text (removed foreground / ``-``)
+        synKeyword      ← syn_keyword       (syntax: keywords)
+        synString       ← syn_string        (syntax: strings)
+        synNumber       ← syn_number        (syntax: numbers)
+        synComment      ← syn_comment       (syntax: comments)
+        synType         ← syn_type          (syntax: types / classes)
+
+    :param tokens: the derived semantic token map for a scheme
+    :returns: a flat colour mapping keyed by the framework's vocabulary
+    """
+    return {
+        "text": tokens.body_text,
+        "dim": tokens.muted_text,
+        "muted": tokens.muted_text,
+        "accent": tokens.signal,
+        "borderMuted": tokens.quiet_frame,
+        "bashBorder": tokens.frame,
+        "userMessage": tokens.prompt_surface,
+        "customMessage": tokens.card_accent,
+        "success": tokens.affirm,
+        "warning": tokens.caution,
+        "error": tokens.alarm,
+        "info": tokens.notice,
+        "highlight": tokens.ink_text,
+        # Rich-render role keys (match the framework adapter's default role
+        # map).
+        "codeInline": tokens.code_inline,
+        "heading": tokens.heading,
+        "blockquoteBar": tokens.blockquote_bar,
+        "diffAddedBg": tokens.diff_added_bg,
+        "diffRemovedBg": tokens.diff_removed_bg,
+        "diffAddedText": tokens.diff_added_text,
+        "diffRemovedText": tokens.diff_removed_text,
+        "synKeyword": tokens.syn_keyword,
+        "synString": tokens.syn_string,
+        "synNumber": tokens.syn_number,
+        "synComment": tokens.syn_comment,
+        "synType": tokens.syn_type,
+    }
+
+
+def theme_adapter(scheme_name: str, tokens: ThemeTokens) -> InkThemeAdapter:
+    """Build the framework :class:`~indusagi.react_ink.InkThemeAdapter` for a
+    scheme from its tokens.
+
+    The TS boundary call: derive the framework colour mapping from the
+    console's semantic tokens, then hand it to ``create_theme_adapter`` under
+    the scheme's name. The full Python boundary is :func:`theme_bundle`,
+    which wraps this same projection.
+
+    :param scheme_name: the scheme identity, used as the adapter's ``name``
+    :param tokens: the derived semantic token map for that scheme
+    :returns: the Rich-backed framework adapter
+    """
+    return create_theme_adapter(scheme_name, framework_colors(tokens))
+
+
+def theme_bundle(scheme_name: str, tokens: ThemeTokens, *, dark: bool = True) -> ThemeBundle:
+    """Build the full framework :class:`~indusagi.react_ink.ThemeBundle` for a
+    scheme from its tokens.
+
+    The Python boundary call (port delta; module docstring): one projection
+    of the tokens through :func:`framework_colors`, handed to
+    ``create_theme_bundle`` — yielding the painter adapter, the registrable
+    ``textual.theme.Theme`` (CSS variables per key/role), and the Pygments
+    style for fenced-code highlighting. This is the *only* place
+    ``create_theme_bundle`` is invoked for a console theme.
+
+    :param scheme_name: the scheme identity, used as the bundle's ``name``
+    :param tokens: the derived semantic token map for that scheme
+    :param dark: whether the scheme targets a dark terminal (Textual's
+        light/dark axis)
+    :returns: adapter + Textual Theme + Pygments style for the scheme
+    """
+    return create_theme_bundle(scheme_name, framework_colors(tokens), dark=dark)