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

code_puppy_core_plugins/theme/bundled_palettes.py

@@ -0,0 +1,346 @@
+"""Bundled terminal palettes for OSC-level theming.
+
+Each palette ships:
+    bg   = #rrggbb default background
+    fg   = #rrggbb default foreground
+    ansi = list of 16 #rrggbb hex strings (ANSI slots 0-15)
+
+The Catppuccin / Tokyo Night palettes are the canonical
+upstream specs (same ones mure ships). The original theme
+palettes (ocean/forest/sunset/vaporwave) are coherent extensions
+of their existing Rich color schemes.
+"""
+
+from __future__ import annotations
+
+# --- Mure-port bundled palettes ---------------------------------------------
+
+CATPPUCCIN_MOCHA = {
+    "bg": "#1e1e2e",
+    "fg": "#cdd6f4",
+    "ansi": [
+        "#45475a",
+        "#f38ba8",
+        "#a6e3a1",
+        "#f9e2af",
+        "#89b4fa",
+        "#f5c2e7",
+        "#94e2d5",
+        "#bac2de",
+        "#585b70",
+        "#f38ba8",
+        "#a6e3a1",
+        "#f9e2af",
+        "#89b4fa",
+        "#f5c2e7",
+        "#94e2d5",
+        "#a6adc8",
+    ],
+}
+
+CATPPUCCIN_LATTE = {
+    "bg": "#eff1f5",
+    "fg": "#4c4f69",
+    "ansi": [
+        "#4c4f69",
+        "#d20f39",
+        "#40a02b",
+        "#df8e1d",
+        "#1e66f5",
+        "#8839ef",
+        "#179299",
+        "#acb0be",
+        "#5c5f77",
+        "#e64553",
+        "#a6d189",
+        "#fe640b",
+        "#7287fd",
+        "#ea76cb",
+        "#94e2d5",
+        "#bcc0cc",
+    ],
+}
+
+TOKYO_NIGHT = {
+    "bg": "#1a1b26",
+    "fg": "#c0caf5",
+    "ansi": [
+        "#15161e",
+        "#f7768e",
+        "#9ece6a",
+        "#e0af68",
+        "#7aa2f7",
+        "#bb9af7",
+        "#7dcfff",
+        "#a9b1d6",
+        "#414868",
+        "#f7768e",
+        "#9ece6a",
+        "#e0af68",
+        "#7aa2f7",
+        "#bb9af7",
+        "#7dcfff",
+        "#c0caf5",
+    ],
+}
+
+GREEN_SCREEN = {
+    # llxprt-code's Green Screen palette: black glass, green phosphor, and one
+    # intentionally eye-searing highlight.
+    "bg": "#000000",
+    "fg": "#6a9955",
+    "ansi": [
+        "#000000",  # 0  black — CRT glass
+        "#6a9955",  # 1  red — phosphor green
+        "#6a9955",  # 2  green — phosphor green
+        "#6a9955",  # 3  yellow — phosphor green
+        "#6a9955",  # 4  blue — phosphor green
+        "#6a9955",  # 5  magenta — phosphor green
+        "#6a9955",  # 6  cyan — phosphor green
+        "#6a9955",  # 7  white — phosphor green
+        "#3a5945",  # 8  bright black — dark phosphor
+        "#6a9955",  # 9  bright red
+        "#00ff00",  # 10 bright green — radioactive highlight
+        "#6a9955",  # 11 bright yellow
+        "#6a9955",  # 12 bright blue
+        "#6a9955",  # 13 bright magenta
+        "#6a9955",  # 14 bright cyan
+        "#00ff00",  # 15 bright white — radioactive highlight
+    ],
+}
+
+DEEP_BLACK = {
+    "bg": "#050505",
+    "fg": "#e6e6e6",
+    "ansi": [
+        "#050505",
+        "#ff6b6b",
+        "#94d82d",
+        "#ffd166",
+        "#4dabf7",
+        "#b197fc",
+        "#63e6be",
+        "#adb5bd",
+        "#1f1f1f",
+        "#ff8787",
+        "#a9e34b",
+        "#ffe066",
+        "#74c0fc",
+        "#d0bfff",
+        "#96f2d7",
+        "#f1f3f5",
+    ],
+}
+
+# --- Light-mode bundled palettes -------------------------------------------
+
+SOLARIZED_LIGHT = {
+    "bg": "#fdf6e3",
+    "fg": "#657b83",
+    "ansi": [
+        "#073642",
+        "#dc322f",
+        "#859900",
+        "#b58900",
+        "#268bd2",
+        "#d33682",
+        "#2aa198",
+        "#eee8d5",
+        "#fdf6e3",
+        "#cb4b16",
+        "#93a1a1",
+        "#839496",
+        "#657b83",
+        "#6c71c4",
+        "#586e75",
+        "#002b36",
+    ],
+}
+
+GITHUB_LIGHT = {
+    "bg": "#ffffff",
+    "fg": "#24292e",
+    "ansi": [
+        "#24292e",
+        "#d73a49",
+        "#28a745",
+        "#dbab09",
+        "#0366d6",
+        "#6f42c1",
+        "#1b7c83",
+        "#6a737d",
+        "#586069",
+        "#cb2431",
+        "#22863a",
+        "#b08800",
+        "#005cc5",
+        "#5a32a3",
+        "#3192aa",
+        "#d1d5da",
+    ],
+}
+
+ROSE_PINE_DAWN = {
+    "bg": "#faf4ed",
+    "fg": "#575279",
+    "ansi": [
+        "#f2e9e1",
+        "#b4637a",
+        "#56949f",
+        "#ea9d34",
+        "#286983",
+        "#907aa9",
+        "#d7827e",
+        "#575279",
+        "#9893a5",
+        "#b4637a",
+        "#56949f",
+        "#ea9d34",
+        "#286983",
+        "#907aa9",
+        "#d7827e",
+        "#cecacd",
+    ],
+}
+
+# --- Coherent palettes for the original 4 themes ---------------------------
+
+OCEAN = {
+    "bg": "#0a1929",
+    "fg": "#d6eaf8",
+    "ansi": [
+        "#0a1929",
+        "#e74c3c",
+        "#48c9b0",
+        "#f4d03f",
+        "#3498db",
+        "#1abc9c",
+        "#5dade2",
+        "#aed6f1",
+        "#34495e",
+        "#ec7063",
+        "#1abc9c",
+        "#f7dc6f",
+        "#5499c7",
+        "#48c9b0",
+        "#85c1e9",
+        "#ebf5fb",
+    ],
+}
+
+FOREST = {
+    "bg": "#1a2310",
+    "fg": "#e3eecc",
+    "ansi": [
+        "#1a2310",
+        "#c0392b",
+        "#27ae60",
+        "#d4ac0d",
+        "#7d6608",
+        "#16a085",
+        "#1e8449",
+        "#aed581",
+        "#52682d",
+        "#cd6155",
+        "#52be80",
+        "#f4d03f",
+        "#7d6608",
+        "#48c9b0",
+        "#7dcea0",
+        "#eaf2cf",
+    ],
+}
+
+SUNSET = {
+    "bg": "#2d1b0e",
+    "fg": "#ffe4cc",
+    "ansi": [
+        "#2d1b0e",
+        "#e74c3c",
+        "#d35400",
+        "#f39c12",
+        "#7d3c98",
+        "#c0392b",
+        "#e67e22",
+        "#fad7a0",
+        "#5d4037",
+        "#ec7063",
+        "#e67e22",
+        "#f9e79f",
+        "#a93226",
+        "#d35400",
+        "#f5b041",
+        "#fdebd0",
+    ],
+}
+
+VAPORWAVE = {
+    "bg": "#16002a",
+    "fg": "#ffe0ff",
+    "ansi": [
+        "#16002a",
+        "#ff6ec7",
+        "#48c9b0",
+        "#f7dc6f",
+        "#bb6bd9",
+        "#ec407a",
+        "#7fdbff",
+        "#e8daef",
+        "#5b2c6f",
+        "#ff79c6",
+        "#80deea",
+        "#fff59d",
+        "#d7bde2",
+        "#f06292",
+        "#80deea",
+        "#fce4ec",
+    ],
+}
+
+PURPLE_PUPPY = {
+    # Purple puppy mascot colors: violet fur, lavender muzzle, pink tongue, and
+    # an inky background.
+    "bg": "#1c0630",
+    "fg": "#f0e3ff",
+    "ansi": [
+        "#2a0a45",  # 0  black — dark plum outline
+        "#ff5c8a",  # 1  red — tongue pink-red
+        "#c986ff",  # 2  green — bright orchid fur highlight
+        "#f5c26b",  # 3  yellow — warm gold (warnings still warn)
+        "#9b30d9",  # 4  blue — vivid violet fur
+        "#ff7fa8",  # 5  magenta — tongue pink
+        "#d9a7f5",  # 6  cyan — soft lilac
+        "#f0e3ff",  # 7  white — muzzle lavender-white
+        "#a98aca",  # 8  bright black — readable muted lavender
+        "#ff7fa8",  # 9  bright red
+        "#dba1ff",  # 10 bright green
+        "#ffd58f",  # 11 bright yellow
+        "#b06be8",  # 12 bright blue
+        "#ff9fd2",  # 13 bright magenta
+        "#e8ccff",  # 14 bright cyan
+        "#fdf7ff",  # 15 bright white — muzzle shine
+    ],
+}
+
+BUBBLEGUM_PINK = {
+    "bg": "#2a0f1f",
+    "fg": "#fff1f7",
+    "ansi": [
+        "#2a0f1f",
+        "#ff5fa2",
+        "#ff8ec7",
+        "#ffd1e8",
+        "#ff4f93",
+        "#d96cff",
+        "#ff9fd2",
+        "#fff1f7",
+        "#4d1d39",
+        "#ff7ab2",
+        "#ffb3da",
+        "#ffe0ef",
+        "#ff6fb0",
+        "#eb8cff",
+        "#ffc4e1",
+        "#fff8fb",
+    ],
+}

