induscode 0.1.0__py3-none-any.whl

induscode/console/components/__init__.py

@@ -0,0 +1,62 @@
+"""Console chrome widgets (M5 wave 2) — the masthead and bottom strip.
+
+Port of TS ``src/console/components`` (minus the root surface, which lands
+with the wave-3 ``ConsoleApp``). Everything here is purely presentational:
+Static/container widgets rendering prebuilt Rich ``Text`` through the
+framework :class:`~indusagi.react_ink.ThemeAdapter`, plus the pure
+colour-sweep / welcome-line maths they share with the tests.
+
+- :mod:`.banner` — :class:`Banner`, the masthead: block-figlet "INDUS CODE"
+  wordmark beside the two-tone emblem, brand/version + welcome lines, the
+  bordered Session and Startup Map panels, the changelog block (rendered via
+  the framework's ``build_changelog_text``), quiet/compact condensed modes,
+  and the optional *frozen* colour-sweep (static gradient — no animation
+  loop, reduced-motion safe by construction).
+- :mod:`.emblem` — :class:`Emblem`, the two-tone block monogram (box-quadrant
+  fill/shadow rows; ``chalk.hex`` spans become ``rich.style.Style`` colours).
+- :mod:`.banner_sweep` — the pure helpers: :func:`welcome_line` and the
+  :func:`row_gradient` hex-lerp, ported verbatim.
+- :mod:`.status_bar` — :class:`StatusBar`, the thin Vertical composing the
+  framework ``StatusLine`` + ``Footer`` strips.
+
+Deleted on port — ``Composer.tsx`` (analysis 02 §7): the TS prompt row with
+its software caret and inline suggestion window is NOT ported. The framework
+``PromptEditor`` (with the console's ``input`` autocomplete providers feeding
+its suggestion overlay) replaces the whole file; the wave-3 ``ConsoleApp``
+wires it. Nothing in this package renders an input row.
+"""
+
+from .banner import (
+    BRAND,
+    WORDMARK_ROWS,
+    Banner,
+    build_banner_text,
+    emblem_sweep_colors,
+    wordmark_lines,
+)
+from .banner_sweep import row_gradient, welcome_line
+from .emblem import (
+    EMBLEM_HEIGHT,
+    Emblem,
+    build_emblem_text,
+    emblem_row_texts,
+    paint_hex,
+)
+from .status_bar import StatusBar
+
+__all__ = [
+    "BRAND",
+    "Banner",
+    "EMBLEM_HEIGHT",
+    "Emblem",
+    "StatusBar",
+    "WORDMARK_ROWS",
+    "build_banner_text",
+    "build_emblem_text",
+    "emblem_row_texts",
+    "emblem_sweep_colors",
+    "paint_hex",
+    "row_gradient",
+    "welcome_line",
+    "wordmark_lines",
+]

induscode/console/components/banner.py

