theamify-cli 1.0.1

package/src/core/engine.js

@@ -0,0 +1,100 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Absolute path to the bundled bash engine + app tree shipped inside the npm
+ * package. The whole engine (script + lib/ + config/) lives under vendor/.
+ */
+export const VENDOR_DIR = fileURLToPath(new URL('../../vendor', import.meta.url));
+export const ENGINE_SCRIPT = path.join(VENDOR_DIR, 'theamify');
+
+/** Install/run-time locations. */
+export const SYSTEM_DIR = '/usr/local/share/theamify';
+export const USER_DIR = path.join(os.homedir(), '.local', 'share', 'theamify');
+export const BIN_NAME = 'theamify';
+export const USER_BIN_LINK = path.join(os.homedir(), '.local', 'bin', BIN_NAME);
+
+/**
+ * Locate an installed theamify runtime.
+ * @returns {{dir: string}|null}
+ */
+export function findInstalledRuntime() {
+  for (const dir of [SYSTEM_DIR, USER_DIR]) {
+    if (fs.existsSync(path.join(dir, BIN_NAME))) return { dir };
+  }
+  return null;
+}
+
+/**
+ * Provision a user-owned install of the engine under ~/.local/share/theamify so
+ * it is writable without root (downloads write into themes/ and .repo_cache/).
+ * Preserves an existing config/themes.conf (user registry edits). Returns the
+ * runtime dir.
+ */
+export async function installUserRuntime() {
+  const { execaSync } = await import('execa');
+  fs.mkdirSync(path.join(USER_DIR, 'lib'), { recursive: true });
+  fs.mkdirSync(path.join(USER_DIR, 'config'), { recursive: true });
+  fs.mkdirSync(path.join(USER_DIR, 'themes'), { recursive: true });
+  fs.mkdirSync(path.join(USER_DIR, '.repo_cache'), { recursive: true });
+
+  fs.copyFileSync(path.join(VENDOR_DIR, BIN_NAME), path.join(USER_DIR, BIN_NAME));
+  fs.chmodSync(path.join(USER_DIR, BIN_NAME), 0o755);
+  for (const lib of ['colors', 'utils', 'grub', 'themes']) {
+    fs.copyFileSync(path.join(VENDOR_DIR, 'lib', `${lib}.sh`), path.join(USER_DIR, 'lib', `${lib}.sh`));
+  }
+  const confSrc = path.join(VENDOR_DIR, 'config', 'themes.conf');
+  const confDst = path.join(USER_DIR, 'config', 'themes.conf');
+  if (!fs.existsSync(confDst)) {
+    fs.copyFileSync(confSrc, confDst);
+  }
+
+  // The installed engine expects a wrapping bin symlink so `sudo theamify` works.
+  fs.mkdirSync(path.dirname(USER_BIN_LINK), { recursive: true });
+  fs.rmSync(USER_BIN_LINK, { force: true });
+  fs.symlinkSync(path.join(USER_DIR, BIN_NAME), USER_BIN_LINK);
+
+  // Ensure a PATH marker so the command is reachable from a fresh shell.
+  await ensureOnPath(path.dirname(USER_BIN_LINK));
+  return USER_DIR;
+}
+
+/** Add a PATH export marker to ~/.bashrc and ~/.zshrc (idempotent). */
+export function ensureOnPath(binDir) {
+  const marker = '# theamify CLI PATH';
+  const rcs = ['.bashrc', '.zshrc'].map((f) => path.join(os.homedir(), f));
+  for (const rc of rcs) {
+    try {
+      const content = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
+      if (content.includes(marker)) continue;
+      fs.appendFileSync(rc, `\n${marker}\nexport PATH="${binDir}:$PATH"\n`);
+    } catch { /* skip */ }
+  }
+}
+
+/**
+ * Resolve the path to the engine to run for a subcommand.
+ * Prefers an installed runtime; otherwise provisions the bundled one in the
+ * user share dir (so downloads are writable) and returns that.
+ * @returns {string} absolute path to the theamify engine
+ */
+export async function resolveEngine() {
+  const found = findInstalledRuntime();
+  if (found) return path.join(found.dir, BIN_NAME);
+  const dir = await installUserRuntime();
+  return path.join(dir, BIN_NAME);
+}
+
+/**
+ * Run the engine (installed or bundled) with inherited stdio so the rich TUI
+ * and all subcommands behave exactly like the native tool.
+ * @param {string[]} args
+ * @returns {Promise<{exitCode: number|null}>}
+ */
+export async function runEngine(args = []) {
+  const { execa } = await import('execa');
+  const engine = await resolveEngine();
+  return execa('bash', [engine, ...args], { stdio: 'inherit', reject: false });
+}