code_puppy_core_plugins/theme/content_styles.py

@@ -0,0 +1,146 @@
+"""Content-text style theming (level 1).
+
+The banner plugin already paints the banner headers. This module paints the
+body text underneath by mutating the `RichConsoleRenderer`'s style maps.
+
+Two upstream knobs:
+    code_puppy.messaging.rich_renderer.DEFAULT_STYLES  (MessageLevel -> style)
+    code_puppy.messaging.rich_renderer.DIFF_STYLES     ({add,remove,context} -> style)
+
+These dicts are **copied** by `RichConsoleRenderer.__init__`. Mutating them
+after construction won't affect already-running renderers, so we also reach
+into live renderer instances (via gc) and update their `_styles` dict in place.
+
+Pure logic + a small amount of surgical monkey patching. Config-persisted so
+preferences survive restarts.
+
+Zen: namespaces are one honking great idea; we keep everything in one place.
+"""
+
+from __future__ import annotations
+
+import gc
+from typing import Callable
+
+from code_puppy.config import get_value, set_config_value
+from code_puppy.messaging import rich_renderer
+from code_puppy.messaging.messages import MessageLevel
+
+# --- The 8 themable content keys -------------------------------------------
+# We expose a flat string-keyed namespace so config persistence is trivial.
+CONTENT_KEYS: tuple[str, ...] = (
+    "info",
+    "warning",
+    "success",
+    "error",
+    "debug",
+    "diff_add",
+    "diff_remove",
+    "diff_context",
+)
+
+_LEVEL_KEYS: dict[str, MessageLevel] = {
+    "info": MessageLevel.INFO,
+    "warning": MessageLevel.WARNING,
+    "success": MessageLevel.SUCCESS,
+    "error": MessageLevel.ERROR,
+    "debug": MessageLevel.DEBUG,
+}
+_DIFF_KEYS: dict[str, str] = {
+    "diff_add": "add",
+    "diff_remove": "remove",
+    "diff_context": "context",
+}
+
+# Snapshot taken at import time (before any mutation). This becomes our
+# "factory default" for restore.
+DEFAULT_CONTENT_STYLES: dict[str, str] = {
+    **{k: rich_renderer.DEFAULT_STYLES[lvl] for k, lvl in _LEVEL_KEYS.items()},
+    **{k: rich_renderer.DIFF_STYLES[v] for k, v in _DIFF_KEYS.items()},
+}
+
+_CONFIG_PREFIX = "content_style_"
+
+
+# --- Persistence helpers ----------------------------------------------------
+def _config_key(name: str) -> str:
+    return f"{_CONFIG_PREFIX}{name}"
+
+
+def get_content_style(name: str) -> str:
+    """Return current style for `name`, falling back to the factory default."""
+    if name not in DEFAULT_CONTENT_STYLES:
+        raise KeyError(f"Unknown content style: {name!r}")
+    return get_value(_config_key(name)) or DEFAULT_CONTENT_STYLES[name]
+
+
+def get_all_content_styles() -> dict[str, str]:
+    """Return the current effective mapping for every content key."""
+    return {name: get_content_style(name) for name in CONTENT_KEYS}
+
+
+def _persist(mapping: dict[str, str]) -> None:
+    for name, style in mapping.items():
+        set_config_value(_config_key(name), style)
+
+
+# --- Mutation -------------------------------------------------------------
+def _push_to_renderers(mapping: dict[str, str]) -> None:
+    """Push a {content_key: style} mapping into module dicts AND live renderers.
+
+    Live renderers copy `DEFAULT_STYLES` at __init__, so mutating the module
+    dict isn't enough — we walk live instances and patch them too.
+    """
+    # 1. Module-level dicts (in case fresh renderers spawn later)
+    for k, lvl in _LEVEL_KEYS.items():
+        rich_renderer.DEFAULT_STYLES[lvl] = mapping[k]
+    for k, diff_key in _DIFF_KEYS.items():
+        rich_renderer.DIFF_STYLES[diff_key] = mapping[k]
+
+    # 2. Live renderer instances (the ones actually painting your terminal)
+    try:
+        for obj in gc.get_objects():
+            if isinstance(obj, rich_renderer.RichConsoleRenderer):
+                styles = getattr(obj, "_styles", None)
+                if isinstance(styles, dict):
+                    for k, lvl in _LEVEL_KEYS.items():
+                        styles[lvl] = mapping[k]
+    except Exception:
+        # gc walks can be flaky in odd interpreters; never let that nuke UX
+        pass
+
+
+def apply_content_styles(
+    mapping: dict[str, str],
+    persist: bool = True,
+    setter: Callable[[dict[str, str]], None] | None = None,
+) -> None:
+    """Apply a content style mapping live + (optionally) persist it.
+
+    Args:
+        mapping: dict with every key in CONTENT_KEYS.
+        persist: if True, write to config so it survives restarts.
+        setter: injectable for tests; defaults to the real persister.
+    """
+    missing = set(CONTENT_KEYS) - mapping.keys()
+    if missing:
+        raise ValueError(f"Content style mapping missing keys: {sorted(missing)}")
+
+    _push_to_renderers(mapping)
+    if persist:
+        (setter or _persist)(mapping)
+
+
+def restore_defaults(persist: bool = True) -> dict[str, str]:
+    """Restore factory-default content styles. Returns the mapping applied."""
+    apply_content_styles(DEFAULT_CONTENT_STYLES, persist=persist)
+    return dict(DEFAULT_CONTENT_STYLES)
+
+
+def reapply_from_config() -> None:
+    """On plugin load, push any persisted overrides into the live renderer.
+
+    Safe to call multiple times; no-op if config has no overrides
+    (since get_content_style falls back to defaults).
+    """
+    _push_to_renderers(get_all_content_styles())

