code-puppy-core-plugins 0.0.2__py3-none-any.whl

code_puppy_core_plugins/theme/register_callbacks.py

@@ -0,0 +1,348 @@
+"""/theme — pick a curated banner+content color theme, interactively or by name.
+
+UX:
+  /theme               → interactive split-panel picker with live preview
+  /theme <N>           → apply theme number N (1-16)
+  /theme <name>        → apply by name (ocean, forest, sunset, vaporwave,
+                         bubblegum-pink, purple-puppy, mocha, latte,
+                         tokyo-night, green-screen, deep-black, solarized-light,
+                         github-light, rose-pine-dawn, surprise, default)
+  /theme reset         → restore Code Puppy defaults (alias of /theme default)
+  /theme show          → show current banner → color mapping
+
+The 15th option (Surprise Me) re-rolls a random palette every time.
+The 16th option (Restore Defaults) puts everything back to factory.
+
+Plays nice with /colors — same color pool, same config keys.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+from typing import TYPE_CHECKING
+
+from code_puppy.callbacks import register_callback
+
+# NOTE: Keep heavy theme/TUI imports inside callers so plugin discovery stays
+# fast; the deferred style import saves startup time. Caveat: theme/__init__.py
+# still eagerly imports style modules/reapplies config, so prompt_toolkit remains
+# on the startup path until that sweep is deferred too.
+
+_INTERACTIVE_TIMEOUT_SECONDS = 300  # 5 min — generous; user is browsing
+_ACTIVE_THEME_CONFIG_KEY = "theme_active_theme"
+_DEFAULT_THEME_NAME = "tokyo-night"
+_LEGACY_THEME_NAME = "legacy-custom"
+
+
+def _custom_help():
+    return [
+        ("theme", "Pick a curated banner+content color theme (interactive: /theme)"),
+    ]
+
+
+# Rendering helpers: emit_info escapes Rich markup, while picker previews use Rich.
+def _format_banner_mapping(mapping: dict[str, str]) -> str:
+    from code_puppy.command_line.colors_menu import BANNER_DISPLAY_INFO
+
+    lines = []
+    for banner, color in mapping.items():
+        display, icon = BANNER_DISPLAY_INFO.get(banner, (banner, ""))
+        prefix = f"{icon} " if icon else "  "
+        lines.append(f"  {prefix}{display:<24} -> {color}")
+    return "\n".join(lines)
+
+
+def _format_content_mapping(mapping: dict[str, str]) -> str:
+    lines = []
+    for key, style in mapping.items():
+        lines.append(f"  {key:<14} -> {style}")
+    return "\n".join(lines)
+
+
+def _announce_applied(theme_name: str) -> None:
+    """Quietly confirm the theme is applied. Mappings available via /theme show."""
+    from code_puppy.messaging import emit_info
+
+    from .themes import MENU_BY_NAME
+
+    theme = MENU_BY_NAME[theme_name]
+    emit_info(
+        f"{theme['icon']} {theme['label']} theme applied. "
+        f"(/theme show to inspect, /theme default to undo)"
+    )
+
+
+# --- Interactive flow -------------------------------------------------------
+def _run_interactive_picker() -> str | None:
+    """Run the async TUI from a sync command handler."""
+    from .picker import interactive_theme_picker
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        future = executor.submit(lambda: asyncio.run(interactive_theme_picker()))
+        return future.result(timeout=_INTERACTIVE_TIMEOUT_SECONDS)
+
+
+def _apply_theme(theme_name: str, *, announce: bool = True) -> None:
+    """Apply banner colors + content styles + inline remap + terminal palette.
+
+    `default` is special: resets banner config, content styles, Rich color
+    remap, AND the terminal-level OSC palette.
+    """
+    from code_puppy.config import reset_all_banner_colors, set_config_value
+
+    from . import content_styles as cs
+    from . import osc_palette as osc
+    from . import rich_themes as rt
+    from .themes import (
+        apply,
+        color_remap_for,
+        colors_for,
+        content_styles_for,
+        terminal_palette_for,
+    )
+
+    if theme_name == "default":
+        reset_all_banner_colors()
+        cs.restore_defaults()
+        rt.restore()
+        osc.reset_palette()
+    else:
+        banner_mapping = colors_for(theme_name)
+        content_mapping = content_styles_for(theme_name)
+        remap = color_remap_for(theme_name)
+        terminal_palette = terminal_palette_for(theme_name)
+        apply(banner_mapping)
+        cs.apply_content_styles(content_mapping)
+        rt.apply_remap(remap)
+        if terminal_palette:
+            osc.apply_palette(terminal_palette)
+
+    set_config_value(_ACTIVE_THEME_CONFIG_KEY, theme_name)
+    if announce:
+        _announce_applied(theme_name)
+
+
+def _active_terminal_palette() -> tuple[str, dict] | None:
+    """Return the active curated theme and its complete persisted palette."""
+    from code_puppy.config import get_value
+
+    from . import osc_palette as osc
+
+    active_theme = get_value(_ACTIVE_THEME_CONFIG_KEY)
+    if not active_theme or active_theme in {"default", _LEGACY_THEME_NAME}:
+        return None
+    palette = osc.get_saved_palette()
+    if not palette or len(palette.get("ansi") or []) < 16:
+        return None
+    return active_theme, palette
+
+
+def _termflow_style(default_style):
+    """Derive Termflow's truecolor Markdown chrome from the active theme."""
+    active = _active_terminal_palette()
+    if active is None:
+        return default_style
+    _, palette = active
+    ansi = palette["ansi"]
+
+    from termflow.render.style import RenderStyle
+
+    return RenderStyle(
+        bright=ansi[14],
+        head=ansi[10],
+        symbol=ansi[13],
+        grey=ansi[8],
+        dark=palette.get("bg", ansi[0]),
+        mid=ansi[8],
+        light=ansi[7],
+        link=ansi[12],
+        error=ansi[9],
+    )
+
+
+def _termflow_highlighter(default_highlighter):
+    """Build syntax colors from the active theme instead of Monokai."""
+    active = _active_terminal_palette()
+    if active is None:
+        return default_highlighter
+    active_theme, palette = active
+    ansi = palette["ansi"]
+
+    from pygments.formatters.terminal256 import TerminalTrueColorFormatter
+    from pygments.style import Style
+    from pygments.token import (
+        Comment,
+        Error,
+        Keyword,
+        Name,
+        Number,
+        Operator,
+        String,
+        Token,
+    )
+    from termflow.syntax import Highlighter
+
+    if active_theme in {"green-screen", "green", "crt"}:
+        # Preserve monochrome phosphor while giving token classes enough
+        # separation to remain useful on both addition and deletion lines.
+        token_styles = {
+            Token: "#72a85b",
+            Comment: "#456b4f",
+            Error: "#7dff68",
+            Keyword: "#39e75f",
+            Name.Function: "#75ff87",
+            Number: "#8acb72",
+            Operator: "#63b96a",
+            String: "#9bdc79",
+        }
+    elif active_theme in {"solarized-light", "solarized"}:
+        token_styles = {
+            Token: "#657b83",
+            Comment: "#586e75",
+            Error: "#dc322f",
+            Keyword: "#859900",
+            Name.Function: "#268bd2",
+            Number: "#2aa198",
+            Operator: "#657b83",
+            String: "#2aa198",
+        }
+    else:
+        token_styles = {
+            Token: ansi[7],
+            Comment: ansi[8],
+            Error: ansi[9],
+            Keyword: ansi[13],
+            Name.Function: ansi[14],
+            Number: ansi[11],
+            Operator: ansi[6],
+            String: ansi[10],
+        }
+
+    theme_style = type(
+        "CodePuppyThemeStyle",
+        (Style,),
+        {"background_color": palette.get("bg"), "styles": token_styles},
+    )
+    highlighter = Highlighter()
+    highlighter._formatter = TerminalTrueColorFormatter(style=theme_style)
+    if active_theme in {"green-screen", "green", "crt"}:
+        # Added lines lean brighter/yellower; removed lines become cooler and
+        # more muted. Small shifts retain the token palette's internal contrast.
+        highlighter.diff_line_tints = {
+            "added": (10, 14, -8),
+            "removed": (-18, -4, 10),
+        }
+    return highlighter
+
+
+def _prompt_text_color(default_color):
+    """Use the active terminal foreground for the persistent prompt buffer."""
+    active = _active_terminal_palette()
+    return active[1].get("fg", default_color) if active else default_color
+
+
+if TYPE_CHECKING:
+    from prompt_toolkit.styles import BaseStyle
+
+
+def _prompt_toolkit_style(style: "BaseStyle | None" = None) -> "BaseStyle":
+    """Lazy shim for prompt_toolkit_theme.merge_with_active_style.
+
+    The real implementation lives in .prompt_toolkit_theme which pulls in
+    prompt_toolkit.styles at import time. Deferring the import until the
+    prompt_toolkit_style callback actually fires (during REPL init, well
+    after startup) keeps that cost off the launch-time critical path.
+
+    Matches the real callable's `(style) -> BaseStyle` shape so a caller
+    passing an unexpected kwarg still gets a TypeError instead of being
+    silently swallowed.
+    """
+    from .prompt_toolkit_theme import merge_with_active_style
+
+    return merge_with_active_style(style)
+
+
+# Preserve the callback name for failure logs; the real symbol is more useful than
+# "_prompt_toolkit_style failed".
+_prompt_toolkit_style.__name__ = "merge_with_active_style"
+
+
+def _apply_default_theme_on_first_run() -> None:
+    """Apply Tokyo Night once, preserving explicit and legacy theme choices."""
+    from code_puppy.config import get_value
+
+    if get_value(_ACTIVE_THEME_CONFIG_KEY):
+        return
+
+    from code_puppy.config import set_config_value
+
+    from . import osc_palette as osc
+
+    if osc.get_saved_palette():
+        # Theme persistence predates the active-theme marker. Treat an existing
+        # palette as an intentional choice and migrate without changing it.
+        set_config_value(_ACTIVE_THEME_CONFIG_KEY, _LEGACY_THEME_NAME)
+        return
+
+    _apply_theme(_DEFAULT_THEME_NAME, announce=False)
+
+
+# --- Command handler --------------------------------------------------------
+def _handle_theme(command: str, name: str):
+    if name != "theme":
+        return None
+
+    from code_puppy.config import get_all_banner_colors
+    from code_puppy.messaging import emit_error, emit_info, emit_warning
+
+    from . import content_styles as cs
+    from .themes import MENU_BY_NAME, resolve_theme_arg
+
+    parts = command.split()
+    sub = parts[1].lower() if len(parts) > 1 else ""
+
+    if sub == "":
+        try:
+            chosen = _run_interactive_picker()
+        except Exception as e:  # pragma: no cover — defensive UX
+            emit_error(f"Theme picker failed: {e}")
+            return True
+        if chosen is None:
+            emit_info("🎨 Theme unchanged.")
+            return True
+        _apply_theme(chosen)
+        return True
+
+    if sub == "show":
+        emit_info(
+            "🎨 Current theme:\n"
+            "Banners:\n"
+            + _format_banner_mapping(get_all_banner_colors())
+            + "\nContent text:\n"
+            + _format_content_mapping(cs.get_all_content_styles())
+        )
+        return True
+
+    theme_name = resolve_theme_arg(sub)
+    if theme_name is None:
+        valid = ", ".join(
+            k for k in MENU_BY_NAME if k not in ("random", "reset", "defaults")
+        )
+        emit_warning(
+            f"Unknown theme '{sub}'. Try /theme for the picker, "
+            f"or pick one of: {valid}."
+        )
+        return True
+
+    _apply_theme(theme_name)
+    return True
+
+
+register_callback("startup", _apply_default_theme_on_first_run)
+register_callback("termflow_style", _termflow_style)
+register_callback("termflow_highlighter", _termflow_highlighter)
+register_callback("prompt_text_color", _prompt_text_color)
+register_callback("prompt_toolkit_style", _prompt_toolkit_style)
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_theme)