@@ -0,0 +1,499 @@
+"""Banner — the masthead the console renders above the transcript.
+
+Port of TS ``src/console/components/Banner.tsx``. The startup chrome the
+surface mounts once at the top of a session: an original block-letter
+wordmark rendered in the box-drawing palette and tinted with the accent
+role, a version + brand line beneath it, the personalized welcome line, a
+compact bordered "Session" panel of at-a-glance facts (the bound model id and
+the working directory), the bordered "Startup Map" of gathered resources,
+and the "What is new" changelog block on a version bump. It reads nothing
+but its inputs, holds no state beyond them, and runs no effects — purely
+presentational, themed through the framework
+:class:`~indusagi.react_ink.ThemeAdapter`.
+
+The wordmark is the "INDUS CODE" brand masthead rendered in the ANSI-Shadow
+block-figlet style from the ``█ ║ ═ ╔ ╗ ╚ ╝`` box-drawing family — the same
+masthead the shipped console shows, so both surfaces share one identity. The
+glyph rows are plain data tinted with the accent role at render time.
+
+Port shape (analysis 02 §7): the Ink component tree (``Wordmark`` /
+``WelcomeLine`` / ``SessionFact`` / ``StartupNotices`` / ``StartupMapPanel``
+/ ``StartupChangelogBlock``) becomes pure builders assembling one
+:class:`rich.text.Text`, rendered by a single :class:`~textual.widgets
+.Static`. Ink's round-bordered boxes become hand-drawn ``╭─╮│╰─╯`` frames in
+the accent tone; the changelog block reuses the framework's
+``build_changelog_text`` (the exact renderer behind the framework
+``ChangelogBlock`` widget); ``chalk.hex`` becomes ``rich.style.Style
+(color=…)`` via :func:`~.emblem.paint_hex`.
+
+The optional colour-sweep is STATIC, exactly as in TS: :func:`row_gradient`
+takes no clock and the gradient is laid down in the one render pass — no
+animation loop exists to suppress, which is what makes it reduced-motion
+safe. The caller resolves the on/off decision (reduced-motion / non-TTY);
+``sweep`` here is simply that resolved flag.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Final, Literal, Sequence
+
+from rich.cells import cell_len
+from rich.console import RenderableType
+from rich.text import Text
+from textual.reactive import reactive
+from textual.widgets import Static
+
+from indusagi.react_ink import build_changelog_text
+
+from ..startup import StartupChangelog, StartupMap, StartupNotice
+from .banner_sweep import row_gradient, welcome_line
+from .emblem import EMBLEM_HEIGHT, emblem_row_texts, paint_hex
+
+if TYPE_CHECKING:
+    from indusagi.react_ink import InkThemeAdapter
+
+__all__ = [
+    "BRAND",
+    "Banner",
+    "WORDMARK_ROWS",
+    "build_banner_text",
+    "emblem_sweep_colors",
+    "wordmark_lines",
+]
+
+
+#: The human-readable product label shown on the version line.
+#:
+#: parity: kept verbatim from the TS Banner, which hardcodes its own masthead
+#: label rather than reading the workspace brand record.
+BRAND: Final[str] = "indus console"
+
+#: The compact emblem glyph drawn inline on the condensed one-liner header.
+_COMPACT_EMBLEM: Final[str] = "▛▜▙▟"
+
+#: The block-letter brand wordmark, one string per terminal row.
+#:
+#: The product name "INDUS CODE" laid out in the ANSI-Shadow block-figlet
+#: style from the ``█ ║ ═ ╔ ╗ ╚ ╝`` box-drawing family. Every row is the same
+#: display width so the capitals stack into a clean masthead; the render
+#: tints the whole block with the accent role.
+WORDMARK_ROWS: Final[tuple[str, ...]] = (
+    "██╗███╗   ██╗██████╗ ██╗   ██╗███████╗     ██████╗ ██████╗ ██████╗ ███████╗",
+    "██║████╗  ██║██╔══██╗██║   ██║██╔════╝    ██╔════╝██╔═══██╗██╔══██╗██╔════╝",
+    "██║██╔██╗ ██║██║  ██║██║   ██║███████╗    ██║     ██║   ██║██║  ██║█████╗  ",
+    "██║██║╚██╗██║██║  ██║██║   ██║╚════██║    ██║     ██║   ██║██║  ██║██╔══╝  ",
+    "██║██║ ╚████║██████╔╝╚██████╔╝███████║    ╚██████╗╚██████╔╝██████╔╝███████╗",
+    "╚═╝╚═╝  ╚═══╝╚═════╝  ╚═════╝ ╚══════╝     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝",
+)
+
+#: The sweep-endpoint fallbacks the TS source used when a scheme leaves the
+#: accent / secondary-accent keys unset.
+_PRIMARY_FALLBACK: Final[str] = "#3ad6b4"
+_SECONDARY_FALLBACK: Final[str] = "#f0a24b"
+
+
+# ---------------------------------------------------------------------------
+# Sweep endpoints
+# ---------------------------------------------------------------------------
+
+
+def _sweep_endpoints(theme: InkThemeAdapter) -> tuple[str, str]:
+    """The primary→secondary hex pair the frozen gradient lerps between."""
+    primary = theme.colors.get("accent") or _PRIMARY_FALLBACK
+    secondary = theme.colors.get("customMessage") or theme.colors.get("accent") or _SECONDARY_FALLBACK
+    return primary, secondary
+
+
+def emblem_sweep_colors(theme: InkThemeAdapter, sweep: bool) -> tuple[str, ...] | None:
+    """The emblem-glyph computed gradient row colours for the colour-sweep,
+    or ``None`` when the sweep is off (the emblem keeps its flat accent
+    fill).
+
+    The emblem is :data:`~.emblem.EMBLEM_HEIGHT` rows tall; each is coloured
+    over the same primary→secondary lerp so the mark and the wordmark share
+    one gradient.
+    """
+    if not sweep:
+        return None
+    primary, secondary = _sweep_endpoints(theme)
+    return tuple(
+        row_gradient(i, EMBLEM_HEIGHT, primary, secondary) for i in range(EMBLEM_HEIGHT)
+    )
+
+
+# ---------------------------------------------------------------------------
+# Pure piece builders (the TS sub-components, as Text producers)
+# ---------------------------------------------------------------------------
+
+
+def wordmark_lines(theme: InkThemeAdapter, sweep: bool = False) -> tuple[Text, ...]:
+    """The block-letter wordmark, optionally tinted with the frozen
+    colour-sweep — one ``Text`` per glyph row.
+
+    With ``sweep`` off (the default) every row is the flat accent role. With
+    it on, row ``i`` is painted with :func:`row_gradient`'s frozen lerp
+    between the accent (primary) and ``customMessage`` (secondary) palette
+    hues — a single render pass, no timer.
+    """
+    rows = len(WORDMARK_ROWS)
+    primary, secondary = _sweep_endpoints(theme)
+    out: list[Text] = []
+    for index, line in enumerate(WORDMARK_ROWS):
+        if sweep:
+            out.append(paint_hex(row_gradient(index, rows, primary, secondary), line))
+        else:
+            out.append(theme.color("accent", line))
+    return tuple(out)
+
+
+def _notice_lines(theme: InkThemeAdapter, notices: Sequence[StartupNotice]) -> list[Text]:
+    """The notices region: one themed line per gathered startup notice, drawn
+    above the wordmark, plus the trailing blank (Ink ``marginBottom={1}``).
+    Empty when there are no notices."""
+    if len(notices) == 0:
+        return []
+    lines: list[Text] = []
+    for notice in notices:
+        if notice.kind == "error":
+            lines.append(theme.color("error", notice.text))
+        elif notice.kind == "warning":
+            lines.append(theme.color("warning", notice.text))
+        else:
+            lines.append(theme.muted(notice.text))
+    lines.append(Text(""))
+    return lines
+
+
+def _welcome_text(
+    theme: InkThemeAdapter,
+    name: str | None,
+    tone: Literal["accent", "muted"] = "accent",
+) -> Text:
+    """The personalized welcome line, themed in the given tone with the name
+    in bold."""
+
+    def paint(text: str) -> Text:
+        return theme.muted(text) if tone == "muted" else theme.color("accent", text)
+
+    line = welcome_line(name)
+    # Split out the name so it can be bolded between the framing words; the
+    # formatter guarantees the "Welcome back, {name}!" / "Welcome back!"
+    # shapes.
+    if name is not None and line != "Welcome back!":
+        out = Text()
+        out.append_text(paint("Welcome back, "))
+        out.append(name.strip(), style="bold")
+        out.append_text(paint("!"))
+        return out
+    return paint(line)
+
+
+def _space_between(left: Text, right: Text, width: int) -> Text:
+    """Lay ``left`` and ``right`` on one row with the slack between them —
+    Ink's ``justifyContent="space-between"`` for a fixed-width panel row."""
+    gap = max(1, width - left.cell_len - right.cell_len)
+    out = Text()
+    out.append_text(left)
+    out.append(" " * gap)
+    out.append_text(right)
+    return out
+
+
+def _panel_lines(
+    theme: InkThemeAdapter,
+    content: Sequence[Text],
+    columns: int,
+) -> list[Text]:
+    """Frame ``content`` rows in a round accent border with one cell of
+    horizontal padding — Ink's ``borderStyle="round"`` ``borderColor=accent``
+    ``paddingX={1}`` box, drawn by hand into text rows."""
+    inner = max(10, columns - 4)
+    border = theme.color_style("accent")
+    lines: list[Text] = [Text("╭" + "─" * (inner + 2) + "╮", style=border)]
+    for row in content:
+        clipped = row.copy()
+        clipped.truncate(inner, overflow="ellipsis", pad=True)
+        line = Text()
+        line.append("│ ", style=border)
+        line.append_text(clipped)
+        line.append(" │", style=border)
+        lines.append(line)
+    lines.append(Text("╰" + "─" * (inner + 2) + "╯", style=border))
+    return lines
+
+
+def _session_fact(theme: InkThemeAdapter, label: str, value: str) -> Text:
+    """One labelled row inside the Session panel: a dim caption and its
+    value."""
+    out = Text()
+    out.append_text(theme.dim(f"{label:<7} "))
+    out.append_text(theme.muted(value))
+    return out
+
+
+def _session_panel_lines(
+    theme: InkThemeAdapter,
+    model_id: str,
+    workspace: str,
+    verbose: bool,
+    columns: int,
+) -> list[Text]:
+    """The bordered Session panel: the at-a-glance facts of the session."""
+    rows: list[Text] = [
+        theme.color("accent", "Session"),
+        _session_fact(theme, "model", model_id),
+        _session_fact(theme, "cwd", workspace),
+    ]
+    if verbose:
+        rows.append(_session_fact(theme, "mode", "verbose diagnostics on"))
+    return _panel_lines(theme, rows, columns)
+
+
+def _startup_map_lines(
+    theme: InkThemeAdapter,
+    startup: StartupMap,
+    columns: int,
+) -> list[Text]:
+    """The Startup Map panel: a bordered list of the gathered session
+    resources, one titled group per section with its entry lines indented
+    beneath it. Empty when the map has no sections."""
+    if len(startup.sections) == 0:
+        return []
+    inner = max(10, columns - 4)
+    total = sum(section.count for section in startup.sections)
+    plural = "" if total == 1 else "s"
+    rows: list[Text] = [
+        _space_between(
+            theme.color("accent", "Startup Map"),
+            theme.dim(f"{total} item{plural}"),
+            inner,
+        )
+    ]
+    for section in startup.sections:
+        rows.append(Text(""))  # Ink marginTop={1} per section group.
+        rows.append(
+            _space_between(theme.muted(section.title), theme.dim(str(section.count)), inner)
+        )
+        for line in section.lines:
+            entry = Text("  ")  # Ink paddingLeft={2}.
+            entry.append_text(theme.dim("› "))
+            entry.append_text(theme.muted(line))
+            rows.append(entry)
+    return _panel_lines(theme, rows, columns)
+
+
+def _changelog_lines(
+    theme: InkThemeAdapter,
+    changelog: StartupChangelog,
+    columns: int,
+) -> list[Text]:
+    """The changelog region. On a full survey it renders the framework
+    changelog block (the exact ``ChangelogBlock`` renderable); on a condensed
+    survey a single "updated to" line preceded by its ``marginTop`` blank;
+    otherwise nothing."""
+    if changelog.mode == "full" and changelog.markdown is not None:
+        return [build_changelog_text("What is new", changelog.markdown, theme, columns)]
+    if changelog.mode == "condensed":
+        line = Text()
+        line.append_text(theme.muted(f"Updated to v{changelog.version}. Use "))
+        line.append_text(theme.color("accent", "/changelog"))
+        line.append_text(theme.muted(" to view the full changelog."))
+        return [Text(""), line]
+    return []
+
+
+# ---------------------------------------------------------------------------
+# The assembled masthead
+# ---------------------------------------------------------------------------
+
+
+def build_banner_text(
+    theme: InkThemeAdapter,
+    *,
+    model_id: str,
+    workspace: str,
+    version: str,
+    verbose: bool = False,
+    quiet: bool = False,
+    compact: bool = False,
+    account: str | None = None,
+    sweep: bool = False,
+    startup: StartupMap | None = None,
+    notices: Sequence[StartupNotice] | None = None,
+    changelog: StartupChangelog | None = None,
+    columns: int = 80,
+) -> Text:
+    """Assemble the console masthead as one prebuilt Rich ``Text``.
+
+    In the default (loud) mode this is the two-tone emblem beside the
+    block-letter wordmark, the brand / version line, the personalized welcome
+    line, the optional notices region, the bordered Session and Startup Map
+    panels, and the changelog block. The ``quiet`` or ``compact`` flags
+    collapse all of that to a single compact header line (emblem glyph +
+    brand + version + model), still carrying the welcome line, the notices,
+    and the changelog so nothing important is silently dropped — ``compact``
+    keeps the inline emblem glyph (the repeat-launch presentation), ``quiet``
+    is the legacy strip.
+
+    :param theme: the framework adapter that turns roles into colours
+    :param model_id: canonical id of the model bound to the session
+    :param workspace: working directory the session is scoped to
+    :param version: the product version shown on the brand line
+    :param verbose: whether to render the extra diagnostics fact
+    :param quiet: suppress the big wordmark + panels (manual toggle)
+    :param compact: auto-condensed repeat-launch one-liner
+    :param account: the signed-in account label for the welcome line (the TS
+        ``name`` prop; renamed — ``name`` is the Textual widget identity)
+    :param sweep: the resolved static colour-sweep on/off decision
+    :param startup: the gathered session resources (the Startup Map panel)
+    :param notices: out-of-band lines drawn above the wordmark
+    :param changelog: the changelog survey shown on a version bump
+    :param columns: the laid-out width panels and dividers size against
+    """
+    notice_list = tuple(notices) if notices is not None else ()
+    lines: list[Text] = list(_notice_lines(theme, notice_list))
+
+    # The condensed one-liner: the manual quiet toggle *or* an auto-condensed
+    # repeat launch. Both collapse to the same compact header.
+    if quiet or compact:
+        header = Text()
+        if compact:
+            header.append_text(theme.color("accent", _COMPACT_EMBLEM[:2]))
+            header.append_text(theme.color("customMessage", _COMPACT_EMBLEM[2:]))
+            header.append("  ")
+        brand = theme.color("accent", BRAND)
+        brand.stylize("bold")
+        header.append_text(brand)
+        header.append("  ")
+        header.append_text(theme.muted(f"v{version}"))
+        header.append("  ")
+        header.append_text(theme.dim(model_id))
+        lines.append(header)
+        lines.append(_welcome_text(theme, account, tone="muted"))
+        if changelog is not None:
+            lines.extend(_changelog_lines(theme, changelog, columns))
+        return Text("\n").join(lines)
+
+    # Emblem beside wordmark: both blocks are the same height, so each
+    # terminal row is `emblem row + two spaces + wordmark row` (the Ink row
+    # Box of two columns).
+    emblem_rows = emblem_row_texts(theme, emblem_sweep_colors(theme, sweep))
+    wordmark_rows = wordmark_lines(theme, sweep)
+    for emblem_row, wordmark_row in zip(emblem_rows, wordmark_rows):
+        row = Text()
+        row.append_text(emblem_row)
+        row.append("  ")
+        row.append_text(wordmark_row)
+        lines.append(row)
+
+    # Brand / version line + welcome line (Ink marginTop={1} block).
+    lines.append(Text(""))
+    brand_line = Text()
+    brand = theme.color("accent", BRAND)
+    brand.stylize("bold")
+    brand_line.append_text(brand)
+    brand_line.append("  ")
+    brand_line.append_text(theme.muted(f"v{version}"))
+    lines.append(brand_line)
+    lines.append(_welcome_text(theme, account, tone="accent"))
+
+    # Session panel (marginTop={1}).
+    lines.append(Text(""))
+    lines.extend(_session_panel_lines(theme, model_id, workspace, verbose, columns))
+
+    # Startup Map panel (marginTop={1}; omitted when the map is empty).
+    if startup is not None and len(startup.sections) > 0:
+        lines.append(Text(""))
+        lines.extend(_startup_map_lines(theme, startup, columns))
+
+    if changelog is not None:
+        lines.extend(_changelog_lines(theme, changelog, columns))
+
+    return Text("\n").join(lines)
+
+
+class Banner(Static):
+    """The console masthead as one persistent ``Static``.
+
+    All inputs are reactive so the surface can re-skin the banner on a scheme
+    switch (live theme preview) or late-arriving startup data; the widget
+    re-renders its prebuilt ``Text`` in place. The Ink root's
+    ``marginBottom={1}`` becomes widget margin.
+    """
+
+    DEFAULT_CSS = """
+    Banner {
+        width: 1fr;
+        height: auto;
+    }
+    """
+
+    theme: reactive[InkThemeAdapter | None] = reactive(None, layout=True)
+    model_id: reactive[str] = reactive("", layout=True)
+    workspace: reactive[str] = reactive("", layout=True)
+    version: reactive[str] = reactive("", layout=True)
+    verbose: reactive[bool] = reactive(False, layout=True)
+    quiet: reactive[bool] = reactive(False, layout=True)
+    compact: reactive[bool] = reactive(False, layout=True)
+    account: reactive[str | None] = reactive(None, layout=True)
+    sweep: reactive[bool] = reactive(False, layout=True)
+    startup: reactive[StartupMap | None] = reactive(None, layout=True)
+    notices: reactive[tuple[StartupNotice, ...]] = reactive((), layout=True)
+    changelog: reactive[StartupChangelog | None] = reactive(None, layout=True)
+
+    def __init__(
+        self,
+        theme: InkThemeAdapter,
+        *,
+        model_id: str,
+        workspace: str,
+        version: str,
+        verbose: bool = False,
+        quiet: bool = False,
+        compact: bool = False,
+        account: str | None = None,
+        sweep: bool = False,
+        startup: StartupMap | None = None,
+        notices: Sequence[StartupNotice] | None = None,
+        changelog: StartupChangelog | None = None,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+        disabled: bool = False,
+    ) -> None:
+        super().__init__("", name=name, id=id, classes=classes, disabled=disabled)
+        self.set_reactive(Banner.theme, theme)
+        self.set_reactive(Banner.model_id, model_id)
+        self.set_reactive(Banner.workspace, workspace)
+        self.set_reactive(Banner.version, version)
+        self.set_reactive(Banner.verbose, verbose)
+        self.set_reactive(Banner.quiet, quiet)
+        self.set_reactive(Banner.compact, compact)
+        self.set_reactive(Banner.account, account)
+        self.set_reactive(Banner.sweep, sweep)
+        self.set_reactive(Banner.startup, startup)
+        self.set_reactive(Banner.notices, tuple(notices) if notices is not None else ())
+        self.set_reactive(Banner.changelog, changelog)
+        # Ink: <Box flexDirection="column" marginBottom={1}>
+        self.styles.margin = (0, 0, 1, 0)
+
+    def render(self) -> RenderableType:
+        theme = self.theme
+        if theme is None:
+            return Text("")
+        columns = self.size.width or 80
+        return build_banner_text(
+            theme,
+            model_id=self.model_id,
+            workspace=self.workspace,
+            version=self.version,
+            verbose=self.verbose,
+            quiet=self.quiet,
+            compact=self.compact,
+            account=self.account,
+            sweep=self.sweep,
+            startup=self.startup,
+            notices=self.notices,
+            changelog=self.changelog,
+            columns=columns,
+        )