code_puppy_core_plugins/theme/osc_palette.py

@@ -0,0 +1,178 @@
+"""Terminal-level palette swap via OSC escape sequences.
+
+This module reaches *past* Code Puppy and recolors the whole terminal window
+(bg, fg, ANSI palette slots) using widely-supported xterm OSC sequences:
+
+    OSC 10 ; spec BEL    -> set default foreground
+    OSC 11 ; spec BEL    -> set default background
+    OSC  4 ; N ; spec BEL -> set ANSI palette slot N (0..15)
+    OSC 110 BEL          -> reset foreground
+    OSC 111 BEL          -> reset background
+    OSC 104 BEL          -> reset whole palette
+
+Supported by iTerm2, Terminal.app, Alacritty, kitty, VS Code, GNOME
+Terminal, Windows Terminal. Unsupported terminals silently ignore them.
+
+We always register an atexit handler so the terminal is restored when
+Code Puppy quits, even if the user forgets to /theme default first.
+"""
+
+from __future__ import annotations
+
+import atexit
+import json
+import sys
+from typing import Optional, Sequence
+
+from code_puppy.config import get_value, set_config_value
+
+BEL = "\007"
+ESC = "\033"
+
+_CONFIG_KEY = "osc_palette_json"
+_atexit_registered = False
+
+
+# --- Low-level emit ---------------------------------------------------------
+def _emit(seq: str) -> None:
+    """Write an escape sequence to stdout, ignoring failures (closed tty etc.)."""
+    try:
+        sys.stdout.write(seq)
+        sys.stdout.flush()
+    except Exception:
+        pass
+
+
+def _osc(code: str, *args: str) -> str:
+    """Build an OSC escape: ESC ] code ; args... BEL"""
+    payload = ";".join((code,) + args)
+    return f"{ESC}]{payload}{BEL}"
+
+
+# --- Public escape builders -------------------------------------------------
+def set_bg(color: str) -> None:
+    _emit(_osc("11", color))
+
+
+def set_fg(color: str) -> None:
+    _emit(_osc("10", color))
+
+
+def set_ansi_slot(slot: int, color: str) -> None:
+    if not 0 <= slot <= 15:
+        return
+    _emit(_osc("4", str(slot), color))
+
+
+def reset_bg() -> None:
+    _emit(_osc("111"))
+
+
+def reset_fg() -> None:
+    _emit(_osc("110"))
+
+
+def reset_ansi() -> None:
+    _emit(_osc("104"))
+
+
+# --- High-level API ---------------------------------------------------------
+def apply_palette(
+    palette: dict, persist: bool = True, register_reset: bool = True
+) -> None:
+    """Apply a palette dict to the live terminal.
+
+    Palette shape:
+        {
+            "bg":   "#rrggbb",                 # optional
+            "fg":   "#rrggbb",                 # optional
+            "ansi": ["#rrggbb", ...]           # optional, 0..16 entries
+        }
+
+    `persist=True` writes the palette to config so the next Code Puppy
+    session can replay it. `register_reset=True` ensures we always
+    restore the terminal at process exit.
+    """
+    if not isinstance(palette, dict):
+        return
+
+    bg = palette.get("bg")
+    fg = palette.get("fg")
+    ansi: Sequence[str] = palette.get("ansi") or []
+
+    if bg:
+        set_bg(bg)
+    if fg:
+        set_fg(fg)
+    for i, color in enumerate(ansi[:16]):
+        if color:
+            set_ansi_slot(i, color)
+
+    if persist:
+        try:
+            set_config_value(_CONFIG_KEY, json.dumps(palette))
+        except Exception:
+            pass
+
+    if register_reset:
+        _ensure_atexit_registered()
+
+
+def reset_palette(persist: bool = True) -> None:
+    """Restore the terminal's original bg/fg/ANSI palette."""
+    reset_ansi()
+    reset_bg()
+    reset_fg()
+    if persist:
+        try:
+            set_config_value(_CONFIG_KEY, "")
+        except Exception:
+            pass
+
+
+def get_saved_palette() -> Optional[dict]:
+    """Read the persisted palette (or None if nothing saved)."""
+    raw = get_value(_CONFIG_KEY)
+    if not raw:
+        return None
+    try:
+        data = json.loads(raw)
+        if isinstance(data, dict):
+            return data
+    except Exception:
+        pass
+    return None
+
+
+def reapply_from_config() -> None:
+    """On plugin load, re-fire any persisted palette into the terminal."""
+    palette = get_saved_palette()
+    if palette:
+        apply_palette(palette, persist=False)
+
+
+# --- Cleanup ----------------------------------------------------------------
+def _at_exit_reset() -> None:
+    """Best-effort terminal restore on Python exit.
+
+    We DON'T touch persisted config here — if the user wants the palette
+    next session, they get it; this just makes sure the live terminal
+    doesn't stay stuck in a weird color after Code Puppy dies.
+    """
+    try:
+        reset_ansi()
+        reset_bg()
+        reset_fg()
+    except Exception:
+        pass
+
+
+def _ensure_atexit_registered() -> None:
+    global _atexit_registered
+    if _atexit_registered:
+        return
+    try:
+        atexit.register(_at_exit_reset)
+        _atexit_registered = True
+    except Exception:
+        pass