code_puppy_core_plugins/theme/rich_themes.py

@@ -0,0 +1,202 @@
+"""Level 2 theming: live remap of inline Rich color names.
+
+The renderer is full of hardcoded inline markup like `[bold cyan]`,
+`[dim cyan]`, `[dim white]`, etc. Rich's stock `Theme` class can intercept
+top-level *named styles* (`[my_style]`) but it does NOT remap base color
+names embedded inside complex styles (`[bold cyan]` → still cyan).
+
+So we go one level deeper: monkey-patch `Console.get_style()` on live console
+instances. Every parsed style flows through it; we inspect the resolved
+`Style.color` (and `bgcolor`) and swap it out if it's in our remap dict.
+
+What we DO remap by default: "decorative" colors (cyan, blue, magenta,
+bright_*). What we DON'T touch:
+    - red    (errors must look angry)
+    - yellow (warnings)
+    - green  (success / diff add)
+    - white  (high-contrast text)
+
+That keeps semantic meaning intact across all themes.
+
+Persisted via config so the patch survives Code Puppy restarts.
+"""
+
+from __future__ import annotations
+
+import gc
+import json
+import weakref
+from typing import Callable, Optional
+
+from rich.color import Color
+from rich.console import Console
+from rich.style import Style
+
+from code_puppy.config import get_value, set_config_value
+from code_puppy.messaging import rich_renderer
+
+# Remap registry: weak per-console records retain no dead consoles.
+_PATCHED: "weakref.WeakKeyDictionary[Console, Callable]" = weakref.WeakKeyDictionary()
+
+_CONFIG_KEY = "rich_color_remap_json"
+
+
+# --- Color-swap mechanics ---------------------------------------------------
+def _safe_parse(name: str) -> Optional[Color]:
+    """Parse a color name, returning None if Rich can't handle it.
+
+    Rich's named-color set is a strict subset of what some palettes use
+    (e.g. ``cyan4`` and ``dark_orchid`` exist as banner backgrounds but
+    aren't parseable as standalone Colors). Never let one bad name take
+    down rendering.
+    """
+    try:
+        return Color.parse(name)
+    except Exception:
+        return None
+
+
+def _swap_color(style: Style, remap: dict[str, str]) -> Style:
+    """Return a new Style with color/bgcolor remapped if names match."""
+    changes = {}
+    if style.color is not None and style.color.name in remap:
+        new = _safe_parse(remap[style.color.name])
+        if new is not None:
+            changes["color"] = new
+    if style.bgcolor is not None and style.bgcolor.name in remap:
+        new = _safe_parse(remap[style.bgcolor.name])
+        if new is not None:
+            changes["bgcolor"] = new
+    if not changes:
+        return style
+    return style + Style(**changes)
+
+
+def _install_patch(console: Console, remap: dict[str, str]) -> None:
+    """Patch a console's get_style to apply the remap. Idempotent."""
+    if not remap:
+        _uninstall_patch(console)
+        return
+
+    if console in _PATCHED:
+        # Already patched — just swap the remap (closure captures it).
+        # Re-install to refresh the captured remap dict.
+        _uninstall_patch(console)
+
+    original = console.get_style
+
+    def patched(name, *, default=None):
+        style = original(name, default=default)
+        return _swap_color(style, remap)
+
+    console.get_style = patched  # type: ignore[method-assign]
+    _PATCHED[console] = original
+
+
+def _uninstall_patch(console: Console) -> None:
+    """Restore a console's original get_style. Safe if not patched."""
+    original = _PATCHED.pop(console, None)
+    if original is not None:
+        try:
+            console.get_style = original  # type: ignore[method-assign]
+        except Exception:
+            pass
+
+
+# --- Live-console discovery -------------------------------------------------
+def _live_consoles() -> list[Console]:
+    """Find every live rich.console.Console instance via gc.
+
+    Cheap heuristic but reliable. We patch them all so subagent renderers
+    and the interactive renderer get themed alongside the bus renderer.
+    """
+    consoles: list[Console] = []
+    try:
+        for obj in gc.get_objects():
+            if isinstance(obj, Console):
+                consoles.append(obj)
+        # Also grab any Console hanging off a live RichConsoleRenderer
+        # (belt-and-suspenders; usually already covered by the above).
+        for obj in gc.get_objects():
+            if isinstance(obj, rich_renderer.RichConsoleRenderer):
+                c = getattr(obj, "_console", None)
+                if isinstance(c, Console) and c not in consoles:
+                    consoles.append(c)
+    except Exception:
+        pass
+    return consoles
+
+
+# --- Public API -------------------------------------------------------------
+def apply_remap(remap: dict[str, str], persist: bool = True) -> int:
+    """Apply a color remap to every live Console. Returns how many got patched.
+
+    Empty remap = restore (un-patch everything).
+    """
+    consoles = _live_consoles()
+    if remap:
+        for c in consoles:
+            _install_patch(c, remap)
+    else:
+        for c in consoles:
+            _uninstall_patch(c)
+
+    if persist:
+        try:
+            set_config_value(_CONFIG_KEY, json.dumps(remap))
+        except Exception:
+            pass
+    return len(consoles)
+
+
+def restore() -> int:
+    """Remove the color remap from every live console."""
+    return apply_remap({}, persist=True)
+
+
+def get_saved_remap() -> dict[str, str]:
+    """Read the persisted remap from config (or {} if none)."""
+    raw = get_value(_CONFIG_KEY)
+    if not raw:
+        return {}
+    try:
+        data = json.loads(raw)
+        if isinstance(data, dict):
+            return {str(k): str(v) for k, v in data.items()}
+    except Exception:
+        pass
+    return {}
+
+
+def reapply_from_config() -> None:
+    """Push any persisted remap back into live consoles. Safe to call repeatedly."""
+    remap = get_saved_remap()
+    if remap:
+        apply_remap(remap, persist=False)
+
+
+# --- Reasonable default palette presets -------------------------------------
+# Used by themes.py. Keep semantic colors (red/yellow/green) untouched.
+def make_remap(
+    cyan: Optional[str] = None,
+    blue: Optional[str] = None,
+    magenta: Optional[str] = None,
+    bright_cyan: Optional[str] = None,
+    bright_blue: Optional[str] = None,
+    bright_magenta: Optional[str] = None,
+    white: Optional[str] = None,
+    bright_white: Optional[str] = None,
+) -> dict[str, str]:
+    """Build a clean remap dict from optional kwargs (None = skip)."""
+    mapping = {
+        "cyan": cyan,
+        "blue": blue,
+        "magenta": magenta,
+        "bright_cyan": bright_cyan,
+        "bright_blue": bright_blue,
+        "bright_magenta": bright_magenta,
+        "white": white,
+        "bright_white": bright_white,
+    }
+    # Drop entries Rich can't parse so a typo in a theme never crashes the UI.
+    return {k: v for k, v in mapping.items() if v and _safe_parse(v) is not None}