ctheme 0.1.0

package/bin/ctheme.js

@@ -0,0 +1,1819 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const readline = require("readline/promises");
+const { execFileSync } = require("child_process");
+
+const TOKENS = [
+  "accent",
+  "border",
+  "borderAccent",
+  "borderMuted",
+  "success",
+  "error",
+  "warning",
+  "muted",
+  "dim",
+  "text",
+  "thinkingText",
+  "selectedBg",
+  "userMessageBg",
+  "userMessageText",
+  "customMessageBg",
+  "customMessageText",
+  "customMessageLabel",
+  "toolPendingBg",
+  "toolSuccessBg",
+  "toolErrorBg",
+  "toolTitle",
+  "toolOutput",
+  "mdHeading",
+  "mdLink",
+  "mdLinkUrl",
+  "mdCode",
+  "mdCodeBlock",
+  "mdCodeBlockBorder",
+  "mdQuote",
+  "mdQuoteBorder",
+  "mdHr",
+  "mdListBullet",
+  "toolDiffAdded",
+  "toolDiffRemoved",
+  "toolDiffContext",
+  "syntaxComment",
+  "syntaxKeyword",
+  "syntaxFunction",
+  "syntaxVariable",
+  "syntaxString",
+  "syntaxNumber",
+  "syntaxType",
+  "syntaxOperator",
+  "syntaxPunctuation",
+  "thinkingOff",
+  "thinkingMinimal",
+  "thinkingLow",
+  "thinkingMedium",
+  "thinkingHigh",
+  "thinkingXhigh",
+  "bashMode"
+];
+
+const BUILTIN_THEMES = [
+  "1337",
+  "base16-eighties-dark",
+  "base16-mocha-dark",
+  "base16-ocean-dark",
+  "base16-ocean-light",
+  "base16-256",
+  "catppuccin-frappe",
+  "catppuccin-latte",
+  "catppuccin-macchiato",
+  "catppuccin-mocha",
+  "coldark-cold",
+  "coldark-dark",
+  "dark-neon",
+  "dracula",
+  "github",
+  "gruvbox-dark",
+  "gruvbox-light",
+  "inspired-github",
+  "monokai-extended",
+  "monokai-extended-bright",
+  "monokai-extended-light",
+  "monokai-extended-origin",
+  "nord",
+  "one-half-dark",
+  "one-half-light",
+  "solarized-dark",
+  "solarized-light",
+  "sublime-snazzy",
+  "two-dark",
+  "zenburn"
+];
+
+const FONT_CHOICES = {
+  ui: ["Manrope", "Space Grotesk", "Outfit", "Sora", "Plus Jakarta Sans", "Newsreader", "Fraunces"],
+  code: ["IBM Plex Mono", "Space Mono", "DM Mono", "Source Code Pro", "Fira Code", "JetBrains Mono"],
+  terminal: ["IBM Plex Mono", "Space Mono", "DM Mono", "Source Code Pro", "Fira Code", "JetBrains Mono"]
+};
+
+const PRESETS = {
+  noir: {
+    fonts: { terminal: "IBM Plex Mono", ui: "Space Grotesk", code: "IBM Plex Mono" },
+    accent: "#79c0ff",
+    bg: "#0d1117",
+    surface: "#161b22",
+    surfaceAlt: "#1f2630",
+    fg: "#e6edf3",
+    muted: "#8b949e",
+    dim: "#6e7681",
+    green: "#3fb950",
+    red: "#ff7b72",
+    yellow: "#d29922",
+    orange: "#ffb86c",
+    purple: "#bc8cff",
+    cyan: "#39c5cf"
+  },
+  paper: {
+    fonts: { terminal: "IBM Plex Mono", ui: "Newsreader", code: "IBM Plex Mono" },
+    accent: "#005cc5",
+    bg: "#fff8e8",
+    surface: "#fffdf7",
+    surfaceAlt: "#f4ecdb",
+    fg: "#2d261d",
+    muted: "#6f6558",
+    dim: "#8b7f71",
+    green: "#1f883d",
+    red: "#cf222e",
+    yellow: "#9a6700",
+    orange: "#bc4c00",
+    purple: "#8250df",
+    cyan: "#0a7ea4"
+  },
+  ember: {
+    fonts: { terminal: "JetBrains Mono", ui: "Sora", code: "JetBrains Mono" },
+    accent: "#ff9e64",
+    bg: "#16120f",
+    surface: "#221a15",
+    surfaceAlt: "#2d221c",
+    fg: "#f7efe8",
+    muted: "#b29a88",
+    dim: "#8d7767",
+    green: "#9ece6a",
+    red: "#f7768e",
+    yellow: "#e0af68",
+    orange: "#ff7a59",
+    purple: "#bb9af7",
+    cyan: "#7dcfff"
+  },
+  mint: {
+    fonts: { terminal: "JetBrains Mono", ui: "Plus Jakarta Sans", code: "JetBrains Mono" },
+    accent: "#2bb673",
+    bg: "#081411",
+    surface: "#10201b",
+    surfaceAlt: "#163029",
+    fg: "#e7fff7",
+    muted: "#91b7ab",
+    dim: "#6f9186",
+    green: "#52d273",
+    red: "#ff7a90",
+    yellow: "#d5c94f",
+    orange: "#ff9d5c",
+    purple: "#b69cff",
+    cyan: "#5ad1e6"
+  },
+  obsidian: {
+    fonts: { terminal: "IBM Plex Mono", ui: "Outfit", code: "IBM Plex Mono" },
+    accent: "#58a6ff",
+    bg: "#05070a",
+    surface: "#0e131a",
+    surfaceAlt: "#171d26",
+    fg: "#edf3ff",
+    muted: "#93a1b5",
+    dim: "#677387",
+    green: "#4fd1a5",
+    red: "#ff7a90",
+    yellow: "#f6c177",
+    orange: "#ff9e64",
+    purple: "#c4a7e7",
+    cyan: "#7dd3fc"
+  },
+  glacier: {
+    fonts: { terminal: "Space Mono", ui: "Space Grotesk", code: "Space Mono" },
+    accent: "#7aa2f7",
+    bg: "#0a1220",
+    surface: "#121c2f",
+    surfaceAlt: "#1a2840",
+    fg: "#eaf2ff",
+    muted: "#9eb3cc",
+    dim: "#6f86a2",
+    green: "#8bd5ca",
+    red: "#f7768e",
+    yellow: "#e0af68",
+    orange: "#ff9e64",
+    purple: "#bb9af7",
+    cyan: "#7dcfff"
+  },
+  cobalt: {
+    fonts: { terminal: "Space Mono", ui: "Sora", code: "Space Mono" },
+    accent: "#4da3ff",
+    bg: "#09111f",
+    surface: "#10203a",
+    surfaceAlt: "#163056",
+    fg: "#edf5ff",
+    muted: "#90a9ca",
+    dim: "#5f7491",
+    green: "#4de2a8",
+    red: "#ff6688",
+    yellow: "#ffd166",
+    orange: "#ff9f43",
+    purple: "#8f7cff",
+    cyan: "#56ccf2"
+  },
+  rose: {
+    fonts: { terminal: "DM Mono", ui: "Fraunces", code: "DM Mono" },
+    accent: "#ea9ab2",
+    bg: "#171217",
+    surface: "#231b23",
+    surfaceAlt: "#302430",
+    fg: "#fff1f6",
+    muted: "#c8a7b6",
+    dim: "#927787",
+    green: "#9ccf9b",
+    red: "#ff7d97",
+    yellow: "#f3c66f",
+    orange: "#ffab73",
+    purple: "#d4a5ff",
+    cyan: "#8bd3dd"
+  },
+  lotus: {
+    fonts: { terminal: "IBM Plex Mono", ui: "Newsreader", code: "IBM Plex Mono" },
+    accent: "#d16d9e",
+    bg: "#fff7f3",
+    surface: "#fffdfb",
+    surfaceAlt: "#f7e8e2",
+    fg: "#3a2432",
+    muted: "#866576",
+    dim: "#ab90a1",
+    green: "#5a8f62",
+    red: "#c7576b",
+    yellow: "#b98932",
+    orange: "#c86b3c",
+    purple: "#8f63b8",
+    cyan: "#4d8ca1"
+  },
+  dune: {
+    fonts: { terminal: "JetBrains Mono", ui: "Sora", code: "JetBrains Mono" },
+    accent: "#d97706",
+    bg: "#16110c",
+    surface: "#231912",
+    surfaceAlt: "#32231a",
+    fg: "#faefe1",
+    muted: "#c1a58a",
+    dim: "#8d735f",
+    green: "#8fbf7a",
+    red: "#f97373",
+    yellow: "#eab308",
+    orange: "#fb923c",
+    purple: "#c084fc",
+    cyan: "#67e8f9"
+  },
+  forest: {
+    fonts: { terminal: "IBM Plex Mono", ui: "Newsreader", code: "IBM Plex Mono" },
+    accent: "#7ccf7a",
+    bg: "#08100b",
+    surface: "#112016",
+    surfaceAlt: "#183020",
+    fg: "#eefbef",
+    muted: "#98b79d",
+    dim: "#6b8b73",
+    green: "#4ade80",
+    red: "#fb7185",
+    yellow: "#facc15",
+    orange: "#fb923c",
+    purple: "#c084fc",
+    cyan: "#6ee7b7"
+  },
+  aurora: {
+    fonts: { terminal: "Space Mono", ui: "Outfit", code: "Space Mono" },
+    accent: "#7c5cff",
+    bg: "#0f0a1f",
+    surface: "#181131",
+    surfaceAlt: "#23194a",
+    fg: "#f4f0ff",
+    muted: "#b2a7d9",
+    dim: "#7d72aa",
+    green: "#74e3b4",
+    red: "#ff7d9c",
+    yellow: "#ffd166",
+    orange: "#ff9f6e",
+    purple: "#b388ff",
+    cyan: "#7bdff2"
+  },
+  espresso: {
+    fonts: { terminal: "DM Mono", ui: "Fraunces", code: "DM Mono" },
+    accent: "#c67c4e",
+    bg: "#120d0b",
+    surface: "#1d1512",
+    surfaceAlt: "#2c201a",
+    fg: "#f7eee8",
+    muted: "#b89b8c",
+    dim: "#826b60",
+    green: "#8bcf9b",
+    red: "#f38ba8",
+    yellow: "#f9e2af",
+    orange: "#fab387",
+    purple: "#cba6f7",
+    cyan: "#89dceb"
+  },
+  mono: {
+    fonts: { terminal: "IBM Plex Mono", ui: "IBM Plex Sans", code: "IBM Plex Mono" },
+    accent: "#c9d1d9",
+    bg: "#0d0d0d",
+    surface: "#151515",
+    surfaceAlt: "#212121",
+    fg: "#f5f5f5",
+    muted: "#b0b0b0",
+    dim: "#767676",
+    green: "#b7e4c7",
+    red: "#ffadad",
+    yellow: "#f4e285",
+    orange: "#ffd6a5",
+    purple: "#d8bbff",
+    cyan: "#bde0fe"
+  },
+  neon: {
+    fonts: { terminal: "Space Mono", ui: "Space Grotesk", code: "Space Mono" },
+    accent: "#00f5d4",
+    bg: "#090414",
+    surface: "#130a24",
+    surfaceAlt: "#1c1033",
+    fg: "#f6f7ff",
+    muted: "#b8add8",
+    dim: "#7f76a8",
+    green: "#72f1b8",
+    red: "#ff5c8a",
+    yellow: "#ffe66d",
+    orange: "#ff9f5c",
+    purple: "#b388ff",
+    cyan: "#00bbf9"
+  },
+  harbor: {
+    fonts: { terminal: "IBM Plex Mono", ui: "Plus Jakarta Sans", code: "IBM Plex Mono" },
+    accent: "#3ba4c9",
+    bg: "#f4f8fb",
+    surface: "#ffffff",
+    surfaceAlt: "#e6eef4",
+    fg: "#18303a",
+    muted: "#5f7c89",
+    dim: "#8ba1ab",
+    green: "#2f855a",
+    red: "#d1495b",
+    yellow: "#b7791f",
+    orange: "#dd6b20",
+    purple: "#6b46c1",
+    cyan: "#0f766e"
+  },
+  solarized: {
+    fonts: { terminal: "Source Code Pro", ui: "Source Sans 3", code: "Source Code Pro" },
+    accent: "#268bd2",
+    bg: "#fdf6e3",
+    surface: "#fffdf7",
+    surfaceAlt: "#eee8d5",
+    fg: "#586e75",
+    muted: "#657b83",
+    dim: "#93a1a1",
+    green: "#859900",
+    red: "#dc322f",
+    yellow: "#b58900",
+    orange: "#cb4b16",
+    purple: "#6c71c4",
+    cyan: "#2aa198"
+  },
+  "solarized-dark": {
+    fonts: { terminal: "Source Code Pro", ui: "Source Sans 3", code: "Source Code Pro" },
+    accent: "#268bd2",
+    bg: "#002b36",
+    surface: "#073642",
+    surfaceAlt: "#0a3b48",
+    fg: "#839496",
+    muted: "#93a1a1",
+    dim: "#657b83",
+    green: "#859900",
+    red: "#dc322f",
+    yellow: "#b58900",
+    orange: "#cb4b16",
+    purple: "#6c71c4",
+    cyan: "#2aa198"
+  },
+  velvet: {
+    fonts: { terminal: "DM Mono", ui: "Fraunces", code: "DM Mono" },
+    accent: "#d4a5ff",
+    bg: "#140d18",
+    surface: "#211328",
+    surfaceAlt: "#2d1b37",
+    fg: "#faf2ff",
+    muted: "#b79dc7",
+    dim: "#7e6891",
+    green: "#8de1c0",
+    red: "#ff8fab",
+    yellow: "#f6d365",
+    orange: "#ffb86c",
+    purple: "#c77dff",
+    cyan: "#7bdff2"
+  }
+};
+
+const APP_PRESETS = {
+  evergreen: {
+    codeThemeId: "everforest",
+    theme: {
+      accent: "#93b259",
+      contrast: 45,
+      fonts: { code: "IBM Plex Mono", ui: "Manrope" },
+      ink: "#5c6a72",
+      opaqueWindows: true,
+      semanticColors: {
+        diffAdded: "#8da101",
+        diffRemoved: "#f85552",
+        skill: "#df69ba"
+      },
+      surface: "#fdf6e3"
+    },
+    variant: "light"
+  },
+  "evergreen-dark": {
+    codeThemeId: "everforest",
+    theme: {
+      accent: "#a7c080",
+      contrast: 60,
+      fonts: { code: "IBM Plex Mono", ui: "Manrope" },
+      ink: "#d3c6aa",
+      opaqueWindows: true,
+      semanticColors: {
+        diffAdded: "#a7c080",
+        diffRemoved: "#e67e80",
+        skill: "#d699b6"
+      },
+      surface: "#2d353b"
+    },
+    variant: "dark"
+  },
+  solarized: {
+    codeThemeId: "solarized",
+    theme: {
+      accent: "#268bd2",
+      contrast: 45,
+      fonts: { code: "Source Code Pro", ui: "Manrope" },
+      ink: "#586e75",
+      opaqueWindows: true,
+      semanticColors: {
+        diffAdded: "#859900",
+        diffRemoved: "#dc322f",
+        skill: "#d33682"
+      },
+      surface: "#fdf6e3"
+    },
+    variant: "light"
+  },
+  "solarized-dark": {
+    codeThemeId: "solarized",
+    theme: {
+      accent: "#268bd2",
+      contrast: 60,
+      fonts: { code: "Source Code Pro", ui: "Manrope" },
+      ink: "#839496",
+      opaqueWindows: false,
+      semanticColors: {
+        diffAdded: "#859900",
+        diffRemoved: "#dc322f",
+        skill: "#d33682"
+      },
+      surface: "#002b36"
+    },
+    variant: "dark"
+  },
+  nord: {
+    codeThemeId: "nord",
+    theme: {
+      accent: "#5e81ac",
+      contrast: 48,
+      fonts: { code: "Space Mono", ui: "Manrope" },
+      ink: "#4c566a",
+      opaqueWindows: true,
+      semanticColors: {
+        diffAdded: "#a3be8c",
+        diffRemoved: "#bf616a",
+        skill: "#b48ead"
+      },
+      surface: "#eceff4"
+    },
+    variant: "light"
+  },
+  "nord-dark": {
+    codeThemeId: "nord",
+    theme: {
+      accent: "#88c0d0",
+      contrast: 60,
+      fonts: { code: "Space Mono", ui: "Manrope" },
+      ink: "#e5e9f0",
+      opaqueWindows: true,
+      semanticColors: {
+        diffAdded: "#a3be8c",
+        diffRemoved: "#bf616a",
+        skill: "#b48ead"
+      },
+      surface: "#2e3440"
+    },
+    variant: "dark"
+  },
+  rosepine: {
+    codeThemeId: "rose-pine-dawn",
+    theme: {
+      accent: "#56949f",
+      contrast: 44,
+      fonts: { code: "DM Mono", ui: "Manrope" },
+      ink: "#575279",
+      opaqueWindows: true,
+      semanticColors: {
+        diffAdded: "#286983",
+        diffRemoved: "#b4637a",
+        skill: "#907aa9"
+      },
+      surface: "#faf4ed"
+    },
+    variant: "light"
+  },
+  "rosepine-dark": {
+    codeThemeId: "rose-pine",
+    theme: {
+      accent: "#9ccfd8",
+      contrast: 58,
+      fonts: { code: "DM Mono", ui: "Manrope" },
+      ink: "#e0def4",
+      opaqueWindows: true,
+      semanticColors: {
+        diffAdded: "#31748f",
+        diffRemoved: "#eb6f92",
+        skill: "#c4a7e7"
+      },
+      surface: "#191724"
+    },
+    variant: "dark"
+  },
+  graphite: {
+    codeThemeId: "github",
+    theme: {
+      accent: "#586069",
+      contrast: 42,
+      fonts: { code: "IBM Plex Mono", ui: "Manrope" },
+      ink: "#24292f",
+      opaqueWindows: true,
+      semanticColors: {
+        diffAdded: "#1a7f37",
+        diffRemoved: "#cf222e",
+        skill: "#8250df"
+      },
+      surface: "#f6f8fa"
+    },
+    variant: "light"
+  },
+  "graphite-dark": {
+    codeThemeId: "github",
+    theme: {
+      accent: "#7d8590",
+      contrast: 58,
+      fonts: { code: "IBM Plex Mono", ui: "Manrope" },
+      ink: "#c9d1d9",
+      opaqueWindows: true,
+      semanticColors: {
+        diffAdded: "#3fb950",
+        diffRemoved: "#f85149",
+        skill: "#d2a8ff"
+      },
+      surface: "#0d1117"
+    },
+    variant: "dark"
+  }
+};
+
+async function main() {
+  try {
+    const args = process.argv.slice(2);
+    const command = args[0];
+
+    if (!command || command === "--help" || command === "-h" || command === "help") {
+      printHelp();
+      return;
+    }
+
+    switch (command) {
+      case "list":
+        runList();
+        return;
+      case "status":
+        runStatus();
+        return;
+      case "reset":
+        runReset(parseFlags(args.slice(1)));
+        return;
+      case "use":
+        runUse(args[1], parseFlags(args.slice(2)));
+        return;
+      case "preview":
+        runPreview(args[1]);
+        return;
+      case "make":
+        await runMake(args[1], parseFlags(args.slice(2)));
+        return;
+      case "wizard":
+        await runMakeWizard(args[1], parseFlags(args.slice(2)));
+        return;
+      case "init":
+      case "new":
+        runInit(args[1], parseFlags(args.slice(2)));
+        return;
+      case "live":
+      case "apply":
+        runLiveTheme(args[1], parseFlags(args.slice(2)));
+        return;
+      case "font":
+      case "fonts":
+        runFontCommand(args.slice(1));
+        return;
+      case "terminal":
+      case "term":
+        runTerminal(args[1], parseFlags(args.slice(2)));
+        return;
+      default:
+        fail(`Unknown command: ${command}`);
+    }
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error));
+  }
+}
+
+function printHelp() {
+  console.log(`ctheme
+
+Short commands for making your terminal look better.
+
+Commands:
+  list                             List bundled and saved themes
+  status                           Show ctheme paths and saved terminal restore state
+  reset [--target <name>]          Restore the terminal UI back to its original state
+  use <name> [flags]               Apply a theme to the actual terminal immediately
+  preview <name>                   Preview a theme palette in the terminal
+  make [name] [flags]              Create a custom theme or launch the theme wizard
+  wizard [name] [flags]            Launch the interactive theme wizard directly
+  init <name> [flags]              Create an editable starter JSON file
+  live <name> [flags]              Apply a theme to the current terminal immediately
+  font <subcommand>                Install and inspect local/Google fonts
+  term <target> [flags]            Generate or apply terminal font/color themes
+
+Examples:
+  ctheme reset
+  ctheme use solarized
+  ctheme use harbor --default
+  ctheme make
+  ctheme wizard
+  ctheme make arjun --from velvet --accent "#ff4d6d"
+  ctheme init custom-light --preset harbor
+  ctheme live neon
+  ctheme live solarized --font "Space Mono"
+  ctheme font install "Manrope"
+  ctheme font list
+  ctheme term apple-terminal --theme noir --font "SF Mono"
+  ctheme term ghostty --font "JetBrains Mono" --font-size 15
+
+Flags for make:
+  --preset <name>                  Base preset name
+  --from <name>                    Base off any bundled or installed theme
+  --accent <hex>
+  --bg <hex>
+  --surface <hex>
+  --surface-alt <hex>
+  --fg <hex>
+  --muted <hex>
+  --dim <hex>
+  --font <family>
+  --ui-font <family>
+  --code-font <family>
+  --terminal-font <family>
+  --wizard                         Force the interactive theme wizard
+
+Flags for init:
+  --preset <name>                  Starter preset name
+  --from <name>                    Starter from existing theme
+  --force                          Overwrite if the file exists
+
+Font subcommands:
+  list                             List installed local font families
+  install <family>                 Download a Google Font family into ~/Library/Fonts/pretty-code
+  path                             Show the managed font install directory
+
+Flags for term:
+  Targets: apple-terminal, current, ghostty, kitty, wezterm
+  --font <family>
+  --font-size <number>
+  --theme <name>
+  --opacity <number>
+  --write                         Write snippet into your terminal config location when supported
+  --live                          Apply immediately when supported
+  --default                       Apple Terminal: set as default and startup profile
+
+Flags for use:
+  --font <family>
+  --font-size <number>
+  --default                       Apple Terminal: set as default and startup profile
+
+Flags for reset:
+  --target <name>                 current, apple-terminal, ghostty, kitty, wezterm
+`);
+}
+
+function runList() {
+  const paths = getThemePaths();
+  const custom = new Set(Object.keys(PRESETS));
+
+  if (fs.existsSync(paths.paletteDir)) {
+    for (const entry of fs.readdirSync(paths.paletteDir)) {
+      if (entry.endsWith(".json")) {
+        custom.add(path.basename(entry, ".json"));
+      }
+    }
+  }
+
+  for (const name of [...custom].sort()) {
+    const source = Object.hasOwn(PRESETS, name) ? "bundled-custom" : "custom";
+    console.log(`${name}  (${source})`);
+  }
+}
+
+function runStatus() {
+  const paths = getThemePaths();
+  const terminalState = readTerminalState(paths);
+
+  console.log(`home: ${paths.themeHome}`);
+  console.log(`theme dir: ${paths.paletteDir}`);
+  console.log(`snippet dir: ${paths.snippetDir}`);
+  console.log(`terminal state: ${paths.terminalStateFile}`);
+  console.log(`saved terminal targets: ${Object.keys(terminalState.targets || {}).join(", ") || "(none)"}`);
+}
+
+function runUse(themeName, flags) {
+  if (!themeName) {
+    fail("Missing theme name. Usage: ctheme use <name>");
+  }
+
+  runLiveTheme(themeName, flags || {});
+}
+
+function runReset(flags) {
+  const target = normalizeTerminalTarget(flags.target || "current");
+  const paths = getThemePaths();
+  const state = readTerminalState(paths);
+
+  if (target === "apple-terminal") {
+    restoreAppleTerminalState(state.targets["apple-terminal"] || null);
+    console.log("Restored Apple Terminal UI.");
+    return;
+  }
+
+  if (target === "ghostty") {
+    resetManagedFile(path.join(os.homedir(), ".config", "ghostty", "config"), "config-file = ");
+    console.log("Removed managed Ghostty theme include.");
+    return;
+  }
+
+  if (target === "kitty") {
+    resetManagedFile(path.join(os.homedir(), ".config", "kitty", "kitty.conf"), "include ");
+    console.log("Removed managed Kitty theme include.");
+    return;
+  }
+
+  if (target === "wezterm") {
+    const weztermPath = path.join(os.homedir(), ".wezterm.lua");
+    if (fs.existsSync(weztermPath) && fs.readFileSync(weztermPath, "utf8").includes("pretty-code")) {
+      fs.unlinkSync(weztermPath);
+      console.log(`Removed ${weztermPath}`);
+    } else {
+      console.log("No managed WezTerm file to remove.");
+    }
+    return;
+  }
+
+  fail(`Unsupported reset target: ${target}`);
+}
+
+function runPreview(themeName) {
+  assertThemeName(themeName);
+  const theme = buildTheme(themeName, getBasePalette(themeName));
+
+  const palette = [
+    ["accent", theme.colors.accent],
+    ["text", theme.colors.text || theme.vars.fg || "#ffffff"],
+    ["muted", theme.colors.muted],
+    ["success", theme.colors.success],
+    ["warning", theme.colors.warning],
+    ["error", theme.colors.error],
+    ["code", theme.colors.mdCode]
+  ];
+
+  console.log(`Preview: ${theme.name}`);
+  for (const [label, value] of palette) {
+    const sample = colorBlock(resolveColor(theme, value), 20);
+    console.log(`${label.padEnd(8)} ${sample} ${resolveColor(theme, value)}`);
+  }
+}
+
+async function runMake(name, flags) {
+  if (!name || !Object.keys(flags).length || flags.wizard) {
+    await runMakeWizard(name, flags);
+    return;
+  }
+
+  const preset = getBasePalette(flags.from || flags.preset || "noir");
+
+  const customized = {
+    ...preset,
+    accent: flags.accent || preset.accent,
+    bg: flags.bg || preset.bg,
+    surface: flags.surface || preset.surface,
+    surfaceAlt: flags["surface-alt"] || preset.surfaceAlt || preset.surface,
+    fg: flags.fg || preset.fg,
+    muted: flags.muted || preset.muted,
+    dim: flags.dim || preset.dim,
+    fonts: mergeThemeFonts(preset, flags)
+  };
+
+  const theme = buildTheme(name, customized);
+  const paths = getThemePaths();
+  writeThemeAssets(paths, name, customized, theme);
+  console.log(`Wrote ${path.join(paths.paletteDir, `${name}.json`)}`);
+}
+
+function runInit(name, flags) {
+  if (!name) {
+    fail("Missing theme name. Usage: ctheme init <name> --preset noir");
+  }
+
+  const paths = getThemePaths();
+  ensureDir(paths.paletteDir);
+  const filePath = path.join(paths.paletteDir, `${name}.json`);
+
+  if (fs.existsSync(filePath) && !flags.force) {
+    fail(`Theme already exists: ${filePath}. Re-run with --force to overwrite.`);
+  }
+
+  const palette = getBasePalette(flags.from || flags.preset || "noir");
+  writeThemeAssets(paths, name, palette);
+  console.log(`Created starter theme at ${filePath}`);
+  console.log("Edit the JSON, then run: ctheme make " + name + " --from " + name);
+}
+
+async function runMakeWizard(initialName, flags) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    const availablePresets = Object.keys(PRESETS).sort();
+    console.log(`Theme wizard`);
+    console.log(`Presets: ${availablePresets.join(", ")}`);
+    console.log(`UI font ideas: ${FONT_CHOICES.ui.join(", ")}`);
+    console.log(`Code/terminal font ideas: ${FONT_CHOICES.code.join(", ")}`);
+
+    const basePresetName = await promptWithDefault(
+      rl,
+      "Base preset",
+      flags.from || flags.preset || "noir"
+    );
+    const preset = getBasePalette(basePresetName);
+    const defaultName = initialName || `${basePresetName}-custom`;
+    const themeName = await promptWithDefault(rl, "Theme name", defaultName);
+
+    const accent = await promptWithDefault(rl, "Accent color", flags.accent || preset.accent);
+    const bg = await promptWithDefault(rl, "Background color", flags.bg || preset.bg);
+    const surface = await promptWithDefault(rl, "Surface color", flags.surface || preset.surface);
+    const surfaceAlt = await promptWithDefault(
+      rl,
+      "Surface alt color",
+      flags["surface-alt"] || preset.surfaceAlt || preset.surface
+    );
+    const fg = await promptWithDefault(rl, "Text color", flags.fg || preset.fg);
+    const muted = await promptWithDefault(rl, "Muted color", flags.muted || preset.muted);
+    const dim = await promptWithDefault(rl, "Dim color", flags.dim || preset.dim);
+
+    const fonts = {
+      terminal: await promptWithDefault(
+        rl,
+        "Terminal font",
+        flags["terminal-font"] || flags.font || getPaletteFonts(preset).terminal
+      ),
+      ui: await promptWithDefault(
+        rl,
+        "UI font",
+        flags["ui-font"] || getPaletteFonts(preset).ui
+      ),
+      code: await promptWithDefault(
+        rl,
+        "Code font",
+        flags["code-font"] || flags.font || getPaletteFonts(preset).code
+      )
+    };
+
+    const autoInstallFonts = await promptYesNo(rl, "Install any missing Google fonts automatically?", true);
+    if (autoInstallFonts) {
+      installFontsBestEffort([fonts.terminal, fonts.ui, fonts.code]);
+    }
+
+    const customized = {
+      ...preset,
+      accent,
+      bg,
+      surface,
+      surfaceAlt,
+      fg,
+      muted,
+      dim,
+      fonts
+    };
+
+    const theme = buildTheme(themeName, customized);
+    const paths = getThemePaths();
+    writeThemeAssets(paths, themeName, customized, theme);
+    console.log(`Wrote ${path.join(paths.paletteDir, `${themeName}.json`)}`);
+
+    const applyNow = await promptYesNo(rl, "Apply this theme to the current terminal now?", true);
+    if (applyNow) {
+      runLiveTheme(themeName, { font: fonts.terminal, default: Boolean(flags.default) });
+    } else {
+      console.log(`Apply later with: ctheme use ${themeName}`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+function runFontCommand(args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "help") {
+    console.log(`Font commands:
+  ctheme font list
+  ctheme font search "mono"
+  ctheme font path
+  ctheme font install "Manrope"
+  ctheme font install "IBM Plex Mono"`);
+    return;
+  }
+
+  if (subcommand === "list") {
+    listInstalledFonts();
+    return;
+  }
+
+  if (subcommand === "path") {
+    console.log(getThemePaths().managedFontDir);
+    return;
+  }
+
+  if (subcommand === "search") {
+    const query = args.slice(1).join(" ").trim();
+    if (!query) {
+      fail('Missing search text. Usage: ctheme font search "mono"');
+    }
+    searchGoogleFonts(query);
+    return;
+  }
+
+  if (subcommand === "install") {
+    const family = args.slice(1).join(" ").trim();
+    if (!family) {
+      fail('Missing font family. Usage: ctheme font install "Manrope"');
+    }
+    installGoogleFont(family);
+    return;
+  }
+
+  fail(`Unknown font subcommand: ${subcommand}`);
+}
+
+function runLiveTheme(themeName, flags) {
+  if (!themeName) {
+    fail("Missing theme name. Usage: ctheme live <name>");
+  }
+
+  const target = normalizeTerminalTarget(flags.target || "current");
+  runTerminal(target, { ...flags, theme: themeName, write: true, live: true });
+}
+
+function runTerminal(target, flags) {
+  if (!target) {
+    fail("Missing terminal target. Use apple-terminal, ghostty, wezterm, or kitty.");
+  }
+
+  const normalizedTarget = normalizeTerminalTarget(target);
+  const themeName = flags.theme || "noir";
+  assertThemeName(themeName);
+  const theme = buildTheme(themeName, getBasePalette(themeName));
+  const presetFonts = getThemeFonts(themeName);
+  const font = flags.font || presetFonts.terminal || "JetBrains Mono";
+  const fontSize = Number(flags["font-size"] || 15);
+  const opacity = flags.opacity ? Number(flags.opacity) : null;
+
+  const paths = getThemePaths();
+  ensureDir(paths.snippetDir);
+
+  let snippetPath;
+  let snippet;
+  if (normalizedTarget === "apple-terminal") {
+    snippetPath = path.join(paths.snippetDir, `${theme.name}.applescript`);
+    snippet = renderAppleTerminalProfile(theme, font, fontSize, theme.name);
+  } else if (normalizedTarget === "ghostty") {
+    snippetPath = path.join(paths.snippetDir, "ghostty.conf");
+    snippet = renderGhosttySnippet(theme, font, fontSize, opacity);
+  } else if (normalizedTarget === "wezterm") {
+    snippetPath = path.join(paths.snippetDir, "wezterm.lua");
+    snippet = renderWeztermSnippet(theme, font, fontSize, opacity);
+  } else if (normalizedTarget === "kitty") {
+    snippetPath = path.join(paths.snippetDir, "kitty.conf");
+    snippet = renderKittySnippet(theme, font, fontSize, opacity);
+  } else {
+    fail(`Unsupported terminal target: ${target}`);
+  }
+
+  fs.writeFileSync(snippetPath, snippet, "utf8");
+  console.log(`Snippet written to ${snippetPath}`);
+
+  const shouldWrite = Boolean(flags.write) || Boolean(flags.live) || normalizedTarget === "apple-terminal";
+  if (shouldWrite) {
+    writeTerminalConfig(normalizedTarget, snippet, snippetPath, {
+      profileName: theme.name,
+      setDefault: Boolean(flags.default)
+    });
+    if (normalizedTarget === "apple-terminal") {
+      console.log(`Applied ${theme.name} to current Apple Terminal windows immediately.`);
+    } else if (flags.live) {
+      console.log(`Updated ${normalizedTarget} config for ${theme.name}. Reload behavior depends on that terminal's own live-config support.`);
+    }
+  } else {
+    console.log("Add this snippet manually or rerun with --write.");
+  }
+}
+
+function listInstalledFonts() {
+  let output = "";
+  try {
+    output = execFileSync("osascript", [
+      "-l",
+      "JavaScript",
+      "-e",
+      'ObjC.import("AppKit"); var fm=$.NSFontManager.sharedFontManager; var raw=ObjC.deepUnwrap(fm.availableFontFamilies); var names=(Array.isArray(raw)?raw:[String(raw)]).map(function(name){ return String(name); }).filter(Boolean).sort(function(a,b){ return a.localeCompare(b); }); console.log(names.join("\\n"));'
+    ], { encoding: "utf8" });
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error));
+  }
+  process.stdout.write(output);
+}
+
+function installGoogleFont(family) {
+  const paths = getThemePaths();
+  ensureDir(paths.managedFontDir);
+  const installed = downloadGoogleFontFiles(family, paths.managedFontDir);
+  if (!installed.length) {
+    fail(`No installable font files found for ${family}`);
+  }
+
+  console.log(`Installed ${family} into ${paths.managedFontDir}`);
+  for (const file of installed) {
+    console.log(`- ${file}`);
+  }
+  if (!looksMonospaceFamily(family)) {
+    console.log("Warning: this family looks proportional. It may render poorly in terminal grids.");
+  }
+}
+
+function searchGoogleFonts(query) {
+  const raw = execFileSync("curl", [
+    "-s",
+    "-L",
+    "-H",
+    "User-Agent: pretty-code",
+    "https://fonts.google.com/metadata/fonts"
+  ], { encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
+
+  const cleaned = raw.replace(/^\)\]\}'\n/, "");
+  const parsed = JSON.parse(cleaned);
+  const fonts = Array.isArray(parsed.familyMetadataList) ? parsed.familyMetadataList : [];
+  const lowered = query.toLowerCase();
+
+  const matches = fonts
+    .filter((font) => typeof font.family === "string" && font.family.toLowerCase().includes(lowered))
+    .slice(0, 50);
+
+  if (!matches.length) {
+    fail(`No Google Fonts matches for: ${query}`);
+  }
+
+  for (const font of matches) {
+    const mono = looksMonospaceFamily(font.family) ? "mono-ish" : "proportional";
+    console.log(`${font.family}  (${mono})`);
+  }
+}
+
+function downloadGoogleFontFiles(family, targetDir) {
+  const slug = family.toLowerCase().replace(/[^a-z0-9]+/g, "");
+  const apiBase = "https://api.github.com/repos/google/fonts/contents";
+  const candidateDirs = [`ofl/${slug}`, `apache/${slug}`, `ufl/${slug}`];
+  let entries = null;
+
+  for (const dir of candidateDirs) {
+    try {
+      const json = execFileSync("curl", [
+        "-s",
+        "-L",
+        "-H",
+        "User-Agent: pretty-code",
+        `${apiBase}/${dir}`
+      ], { encoding: "utf8" });
+      const parsed = JSON.parse(json);
+      if (Array.isArray(parsed)) {
+        entries = parsed;
+        break;
+      }
+    } catch (_error) {
+      continue;
+    }
+  }
+
+  if (!entries) {
+    fail(`Google Fonts family not found in google/fonts: ${family}`);
+  }
+
+  const fontFiles = entries.filter((entry) => entry && typeof entry.name === "string" && /\.(ttf|otf|ttc)$/i.test(entry.name));
+  const installed = [];
+
+  for (const entry of fontFiles) {
+    const destPath = path.join(targetDir, entry.name);
+    execFileSync("curl", [
+      "-L",
+      "--fail",
+      "-H",
+      "User-Agent: pretty-code",
+      "--output",
+      destPath,
+      entry.download_url
+    ], { stdio: "inherit" });
+    installed.push(destPath);
+  }
+
+  return installed;
+}
+
+function installFontFiles(sourceDir, targetDir) {
+  const installed = [];
+  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    if (entry.isDirectory()) {
+      installed.push(...installFontFiles(sourcePath, targetDir));
+      continue;
+    }
+    if (!/\.(ttf|otf|ttc)$/i.test(entry.name)) continue;
+    const destPath = path.join(targetDir, entry.name);
+    fs.copyFileSync(sourcePath, destPath);
+    installed.push(destPath);
+  }
+  return installed;
+}
+
+function looksMonospaceFamily(name) {
+  return /(mono|code|terminal|console|courier|menlo|plex mono|fira mono|jetbrains mono|space mono|ibm plex mono)/i.test(name);
+}
+
+function buildTheme(name, palette) {
+  const mode = inferMode(palette);
+  const readable = {
+    accent: ensureReadableColor(palette.accent, palette.bg, mode === "light" ? 4.5 : 4.5),
+    fg: ensureReadableColor(palette.fg, palette.bg, mode === "light" ? 9 : 7),
+    muted: ensureReadableColor(palette.muted, palette.bg, mode === "light" ? 5.4 : 4.8),
+    dim: ensureReadableColor(palette.dim, palette.bg, mode === "light" ? 4 : 3.4),
+    green: ensureReadableColor(palette.green, palette.bg, mode === "light" ? 4.8 : 4.5),
+    red: ensureReadableColor(palette.red, palette.bg, mode === "light" ? 4.8 : 4.5),
+    yellow: ensureReadableColor(palette.yellow, palette.bg, mode === "light" ? 5.2 : 4.5),
+    orange: ensureReadableColor(palette.orange, palette.bg, mode === "light" ? 4.8 : 4.5),
+    purple: ensureReadableColor(palette.purple, palette.bg, mode === "light" ? 4.8 : 4.5),
+    cyan: ensureReadableColor(palette.cyan, palette.bg, mode === "light" ? 4.8 : 4.5)
+  };
+
+  const vars = {
+    accent: readable.accent,
+    bg: palette.bg,
+    surface: palette.surface,
+    surfaceAlt: palette.surfaceAlt || palette.surface,
+    fg: readable.fg,
+    muted: readable.muted,
+    dim: readable.dim,
+    green: readable.green,
+    red: readable.red,
+    yellow: readable.yellow,
+    orange: readable.orange,
+    purple: readable.purple,
+    cyan: readable.cyan
+  };
+
+  const colors = {
+    accent: "accent",
+    border: "muted",
+    borderAccent: "accent",
+    borderMuted: "dim",
+    success: "green",
+    error: "red",
+    warning: "yellow",
+    muted: "muted",
+    dim: "dim",
+    text: "fg",
+    thinkingText: "muted",
+    selectedBg: "surfaceAlt",
+    userMessageBg: "surface",
+    userMessageText: "fg",
+    customMessageBg: "surfaceAlt",
+    customMessageText: "fg",
+    customMessageLabel: "accent",
+    toolPendingBg: "surface",
+    toolSuccessBg: "surface",
+    toolErrorBg: "surface",
+    toolTitle: "accent",
+    toolOutput: "fg",
+    mdHeading: "orange",
+    mdLink: "accent",
+    mdLinkUrl: "cyan",
+    mdCode: "cyan",
+    mdCodeBlock: "fg",
+    mdCodeBlockBorder: "muted",
+    mdQuote: "muted",
+    mdQuoteBorder: "muted",
+    mdHr: "dim",
+    mdListBullet: "accent",
+    toolDiffAdded: "green",
+    toolDiffRemoved: "red",
+    toolDiffContext: "muted",
+    syntaxComment: "muted",
+    syntaxKeyword: "purple",
+    syntaxFunction: "accent",
+    syntaxVariable: "orange",
+    syntaxString: "green",
+    syntaxNumber: "yellow",
+    syntaxType: "cyan",
+    syntaxOperator: "accent",
+    syntaxPunctuation: "muted",
+    thinkingOff: "dim",
+    thinkingMinimal: "accent",
+    thinkingLow: "cyan",
+    thinkingMedium: "green",
+    thinkingHigh: "orange",
+    thinkingXhigh: "red",
+    bashMode: "orange"
+  };
+
+  const missing = TOKENS.filter((token) => !Object.hasOwn(colors, token));
+  if (missing.length) {
+    throw new Error(`Theme is missing required tokens: ${missing.join(", ")}`);
+  }
+
+  return {
+    $schema:
+      "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+    name,
+    vars,
+    colors
+  };
+}
+
+function getBasePalette(name) {
+  if (PRESETS[name]) return PRESETS[name];
+
+  const paths = getThemePaths();
+  const palettePath = path.join(paths.paletteDir, `${name}.json`);
+  if (fs.existsSync(palettePath)) {
+    return JSON.parse(fs.readFileSync(palettePath, "utf8"));
+  }
+
+  fail(`Theme not found or not remixable: ${name}`);
+}
+
+function normalizeTerminalTarget(target) {
+  if (!target || target === "current") {
+    const detected = detectCurrentTerminalTarget();
+    if (detected) return detected;
+    if (process.platform === "darwin") return "apple-terminal";
+    fail("Could not detect the current terminal. Pass a target like apple-terminal, ghostty, kitty, or wezterm.");
+  }
+
+  if (target === "apple" || target === "terminal" || target === "terminal.app") {
+    return "apple-terminal";
+  }
+
+  return target;
+}
+
+function detectCurrentTerminalTarget() {
+  const termProgram = process.env.TERM_PROGRAM || "";
+  if (termProgram === "Apple_Terminal") return "apple-terminal";
+  if (termProgram === "ghostty") return "ghostty";
+  if (termProgram === "WezTerm") return "wezterm";
+  if (termProgram.toLowerCase() === "kitty") return "kitty";
+  return "";
+}
+
+function getThemeFonts(name) {
+  if (PRESETS[name] && PRESETS[name].fonts) {
+    return PRESETS[name].fonts;
+  }
+
+  const paths = getThemePaths();
+  const palettePath = path.join(paths.paletteDir, `${name}.json`);
+  if (fs.existsSync(palettePath)) {
+    try {
+      const palette = JSON.parse(fs.readFileSync(palettePath, "utf8"));
+      return getPaletteFonts(palette);
+    } catch (_error) {
+      return { terminal: "JetBrains Mono", ui: "Manrope", code: "JetBrains Mono" };
+    }
+  }
+  return { terminal: "JetBrains Mono", ui: "Manrope", code: "JetBrains Mono" };
+}
+
+function getPaletteFonts(palette) {
+  const baseFonts = palette && palette.fonts ? palette.fonts : {};
+  const terminal = baseFonts.terminal || baseFonts.code || "JetBrains Mono";
+  const code = baseFonts.code || baseFonts.terminal || terminal;
+  const ui = baseFonts.ui || "Manrope";
+  return { terminal, ui, code };
+}
+
+function mergeThemeFonts(preset, flags) {
+  const baseFonts = getPaletteFonts(preset);
+  const terminal = flags["terminal-font"] || flags.font || baseFonts.terminal;
+  const code = flags["code-font"] || flags.font || baseFonts.code || terminal;
+  const ui = flags["ui-font"] || baseFonts.ui;
+  return { terminal, ui, code };
+}
+
+async function promptWithDefault(rl, label, fallback) {
+  const value = await rl.question(`${label}${fallback ? ` [${fallback}]` : ""}: `);
+  const trimmed = value.trim();
+  return trimmed || fallback;
+}
+
+async function promptYesNo(rl, label, defaultValue) {
+  const suffix = defaultValue ? " [Y/n]" : " [y/N]";
+  const value = (await rl.question(`${label}${suffix}: `)).trim().toLowerCase();
+  if (!value) return defaultValue;
+  return value === "y" || value === "yes";
+}
+
+function installFontsBestEffort(fonts) {
+  for (const family of [...new Set(fonts.filter(Boolean))]) {
+    try {
+      installGoogleFont(family);
+    } catch (error) {
+      console.log(`Skipped Google Fonts install for ${family}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+
+function writeThemeAssets(paths, name, palette) {
+  ensureDir(paths.paletteDir);
+  fs.writeFileSync(path.join(paths.paletteDir, `${name}.json`), `${JSON.stringify(palette, null, 2)}\n`, "utf8");
+}
+
+function assertThemeName(themeName) {
+  if (!themeName) {
+    fail("Missing theme name.");
+  }
+}
+
+function getThemePaths() {
+  const themeHome = process.env.CTHEME_HOME || path.join(os.homedir(), ".ctheme");
+  return {
+    themeHome,
+    paletteDir: process.env.CTHEME_THEME_DIR || path.join(themeHome, "themes"),
+    snippetDir: process.env.CTHEME_SNIPPET_DIR || path.join(themeHome, "snippets"),
+    managedFontDir: path.join(os.homedir(), "Library", "Fonts", "pretty-code"),
+    terminalStateFile: path.join(themeHome, "snippets", ".ctheme-state.json")
+  };
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function parseFlags(parts) {
+  const flags = {};
+  for (let i = 0; i < parts.length; i += 1) {
+    const part = parts[i];
+    if (!part.startsWith("--")) continue;
+    const key = part.slice(2);
+    const next = parts[i + 1];
+    if (!next || next.startsWith("--")) {
+      flags[key] = true;
+      continue;
+    }
+    flags[key] = next;
+    i += 1;
+  }
+  return flags;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function resolveColor(theme, value) {
+  if (typeof value === "string" && value.startsWith("#")) return value;
+  if (typeof value === "string" && theme.vars && theme.vars[value]) return theme.vars[value];
+  if (value === "") return theme.vars.fg || "#ffffff";
+  return typeof value === "string" ? value : "#ffffff";
+}
+
+function renderTmTheme(name, theme) {
+  const globalBg = resolveColor(theme, theme.vars.bg || theme.colors.userMessageBg);
+  const globalFg = resolveColor(theme, theme.vars.fg || theme.colors.text);
+  const globalSelection = resolveColor(theme, theme.colors.selectedBg);
+  const caret = resolveColor(theme, theme.colors.accent);
+  const invisibles = resolveColor(theme, theme.colors.dim);
+  const lineHighlight = resolveColor(theme, theme.vars.surfaceAlt || theme.colors.selectedBg);
+
+  const rules = [
+    { name: "Comment", scope: "comment", foreground: resolveColor(theme, theme.colors.syntaxComment), fontStyle: "italic" },
+    { name: "Keyword", scope: "keyword, storage", foreground: resolveColor(theme, theme.colors.syntaxKeyword) },
+    { name: "String", scope: "string", foreground: resolveColor(theme, theme.colors.syntaxString) },
+    { name: "Number", scope: "constant.numeric", foreground: resolveColor(theme, theme.colors.syntaxNumber) },
+    { name: "Function", scope: "entity.name.function, support.function", foreground: resolveColor(theme, theme.colors.syntaxFunction) },
+    { name: "Type", scope: "entity.name.type, support.type, storage.type", foreground: resolveColor(theme, theme.colors.syntaxType) },
+    { name: "Variable", scope: "variable, entity.name.variable", foreground: resolveColor(theme, theme.colors.syntaxVariable) },
+    { name: "Operator", scope: "keyword.operator", foreground: resolveColor(theme, theme.colors.syntaxOperator) },
+    { name: "Punctuation", scope: "punctuation", foreground: resolveColor(theme, theme.colors.syntaxPunctuation) },
+    { name: "Invalid", scope: "invalid", foreground: resolveColor(theme, theme.colors.error) },
+    { name: "Markup Heading", scope: "markup.heading", foreground: resolveColor(theme, theme.colors.mdHeading) },
+    { name: "Markup Link", scope: "markup.underline.link", foreground: resolveColor(theme, theme.colors.mdLink), fontStyle: "underline" },
+    { name: "Markup Quote", scope: "markup.quote", foreground: resolveColor(theme, theme.colors.mdQuote) },
+    { name: "Markup Raw", scope: "markup.raw, markup.inline.raw", foreground: resolveColor(theme, theme.colors.mdCode) }
+  ];
+
+  const xml = [];
+  xml.push('<?xml version="1.0" encoding="UTF-8"?>');
+  xml.push('<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">');
+  xml.push('<plist version="1.0">');
+  xml.push("<dict>");
+  xml.push("  <key>name</key>");
+  xml.push(`  <string>${escapeXml(name)}</string>`);
+  xml.push("  <key>settings</key>");
+  xml.push("  <array>");
+  xml.push("    <dict>");
+  xml.push("      <key>settings</key>");
+  xml.push("      <dict>");
+  xml.push(`        <key>background</key><string>${escapeXml(globalBg)}</string>`);
+  xml.push(`        <key>foreground</key><string>${escapeXml(globalFg)}</string>`);
+  xml.push(`        <key>caret</key><string>${escapeXml(caret)}</string>`);
+  xml.push(`        <key>selection</key><string>${escapeXml(globalSelection)}</string>`);
+  xml.push(`        <key>invisibles</key><string>${escapeXml(invisibles)}</string>`);
+  xml.push(`        <key>lineHighlight</key><string>${escapeXml(lineHighlight)}</string>`);
+  xml.push("      </dict>");
+  xml.push("    </dict>");
+
+  for (const rule of rules) {
+    xml.push("    <dict>");
+    xml.push(`      <key>name</key><string>${escapeXml(rule.name)}</string>`);
+    xml.push(`      <key>scope</key><string>${escapeXml(rule.scope)}</string>`);
+    xml.push("      <key>settings</key>");
+    xml.push("      <dict>");
+    xml.push(`        <key>foreground</key><string>${escapeXml(rule.foreground)}</string>`);
+    if (rule.fontStyle) {
+      xml.push(`        <key>fontStyle</key><string>${escapeXml(rule.fontStyle)}</string>`);
+    }
+    xml.push("      </dict>");
+    xml.push("    </dict>");
+  }
+
+  xml.push("  </array>");
+  xml.push("</dict>");
+  xml.push("</plist>");
+  xml.push("");
+  return xml.join("\n");
+}
+
+function escapeXml(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function colorBlock(hex, width) {
+  const rgb = hexToRgb(hex);
+  return `\x1b[48;2;${rgb.r};${rgb.g};${rgb.b}m${" ".repeat(width)}\x1b[0m`;
+}
+
+function hexToRgb(hex) {
+  const normalized = hex.replace("#", "");
+  const value = normalized.length === 3
+    ? normalized.split("").map((c) => c + c).join("")
+    : normalized;
+  return {
+    r: parseInt(value.slice(0, 2), 16),
+    g: parseInt(value.slice(2, 4), 16),
+    b: parseInt(value.slice(4, 6), 16)
+  };
+}
+
+function relativeLuminance(hex) {
+  const { r, g, b } = hexToRgb(hex);
+  const channel = (value) => {
+    const normalized = value / 255;
+    return normalized <= 0.03928
+      ? normalized / 12.92
+      : ((normalized + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
+}
+
+function contrastRatio(foreground, background) {
+  const l1 = relativeLuminance(foreground);
+  const l2 = relativeLuminance(background);
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+function mixHex(from, to, weight) {
+  const a = hexToRgb(from);
+  const b = hexToRgb(to);
+  const blend = (start, end) => Math.round(start + (end - start) * weight);
+  return rgbToHex(blend(a.r, b.r), blend(a.g, b.g), blend(a.b, b.b));
+}
+
+function ensureReadableColor(color, background, minimumRatio) {
+  const initial = normalizeHex(color);
+  const bg = normalizeHex(background);
+
+  if (contrastRatio(initial, bg) >= minimumRatio) {
+    return initial;
+  }
+
+  const bgLum = relativeLuminance(bg);
+  const anchor = bgLum > 0.6 ? "#000000" : "#ffffff";
+  let best = initial;
+
+  for (let step = 1; step <= 24; step += 1) {
+    const candidate = mixHex(initial, anchor, step / 24);
+    best = candidate;
+    if (contrastRatio(candidate, bg) >= minimumRatio) {
+      return candidate;
+    }
+  }
+
+  return best;
+}
+
+function normalizeHex(hex) {
+  if (typeof hex !== "string") return "#000000";
+  const trimmed = hex.trim();
+  if (/^#[0-9a-f]{3}$/i.test(trimmed)) {
+    return `#${trimmed.slice(1).split("").map((char) => char + char).join("").toLowerCase()}`;
+  }
+  if (/^#[0-9a-f]{6}$/i.test(trimmed)) {
+    return trimmed.toLowerCase();
+  }
+  return trimmed;
+}
+
+function inferMode(palette) {
+  const { r, g, b } = hexToRgb(palette.bg);
+  const luminance = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
+  return luminance > 0.6 ? "light" : "dark";
+}
+
+function renderGhosttySnippet(theme, font, fontSize, opacity) {
+  const bg = resolveColor(theme, theme.vars.bg);
+  const fg = resolveColor(theme, theme.vars.fg);
+  return [
+    `theme = ${theme.name}`,
+    `font-family = ${font}`,
+    `font-size = ${fontSize}`,
+    `background = ${bg}`,
+    `foreground = ${fg}`,
+    opacity ? `background-opacity = ${opacity}` : null
+  ]
+    .filter(Boolean)
+    .join("\n")
+    .concat("\n");
+}
+
+function renderKittySnippet(theme, font, fontSize, opacity) {
+  const bg = resolveColor(theme, theme.vars.bg);
+  const fg = resolveColor(theme, theme.vars.fg);
+  return [
+    `font_family ${font}`,
+    `font_size ${fontSize}`,
+    `background ${bg}`,
+    `foreground ${fg}`,
+    opacity ? `background_opacity ${opacity}` : null,
+    `selection_background ${resolveColor(theme, theme.colors.selectedBg)}`,
+    `selection_foreground ${fg}`
+  ]
+    .filter(Boolean)
+    .join("\n")
+    .concat("\n");
+}
+
+function renderWeztermSnippet(theme, font, fontSize, opacity) {
+  const bg = resolveColor(theme, theme.vars.bg);
+  const fg = resolveColor(theme, theme.vars.fg);
+  return `local wezterm = require("wezterm")
+
+return {
+  font = wezterm.font("${font}"),
+  font_size = ${fontSize},
+  window_background_opacity = ${opacity || 1},
+  colors = {
+    background = "${bg}",
+    foreground = "${fg}",
+    selection_bg = "${resolveColor(theme, theme.colors.selectedBg)}",
+    selection_fg = "${fg}",
+    ansi = { "${bg}", "${resolveColor(theme, theme.colors.error)}", "${resolveColor(theme, theme.colors.success)}", "${resolveColor(theme, theme.colors.warning)}", "${resolveColor(theme, theme.colors.accent)}", "${resolveColor(theme, theme.colors.syntaxKeyword)}", "${resolveColor(theme, theme.colors.mdCode)}", "${fg}" },
+    brights = { "${resolveColor(theme, theme.colors.dim)}", "${resolveColor(theme, theme.colors.error)}", "${resolveColor(theme, theme.colors.success)}", "${resolveColor(theme, theme.colors.warning)}", "${resolveColor(theme, theme.colors.accent)}", "${resolveColor(theme, theme.colors.syntaxKeyword)}", "${resolveColor(theme, theme.colors.mdCode)}", "${fg}" }
+  }
+}
+`;
+}
+
+function renderAppleTerminalProfile(theme, font, fontSize, profileName) {
+  const background = appleScriptColor(resolveColor(theme, theme.vars.bg));
+  const foreground = appleScriptColor(resolveColor(theme, theme.vars.fg));
+  const cursor = appleScriptColor(resolveColor(theme, theme.colors.accent));
+  const bold = appleScriptColor(brightenHex(resolveColor(theme, theme.vars.fg), 0.08));
+
+  return [
+    'tell application "Terminal"',
+    `  if not (exists settings set "${escapeAppleScript(profileName)}") then`,
+    `    make new settings set with properties {name:"${escapeAppleScript(profileName)}"}`,
+    "  end if",
+    `  set font of settings set "${escapeAppleScript(profileName)}" to "${escapeAppleScript(font)}"`,
+    `  set number of rows of settings set "${escapeAppleScript(profileName)}" to 30`,
+    `  set number of columns of settings set "${escapeAppleScript(profileName)}" to 120`,
+    `  set font antialiasing of settings set "${escapeAppleScript(profileName)}" to true`,
+    `  set background color of settings set "${escapeAppleScript(profileName)}" to ${background}`,
+    `  set normal text color of settings set "${escapeAppleScript(profileName)}" to ${foreground}`,
+    `  set bold text color of settings set "${escapeAppleScript(profileName)}" to ${bold}`,
+    `  set cursor color of settings set "${escapeAppleScript(profileName)}" to ${cursor}`,
+    `  set current settings of tabs of windows to settings set "${escapeAppleScript(profileName)}"`,
+    "end tell",
+    ""
+  ].join("\n");
+}
+
+function writeTerminalConfig(target, snippet, snippetPath, options = {}) {
+  const home = os.homedir();
+  if (target === "apple-terminal" || target === "apple" || target === "terminal" || target === "terminal.app") {
+    applyAppleTerminalProfile(snippetPath, options);
+    return;
+  }
+  if (target === "ghostty") {
+    const targetPath = path.join(home, ".config", "ghostty", "config");
+    appendInclude(targetPath, `config-file = ${snippetPath}`);
+    console.log(`Updated ${targetPath}`);
+    return;
+  }
+  if (target === "kitty") {
+    const targetPath = path.join(home, ".config", "kitty", "kitty.conf");
+    appendInclude(targetPath, `include ${snippetPath}`);
+    console.log(`Updated ${targetPath}`);
+    return;
+  }
+  if (target === "wezterm") {
+    const targetPath = path.join(home, ".wezterm.lua");
+    if (fs.existsSync(targetPath)) {
+      console.log(`Existing ${targetPath} left untouched. Merge ${snippetPath} manually.`);
+      return;
+    }
+    fs.writeFileSync(targetPath, snippet, "utf8");
+    console.log(`Created ${targetPath}`);
+  }
+}
+
+function applyAppleTerminalProfile(profilePath, options = {}) {
+  const paths = getThemePaths();
+  snapshotAppleTerminalState(paths);
+  execFileSync("osascript", [profilePath], { stdio: "inherit" });
+  if (options.setDefault && options.profileName) {
+    execFileSync(
+      "osascript",
+      [
+        "-e",
+        `tell application "Terminal" to set default settings to settings set "${escapeAppleScript(options.profileName)}"`,
+        "-e",
+        `tell application "Terminal" to set startup settings to settings set "${escapeAppleScript(options.profileName)}"`
+      ],
+      { stdio: "inherit" }
+    );
+  }
+}
+
+function readTerminalState(paths = getThemePaths()) {
+  if (!fs.existsSync(paths.terminalStateFile)) {
+    return { targets: {} };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(paths.terminalStateFile, "utf8"));
+  } catch (_error) {
+    return { targets: {} };
+  }
+}
+
+function writeTerminalState(state, paths = getThemePaths()) {
+  ensureDir(path.dirname(paths.terminalStateFile));
+  fs.writeFileSync(paths.terminalStateFile, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+
+function snapshotAppleTerminalState(paths = getThemePaths()) {
+  const state = readTerminalState(paths);
+  if (state.targets["apple-terminal"]) {
+    return;
+  }
+
+  const currentProfile = readAppleTerminalValue('tell application "Terminal" to get name of current settings of selected tab of front window');
+  const defaultProfile = readDefault("com.apple.Terminal", "Default Window Settings", "Basic");
+  const startupProfile = readDefault("com.apple.Terminal", "Startup Window Settings", defaultProfile);
+
+  state.targets["apple-terminal"] = {
+    currentProfile: currentProfile || defaultProfile || "Basic",
+    defaultProfile: defaultProfile || "Basic",
+    startupProfile: startupProfile || defaultProfile || "Basic"
+  };
+  writeTerminalState(state, paths);
+}
+
+function restoreAppleTerminalState(savedState) {
+  const fallbackProfile = "Basic";
+  const currentProfile = savedState && savedState.currentProfile ? savedState.currentProfile : fallbackProfile;
+  const defaultProfile = savedState && savedState.defaultProfile ? savedState.defaultProfile : fallbackProfile;
+  const startupProfile = savedState && savedState.startupProfile ? savedState.startupProfile : defaultProfile;
+
+  execFileSync("osascript", [
+    "-e",
+    `tell application "Terminal" to set current settings of tabs of windows to settings set "${escapeAppleScript(currentProfile)}"`,
+    "-e",
+    `tell application "Terminal" to set default settings to settings set "${escapeAppleScript(defaultProfile)}"`,
+    "-e",
+    `tell application "Terminal" to set startup settings to settings set "${escapeAppleScript(startupProfile)}"`
+  ], { stdio: "inherit" });
+}
+
+function readAppleTerminalValue(script) {
+  try {
+    return execFileSync("osascript", ["-e", script], { encoding: "utf8" }).trim();
+  } catch (_error) {
+    return "";
+  }
+}
+
+function readDefault(domain, key, fallback) {
+  try {
+    return execFileSync("defaults", ["read", domain, key], { encoding: "utf8" }).trim();
+  } catch (_error) {
+    return fallback;
+  }
+}
+
+function resetManagedFile(targetPath, prefix) {
+  if (!fs.existsSync(targetPath)) {
+    return;
+  }
+  const existing = fs.readFileSync(targetPath, "utf8");
+  const lines = existing
+    .split("\n")
+    .filter((line) => !line.includes("pretty-code") && !line.startsWith(prefix + path.join(os.homedir(), ".ctheme", "snippets")));
+  fs.writeFileSync(targetPath, `${lines.join("\n").replace(/\n*$/, "\n")}`, "utf8");
+}
+
+function appendInclude(targetPath, line) {
+  ensureDir(path.dirname(targetPath));
+  const existing = fs.existsSync(targetPath) ? fs.readFileSync(targetPath, "utf8") : "";
+  if (existing.includes(line)) return;
+  const updated = `${existing.trimEnd()}${existing.trimEnd() ? "\n" : ""}${line}\n`;
+  fs.writeFileSync(targetPath, updated, "utf8");
+}
+
+function brightenHex(hex, amount) {
+  const { r, g, b } = hexToRgb(hex);
+  const brighten = (channel) => Math.max(0, Math.min(255, Math.round(channel + (255 - channel) * amount)));
+  return rgbToHex(brighten(r), brighten(g), brighten(b));
+}
+
+function rgbToHex(r, g, b) {
+  return `#${[r, g, b].map((n) => n.toString(16).padStart(2, "0")).join("")}`;
+}
+
+function appleScriptColor(hex) {
+  const { r, g, b } = hexToRgb(hex);
+  const scale = (value) => Math.round((value / 255) * 65535);
+  return `{${scale(r)}, ${scale(g)}, ${scale(b)}}`;
+}
+
+function escapeAppleScript(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+function fail(message) {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}
+
+main();