package/src/lib/chafa.js

@@ -0,0 +1,143 @@
+import { execa, execaSync } from 'execa';
+import pc from 'picocolors';
+import * as p from '@clack/prompts';
+
+/**
+ * chafa — the terminal image renderer behind theamify's thumbnail previews.
+ * This module manages chafa as a first-class wizard dependency:
+ *   - install   when the wizard runs and chafa is missing
+ *   - update    when the wizard updates itself
+ *   - uninstall when the wizard is uninstalled (opt-in)
+ */
+
+export const CHAFA_BIN = 'chafa';
+
+/** @returns {Promise<boolean>} true if `chafa` is on PATH. */
+export async function hasChafa() {
+  try {
+    const res = await execa('bash', ['-c', `command -v ${CHAFA_BIN}`], { reject: false });
+    return Boolean(res.stdout.trim());
+  } catch {
+    return false;
+  }
+}
+
+/** Detect which package manager is available. @returns {string|null} */
+export function detectPackageManager() {
+  const order = ['apt-get', 'dnf', 'yum', 'pacman', 'zypper', 'apk'];
+  const pm = order.find((name) => {
+    try {
+      return Boolean(execaSync('bash', ['-c', `command -v ${name}`], { reject: false }).stdout.trim());
+    } catch {
+      return false;
+    }
+  });
+  return pm || null;
+}
+
+/**
+ * Run a privileged package-manager command, releasing the terminal first so the
+ * sudo password prompt is visible and Ctrl+C actually works. Mirrors the
+ * interactive-sudo pattern used by gitswitch and warp-wizard.
+ * @param {string[]} cmd sudo + args
+ */
+async function runPrivileged(cmd) {
+  const res = await execa('sudo', cmd, { stdio: 'inherit', reject: false });
+  if (res.exitCode !== 0) throw new Error(`Command failed: sudo ${cmd.join(' ')} (exit ${res.exitCode})`);
+  return res;
+}
+
+/**
+ * Install chafa, prompting the user first. Safe no-op when a package manager is
+ * unavailable or chafa is already installed.
+ * @param {{silent?: boolean}} [opts]
+ * @returns {Promise<boolean>} true when chafa is available afterwards
+ */
+export async function ensureChafa({ silent = false } = {}) {
+  if (await hasChafa()) return true;
+
+  const pm = detectPackageManager();
+  if (!pm) {
+    if (!silent) p.log.warn('No supported package manager found — install chafa manually to enable previews.');
+    return false;
+  }
+
+  const want = silent ? true : await p.confirm({
+    message: `Install ${pc.cyan('chafa')} to enable terminal theme previews?`,
+    initialValue: true,
+  });
+  if (p.isCancel(want) || !want) {
+    if (!silent) p.log.message(pc.dim('Skipped — theme thumbnails will be disabled. Install later with your package manager.'));
+    return false;
+  }
+
+  if (!silent) p.log.step(`Installing chafa via ${pm}…`);
+  const s = p.spinner();
+  s.start('Installing chafa…');
+  try {
+    // Release the spinner so the sudo prompt is visible & interruptible.
+    s.stop('');
+    const pkgArgs = pm === 'pacman' ? ['-S', '--noconfirm', 'chafa'] : [pm, 'install', '-y', 'chafa'];
+    await runPrivileged(pkgArgs);
+    if (!(await hasChafa())) throw new Error('chafa install appeared to complete, but chafa is not on PATH.');
+    if (!silent) p.log.success('chafa installed — terminal thumbnails enabled!');
+    return true;
+  } catch (e) {
+    if (!silent) p.log.warn(`chafa install failed: ${e.message}\n  Try manually: sudo apt install chafa`);
+    return false;
+  }
+}
+
+/** Update chafa to its latest available version (best-effort). */
+export async function updateChafa() {
+  if (!(await hasChafa())) return ensureChafa({ silent: true });
+
+  const pm = detectPackageManager();
+  if (!pm) return false;
+  p.log.step('Updating chafa…');
+  try {
+    const args = pm === 'pacman'
+      ? ['-Syu', '--noconfirm', 'chafa']
+      : pm === 'apk'
+        ? ['apk', 'upgrade', 'chafa']
+        : [pm, 'install', '-y', '--only-upgrade', 'chafa'];
+    await runPrivileged(args);
+    p.log.success('chafa updated.');
+    return true;
+  } catch (e) {
+    p.log.warn(`chafa update failed: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * Remove chafa after confirming. Only called from the uninstall wizard.
+ * @returns {Promise<boolean>} true when chafa was removed
+ */
+export async function uninstallChafa() {
+  if (!(await hasChafa())) { p.log.message(pc.dim('chafa not installed — nothing to remove.')); return false; }
+
+  const pm = detectPackageManager();
+  if (!pm) { p.log.warn('No package manager found — remove chafa yourself.'); return false; }
+
+  const want = await p.confirm({
+    message: 'Also remove chafa (thumbnail renderer)? You can re-enable previews later by reinstalling it.',
+    initialValue: false,
+  });
+  if (p.isCancel(want) || !want) { p.log.message(pc.dim('Kept chafa.')); return false; }
+
+  p.log.step(`Removing chafa via ${pm}…`);
+  try {
+    const args = pm === 'pacman'
+      ? ['pacman', '-Rns', '--noconfirm', 'chafa']
+      : pm === 'apk'
+        ? ['apk', 'del', 'chafa']
+        : [pm, 'remove', '-y', 'chafa'];
+    await runPrivileged(args);
+    p.log.success('chafa removed.');
+    return true;
+  } catch (e) {
+    p.log.warn(`chafa removal failed: ${e.message}`);
+    return false;
+  }
+}

package/src/lib/conf.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { USER_DIR } from '../core/engine.js';
+
+export const VENDOR_CONF = fileURLToPath(new URL('../../vendor/config/themes.conf', import.meta.url));
+
+/**
+ * Parse the `themes.conf` registry (NAME|URL|SUBDIR|DESC|SOURCE|TAGS).
+ * Skips blank lines and `#` comments.
+ * @param {string} [file] path to themes.conf (defaults to vendored copy)
+ * @returns {Array<{name:string,url:string,sub:string,desc:string,source:string,tags:string[]}>}
+ */
+export function parseThemes(file = VENDOR_CONF) {
+  const content = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+  const out = [];
+  for (const raw of content.split('\n')) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#')) continue;
+    const parts = line.split('|');
+    const [name, url, sub, desc, source, tags] = parts;
+    if (!name || !url) continue;
+    out.push({
+      name: name.trim(),
+      url: url.trim(),
+      sub: (sub || '.').trim(),
+      desc: (desc || '').trim(),
+      source: (source || '').trim(),
+      tags: (tags || '').split(',').map((t) => t.trim()).filter(Boolean),
+    });
+  }
+  return out;
+}
+
+/**
+ * Find a theme by name (case-insensitive).
+ * @param {string} name
+ * @param {string} [file]
+ * @returns {object|null}
+ */
+export function findTheme(name, file = VENDOR_CONF) {
+  if (!name) return null;
+  return parseThemes(file).find((t) => t.name.toLowerCase() === name.toLowerCase()) || null;
+}
+
+/**
+ * Resolve the registry file actually in use by the installed runtime when one
+ * exists (so user's `theamify add`/`del` edits are honored), else the vendored
+ * default shipped in this package.
+ * @returns {string} path to themes.conf (runtime or vendored)
+ */
+export function resolveConfPath() {
+  const runtimeConf = path.join(USER_DIR, 'config', 'themes.conf');
+  return fs.existsSync(runtimeConf) ? runtimeConf : VENDOR_CONF;
+}

package/src/lib/tools.js

@@ -0,0 +1,76 @@
+import { execa, execaSync } from 'execa';
+import pc from 'picocolors';
+import * as p from '@clack/prompts';
+
+/**
+ * theamify companion tools — installed / updated by the wizard, but NEVER
+ * removed on uninstall (they're useful to the user on their own).
+ *
+ * Registry:
+ *   - chafa            terminal image renderer → inline theme thumbnails
+ *   - grub-customizer  GUI to tweak the GRUB menu & themes
+ */
+
+export const TOOLS = [
+  {
+    name: 'chafa',
+    bin: 'chafa',
+    purpose: 'terminal thumbnail previews',
+    install: { 'apt-get': 'chafa', 'dnf': 'chafa', 'yum': 'chafa', 'pacman': 'chafa', 'zypper': 'chafa', 'apk': 'chafa' },
+  },
+  {
+    name: 'grub-customizer',
+    bin: 'grub-customizer',
+    purpose: 'GUI for tweaking the GRUB menu & themes',
+    install: { 'apt-get': 'grub-customizer', 'dnf': 'grub-customizer', 'yum': 'grub-customizer', 'pacman': 'grub-customizer', 'zypper': 'grub-customizer', 'apk': null },
+  },
+];
+
+/** @param {{bin:string}} tool */
+export async function hasTool(tool) {
+  try {
+    const res = await execa('bash', ['-c', `command -v ${tool.bin}`], { reject: false });
+    return Boolean(res.stdout.trim());
+  } catch {
+    return false;
+  }
+}
+
+/** Detect which package manager is available. @returns {string|null} */
+export function detectPackageManager() {
+  const order = ['apt-get', 'dnf', 'yum', 'pacman', 'zypper', 'apk'];
+  const pm = order.find((name) => {
+    try {
+      return Boolean(execaSync('bash', ['-c', `command -v ${name}`], { reject: false }).stdout.trim());
+    } catch {
+      return false;
+    }
+  });
+  return pm || null;
+}
+
+/**
+ * Run a privileged package-manager command, releasing the terminal first so the
+ * sudo password prompt is visible and Ctrl+C actually works. Mirrors the
+ * interactive-sudo pattern used by gitswitch and warp-wizard.
+ * @param {string[]} cmd sudo + args
+ */
+async function runPrivileged(cmd) {
+  const res = await execa('sudo', cmd, { stdio: 'inherit', reject: false });
+  if (res.exitCode !== 0) throw new Error(`Command failed: sudo ${cmd.join(' ')} (exit ${res.exitCode})`);
+  return res;
+}
+
+/** @returns {string|null} package-manager-specific package name for a tool */
+function packageNameFor(tool, pm) {
+  return tool.install ? tool.install[pm] : (tool.name || null);
+}
+
+/** @returns {boolean} whether the tool binary is on PATH (sync) */
+function hasToolSync(tool) {
+  try {
+    return Boolean(execaSync('bash', ['-c', `command -v ${tool.bin}`], { reject: false }).stdout.trim());
+  } catch {
+    return false;
+  }
+}

package/src/wizard/browse.js

@@ -0,0 +1,165 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseThemes, resolveConfPath } from '../lib/conf.js';
+import { ensureChafa } from '../lib/chafa.js';
+import { resolveEngine, USER_DIR } from '../core/engine.js';
+
+const USER_THEMES = path.join(USER_DIR, 'themes');
+const GRUB_CFG = '/etc/default/grub';
+
+/** Extract the currently-active theme folder name from /etc/default/grub. */
+function activeTheme() {
+  try {
+    const cfg = fs.readFileSync(GRUB_CFG, 'utf8');
+    const m = cfg.match(/^GRUB_THEME="?([^"\n]+)"?/m);
+    if (!m) return null;
+    return (path.basename(path.dirname(m[1])) || m[1]).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function themeStatus(name) {
+  const active = activeTheme();
+  let status = 'remote';
+  if (fs.existsSync(path.join(USER_THEMES, name))) status = 'cached';
+  if (name === active) status = 'active';
+  return status;
+}
+
+const statusColor = (status) => ({
+  active: pc.green,
+  cached: pc.cyan,
+  remote: pc.dim,
+}[status] || pc.dim);
+
+/**
+ * Render a terminal "thumbnail" preview of a cached theme via chafa (or any
+ * terminal image renderer the user has). Silently nops when unsatisfiable.
+ * @returns {Promise<boolean>} true if a preview was rendered
+ */
+export async function showThemePreview({ name, width = 40, height = 12 }) {
+  const dir = path.join(USER_THEMES, name);
+  if (!fs.existsSync(dir)) return false;
+
+  const image = fs.readdirSync(dir, { recursive: true })
+    .map((f) => path.join(dir, f))
+    .filter((f) => /\.(png|jpe?g|webp)$/i.test(f) && !f.includes('/.git/'))
+    .sort()[0];
+  if (!image) return false;
+
+  const { execa } = await import('execa');
+  for (const tool of ['chafa', 'timg', 'viu', 'jp2a']) {
+    const args = tool === 'chafa'
+      ? ['--size', `${width}x${height}`, image]
+      : [image];
+    try {
+      const { stdout } = await execa(tool, args, { reject: false });
+      if (stdout && stdout.trim()) {
+        p.log.message(`\n${stdout}\n`);
+        return true;
+      }
+    } catch { /* try next */ }
+  }
+  p.log.message(pc.dim('Install `chafa` (: sudo apt install chafa) for terminal theme previews.'));
+  return false;
+}
+
+/** Interactive GRUB-theme browser wizard (mirrors GitSwitch's look & feel). */
+export async function runThemeBrowser() {
+  // Step 1: ensure the thumbnail renderer is present before anything else.
+  await ensureChafa();
+
+  const themes = parseThemes(resolveConfPath());
+  const active = activeTheme();
+
+  const selected = await p.select({
+    message: pc.bold('Pick a GRUB theme'),
+    options: themes.map((t) => {
+      const status = themeStatus(t.name);
+      const color = statusColor(status);
+      return {
+        value: t,
+        label: `${t.name}  ${color(`[${status.toUpperCase()}]`)}${t.name === active ? '  ⭐' : ''}`,
+        hint: t.tags.slice(0, 3).join(', '),
+      };
+    }),
+  });
+  if (p.isCancel(selected)) { p.cancel('Bye! 👋'); process.exit(0); }
+
+  p.log.step(`${pc.bold(selected.name)} — ${selected.desc}`);
+  p.log.message(pc.dim(selected.url));
+
+  if (fs.existsSync(path.join(USER_THEMES, selected.name))) {
+    await showThemePreview({ name: selected.name });
+  }
+
+  const action = await p.select({
+    message: `What do you want to do with ${pc.cyan(selected.name)}?`,
+    options: [
+      { value: 'preview', label: 'Show terminal thumbnail preview', hint: 'requires chafa + cached theme' },
+      { value: 'get', label: 'Download / update it', hint: 'git clone into local cache' },
+      { value: 'use', label: 'Apply to GRUB', hint: 'needs sudo; rebuilds GRUB' },
+      { value: 'open', label: 'Open source page in browser' },
+      { value: 'back', label: 'Cancel' },
+    ],
+  });
+  if (p.isCancel(action) || action === 'back') { p.outro('Bye! 👋'); process.exit(0); }
+
+  const engine = await resolveEngine();
+  const { execa } = await import('execa');
+
+  if (action === 'preview') {
+    await showThemePreview({ name: selected.name, width: 80, height: 20 });
+    p.outro(pc.green('Preview above.'));
+  } else if (action === 'get') {
+    const s = p.spinner();
+    s.start(`Downloading ${selected.name}…`);
+    try {
+      await execa('bash', [engine, 'get', selected.name], { stdio: 'inherit', reject: true });
+      s.stop(pc.green(`Downloaded ${selected.name}.`));
+    } catch (e) {
+      s.stop(pc.red(`Download failed: ${e.message}`));
+    }
+  } else if (action === 'use') {
+    await runUse(engine, selected.name);
+  } else if (action === 'open') {
+    await execa('bash', [engine, 'open', selected.name], { stdio: 'inherit', reject: false });
+  }
+}
+
+/** Apply a theme to GRUB, re-invoking with sudo, spinner released for the prompt. */
+export async function runUse(engine, name) {
+  const cached = path.join(USER_THEMES, name);
+  if (!fs.existsSync(cached)) {
+    p.log.warn(`${name} isn't downloaded yet. Fetching first…`);
+    const s = p.spinner();
+    s.start(`Downloading ${name}…`);
+    try {
+      await execa('bash', [engine, 'get', name], { stdio: 'inherit', reject: true });
+      s.stop();
+    } catch (e) {
+      s.stop(pc.red(`Download failed: ${e.message}`));
+      return;
+    }
+  }
+
+  const confirmApply = await p.confirm({ message: `Apply ${pc.cyan(name)} to GRUB and rebuild? (sudo)`, initialValue: true });
+  if (p.isCancel(confirmApply) || !confirmApply) { p.outro('Skipped.'); return; }
+
+  const { execa } = await import('execa');
+  if (process.getuid() !== 0) {
+    // Release spinner, then prompt sudo on a clean terminal so Ctrl+C works.
+    console.log();
+    const res = await execa('sudo', ['bash', engine, 'use', name], { stdio: 'inherit', reject: false });
+    return res.exitCode === 0
+      ? p.outro(pc.green(`${name} is now your GRUB theme! 🎉`))
+      : p.cancel('GRUB apply failed.');
+  }
+  const res = await execa('bash', [engine, 'use', name], { stdio: 'inherit', reject: false });
+  res.exitCode === 0
+    ? p.outro(pc.green(`${name} is now your GRUB theme! 🎉`))
+    : p.cancel('GRUB apply failed.');
+}

package/vendor/config/themes.conf

@@ -0,0 +1,36 @@
+# +==============================================================================+
+# |  theamify Theme Registry                                                     |
+# |  Format : NAME|GITHUB_URL|SUBDIR|DESCRIPTION|SOURCE_URL|TAGS                |
+# |  SUBDIR  : "." = repo root  |  "path/to/dir" = subdir within repo           |
+# |            "generate:<args>" = repo has no static theme folder, build it    |
+# |            via its own generate.sh first (see CONTRIBUTING.md)              |
+# |  Add     : theamify add <url>                                                |
+# |  Remove  : theamify del <name>                                               |
+# +==============================================================================+
+
+# -- HenriqueLopes42 Cyberpunk Series ------------------------------------------
+CyberEXS|https://github.com/HenriqueLopes42/themeGrub.CyberEXS|.|Dark cyberpunk hooded-figure neon GRUB theme|https://www.gnome-look.org/p/1968990|cyberpunk,dark,neon,hooded,scifi
+CyberSynchro|https://github.com/HenriqueLopes42/ThemeGrub.CyberSynchro|.|Teal & neon cyberpunk matrix GRUB theme|https://www.gnome-look.org/p/1972621|cyberpunk,teal,neon,matrix,dark
+
+# -- Space & Sci-Fi -------------------------------------------------------------
+Space-Isolation|https://github.com/callmenoodles/space-isolation|.|Alien: Isolation-inspired dark space GRUB theme|https://www.gnome-look.org/p/2296342|space,alien,scifi,dark,atmospheric,horror
+
+# -- Anime / Kawaii ------------------------------------------------------------
+# NOTE: upstream repo is "KawaiiGRUB" (double i) - a single-i URL 404s and
+# makes git fall back to an interactive credential prompt over HTTPS, which
+# hangs a non-interactive `get --all` run. Fixed here; see CONTRIBUTING.md.
+Kawaii-GRUB|https://github.com/Gabbar-v7/KawaiiGRUB|.|Kawaii anime vibrant bold GRUB theme|https://www.gnome-look.org/p/2218890|anime,kawaii,cute,colorful,bold,vibrant
+Kayoko-Onikata|https://github.com/MTFTau-5/Kayoko-Onikata-GRUB|.|Cat cafe anime cozy pastel GRUB theme|https://www.gnome-look.org/p/2350900|anime,cat,cute,cozy,pastel,kawaii
+
+# -- Abstract / Tech -----------------------------------------------------------
+# NOTE: yeyushengfan258's Matrix/Particle repos use the same "no static
+# theme folder, build via generate.sh" pattern that the old Elegant entries
+# used (and originally failed at). Verified working with the args below -
+# generate.sh accepts -t [window|sidebar] and -s [1080p|2k|4k]; change either
+# to taste. See CONTRIBUTING.md for how `generate:<args>` is driven.
+Matrices|https://github.com/yeyushengfan258/Matrix-grub-theme|generate:-t window -s 1080p|Abstract matrix blue tech orb GRUB theme|https://www.gnome-look.org/p/2271298|matrix,abstract,blue,tech,modern,3d
+Particle|https://github.com/yeyushengfan258/Particle-grub-theme|generate:-t window -s 1080p|Particle effect dynamic blue GRUB theme|https://www.gnome-look.org/p/2269763|particle,abstract,blue,dynamic,modern
+
+# -- Chill / Minimal -----------------------------------------------------------
+Zzz-GRUB|https://github.com/jsthope/Zzz-GRUB-Theme|.|Cute sleeping cat chill minimal GRUB theme|https://www.gnome-look.org/p/2354136|cat,chill,minimal,cute,anime,night,cozy
+