shell-logo 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shell-logo",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "Render colorful ASCII art logos in the terminal from a config file",
   "license": "MIT",

package/src/config.js

@@ -1,22 +1,35 @@
+/**
+ * Config loading with XDG-first resolution and legacy migration.
+ *
+ * Load order:
+ *   1. XDG path  (~/.config/shell-logo/folders/<hash>/config.json)
+ *   2. Legacy path (.shell-logo.json in the working directory)
+ *
+ * If a legacy config is found but no XDG config exists, the legacy config
+ * is automatically copied to XDG (the legacy file is left untouched).
+ */
+
 import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
 import chalk from 'chalk';
+import { configPath, legacyConfigPath } from './paths.js';
+import { writeConfig } from './generate.js';
+import { SHAPE_NAMES } from './shapes.js';
 
 export const DEFAULTS = {
   colors: ['#ff6b6b', '#feca57', '#48dbfb'],
   font: 'Standard',
 };
 
-export function tryLoadConfig() {
-  const configPath = join(process.cwd(), '.shell-logo.json');
-
-  let raw;
-  try {
-    raw = readFileSync(configPath, 'utf-8');
-  } catch {
-    return null;
-  }
-
+/**
+ * Parse a JSON string and validate it as a shell-logo config.
+ *
+ * Supports two modes:
+ *   - "text" (default): requires non-empty `text`, optional `colors`/`font`
+ *   - "shape": requires valid `shape` name, optional `colors`, no `text`/`font` needed
+ *
+ * Returns a normalized config object, or null if invalid.
+ */
+function parseAndValidate(raw) {
   let config;
   try {
     config = JSON.parse(raw);
@@ -24,68 +37,92 @@ export function tryLoadConfig() {
     return null;
   }
 
-  if (!config.text || typeof config.text !== 'string' || config.text.trim() === '') {
-    return null;
-  }
-
   if (config.colors !== undefined) {
     if (!Array.isArray(config.colors) || config.colors.length < 2) {
       return null;
     }
   }
 
+  const mode = config.mode ?? 'text';
+
+  if (mode === 'shape') {
+    if (!config.shape || !SHAPE_NAMES.includes(config.shape)) {
+      return null;
+    }
+    return {
+      mode: 'shape',
+      shape: config.shape,
+      colors: config.colors ?? DEFAULTS.colors,
+    };
+  }
+
+  // mode === 'text' (or absent for backward compatibility)
+  if (!config.text || typeof config.text !== 'string' || config.text.trim() === '') {
+    return null;
+  }
+
   return {
+    mode: 'text',
     text: config.text.trim(),
     colors: config.colors ?? DEFAULTS.colors,
     font: config.font ?? DEFAULTS.font,
   };
 }
 
-export function loadConfig() {
-  const configPath = join(process.cwd(), '.shell-logo.json');
-
-  let raw;
+/**
+ * Try to load config for `cwd`. Returns the parsed config or null.
+ * Checks XDG first, then falls back to legacy .shell-logo.json.
+ * Auto-migrates legacy configs to XDG on first load.
+ */
+export function tryLoadConfig(cwd) {
+  // 1. Try XDG path
   try {
-    raw = readFileSync(configPath, 'utf-8');
+    const raw = readFileSync(configPath(cwd), 'utf-8');
+    const config = parseAndValidate(raw);
+    if (config) return config;
   } catch {
-    console.error(
-      chalk.red('Error: ') +
-        'No .shell-logo.json found in the current directory.\n\n' +
-        'Create one with at least:\n\n' +
-        '  { "text": "HELLO" }\n\n' +
-        'Or copy an example:\n\n' +
-        '  cp node_modules/shell-logo/examples/.shell-logo.json .'
-    );
-    process.exit(1);
+    // Not found or unreadable — fall through to legacy
   }
 
-  let config;
+  // 2. Try legacy .shell-logo.json in the working directory
+  let raw;
   try {
-    config = JSON.parse(raw);
+    raw = readFileSync(legacyConfigPath(cwd), 'utf-8');
   } catch {
-    console.error(chalk.red('Error: ') + '.shell-logo.json contains invalid JSON.');
-    process.exit(1);
+    return null;
   }
 
-  if (!config.text || typeof config.text !== 'string' || config.text.trim() === '') {
-    console.error(
-      chalk.red('Error: ') + '"text" is required and must be a non-empty string in .shell-logo.json.'
+  const config = parseAndValidate(raw);
+  if (!config) return null;
+
+  // 3. Auto-migrate legacy config to XDG (legacy file is left untouched)
+  try {
+    writeConfig(config, cwd);
+    const xdgPath = configPath(cwd);
+    console.log(
+      chalk.dim(`Migrated config from .shell-logo.json → ${xdgPath}`)
     );
-    process.exit(1);
+  } catch {
+    // Migration failed — still usable from the legacy path
   }
 
-  if (config.colors !== undefined) {
-    if (!Array.isArray(config.colors) || config.colors.length < 2) {
-      console.error(
-        chalk.red('Error: ') + '"colors" must be an array of at least 2 color strings.'
-      );
-      process.exit(1);
-    }
-  }
+  return config;
+}
 
-  return {
-    text: config.text.trim(),
-    colors: config.colors ?? DEFAULTS.colors,
-    font: config.font ?? DEFAULTS.font,
-  };
+/**
+ * Load config for `cwd`, or exit with an error if none is found.
+ * Same resolution as tryLoadConfig but treats missing config as fatal.
+ */
+export function loadConfig(cwd) {
+  const config = tryLoadConfig(cwd);
+  if (config) return config;
+
+  const xdg = configPath(cwd);
+  console.error(
+    chalk.red('Error: ') +
+      `No config found for this folder.\n\n` +
+      `Expected at: ${xdg}\n\n` +
+      'Run shell-logo and choose "Generate" to create one.'
+  );
+  process.exit(1);
 }

package/src/generate.js

@@ -1,8 +1,46 @@
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+/**
+ * Config persistence — writes config to the XDG folder structure.
+ *
+ * Uses atomic writes (write to tmp file, then rename) to prevent corruption
+ * if two terminals write to the same folder config simultaneously.
+ */
 
-export function writeConfig(config) {
-  const configPath = join(process.cwd(), '.shell-logo.json');
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
-  return configPath;
+import { writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { configPath, folderConfigDir, metaPath } from './paths.js';
+
+/**
+ * Write data to a file atomically: write to a temp file in the same
+ * directory, then rename. This avoids partial reads if another process
+ * is reading the file at the same time.
+ */
+function atomicWriteSync(targetPath, data) {
+  const dir = dirname(targetPath);
+  const tmpPath = join(dir, `.tmp.${randomBytes(6).toString('hex')}`);
+  writeFileSync(tmpPath, data);
+  renameSync(tmpPath, targetPath);
+}
+
+/**
+ * Persist a config object to the XDG folder for `cwd`.
+ * Creates the directory tree if it doesn't exist yet.
+ * Also writes a meta.json with the original folder path (best-effort).
+ * Returns the path the config was written to.
+ */
+export function writeConfig(config, cwd = process.cwd()) {
+  const dir = folderConfigDir(cwd);
+  mkdirSync(dir, { recursive: true });
+
+  atomicWriteSync(configPath(cwd), JSON.stringify(config, null, 2) + '\n');
+
+  // meta.json stores the original folder path so humans can identify
+  // which hash directory belongs to which project.
+  try {
+    atomicWriteSync(metaPath(cwd), JSON.stringify({ path: resolve(cwd) }, null, 2) + '\n');
+  } catch {
+    // Best-effort — not critical if this fails
+  }
+
+  return configPath(cwd);
 }

package/src/index.js

@@ -1,67 +1,46 @@
 #!/usr/bin/env node
 
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+/**
+ * Entry point for shell-logo.
+ *
+ * 1. Run the interactive UI to get a config + session mode (persistent or temporary).
+ * 2. If the user chose "Generate", persist the new config to disk.
+ * 3. Start the fullscreen render loop with arrow-key theme/font cycling.
+ */
+
 import { runInteractiveUI } from './ui.js';
 import { writeConfig } from './generate.js';
 import { render } from './renderer.js';
 import { getTerminalSize, clearScreen, hideCursor, showCursor, centerContent } from './terminal.js';
 import { THEMES, FONTS } from './themes.js';
+import { SHAPES } from './shapes.js';
 import chalk from 'chalk';
 import * as p from '@clack/prompts';
 
-const { action, config } = await runInteractiveUI();
+const { action, config, persistent } = await runInteractiveUI();
 
 if (action === 'generate') {
   const s = p.spinner();
-  s.start('Writing .shell-logo.json...');
+  s.start('Saving config...');
   writeConfig(config);
   s.stop('Config saved!');
-
-  const isGitRepo = existsSync(join(process.cwd(), '.git'));
-  const gitignorePath = join(process.cwd(), '.gitignore');
-  let shouldPrompt = isGitRepo;
-
-  if (existsSync(gitignorePath)) {
-    const content = readFileSync(gitignorePath, 'utf-8');
-    const lines = content.split('\n').map(l => l.trim());
-    if (lines.includes('.shell-logo.json')) {
-      shouldPrompt = false;
-    }
-  }
-
-  if (shouldPrompt) {
-    const addToGitignore = await p.select({
-      message: 'Add .shell-logo.json to .gitignore?',
-      options: [
-        { value: true, label: 'Yes (recommended)' },
-        { value: false, label: 'No' },
-      ],
-    });
-
-    if (p.isCancel(addToGitignore)) {
-      p.cancel('Cancelled.');
-      process.exit(0);
-    }
-
-    if (addToGitignore) {
-      if (existsSync(gitignorePath)) {
-        const existing = readFileSync(gitignorePath, 'utf-8');
-        const separator = existing.endsWith('\n') ? '' : '\n';
-        writeFileSync(gitignorePath, existing + separator + '.shell-logo.json\n');
-      } else {
-        writeFileSync(gitignorePath, '.shell-logo.json\n');
-      }
-      p.log.success('.gitignore updated.');
-    }
-  }
 }
 
-startRenderLoop(config);
-
-function startRenderLoop(config) {
+startRenderLoop(config, persistent);
+
+/**
+ * Fullscreen render loop. Draws the logo centered in the terminal and
+ * listens for arrow keys to cycle themes (up/down) and fonts (left/right).
+ *
+ * @param {object}  config     - Logo config: { text, colors, font }
+ * @param {boolean} persistent - When true, arrow key changes are saved to disk.
+ *                               When false (temporary session), changes are in-memory only.
+ */
+function startRenderLoop(config, persistent) {
   let resizeTimer;
 
+  const isShapeMode = config.mode === 'shape';
+
   // Find the current theme index by matching colors
   let themeIndex = THEMES.findIndex(
     (t) => JSON.stringify(t.colors) === JSON.stringify(config.colors)
@@ -71,6 +50,11 @@ function startRenderLoop(config) {
   let fontIndex = FONTS.indexOf(config.font);
   if (fontIndex === -1) fontIndex = 0;
 
+  let shapeIndex = isShapeMode
+    ? SHAPES.findIndex((s) => s.name === config.shape)
+    : 0;
+  if (shapeIndex === -1) shapeIndex = 0;
+
   let showStatus = false;
   let statusTimer;
 
@@ -80,11 +64,15 @@ function startRenderLoop(config) {
     clearScreen();
     process.stdout.write(centerContent(art, columns, rows));
     if (showStatus) {
-      const status = `  ${THEMES[themeIndex].name}  ·  ${FONTS[fontIndex]}  ·  ↑↓ theme  ←→ font  q quit`;
+      const lrLabel = isShapeMode
+        ? `${SHAPES[shapeIndex].name}  ·  ←→ shape`
+        : `${FONTS[fontIndex]}  ·  ←→ font`;
+      const status = `  ${THEMES[themeIndex].name}  ·  ${lrLabel}  ·  ↑↓ theme  q quit`;
       process.stdout.write(`\x1B[${rows};1H` + chalk.dim(status));
     }
   }
 
+  /** Briefly show the status bar (theme name, font, controls) for 2 seconds. */
   function flashStatus() {
     showStatus = true;
     clearTimeout(statusTimer);
@@ -94,6 +82,7 @@ function startRenderLoop(config) {
     }, 2000);
   }
 
+  /** Debounce re-renders on terminal resize to avoid flickering. */
   function debouncedRender() {
     clearTimeout(resizeTimer);
     resizeTimer = setTimeout(renderLoop, 50);
@@ -131,16 +120,27 @@ function startRenderLoop(config) {
       } else if (key[2] === 66) { // Arrow Down — next theme
         themeIndex = (themeIndex + 1) % THEMES.length;
         config.colors = THEMES[themeIndex].colors;
-      } else if (key[2] === 67) { // Arrow Right — next font
-        fontIndex = (fontIndex + 1) % FONTS.length;
-        config.font = FONTS[fontIndex];
-      } else if (key[2] === 68) { // Arrow Left — prev font
-        fontIndex = (fontIndex - 1 + FONTS.length) % FONTS.length;
-        config.font = FONTS[fontIndex];
+      } else if (key[2] === 67) { // Arrow Right — next font/shape
+        if (isShapeMode) {
+          shapeIndex = (shapeIndex + 1) % SHAPES.length;
+          config.shape = SHAPES[shapeIndex].name;
+        } else {
+          fontIndex = (fontIndex + 1) % FONTS.length;
+          config.font = FONTS[fontIndex];
+        }
+      } else if (key[2] === 68) { // Arrow Left — prev font/shape
+        if (isShapeMode) {
+          shapeIndex = (shapeIndex - 1 + SHAPES.length) % SHAPES.length;
+          config.shape = SHAPES[shapeIndex].name;
+        } else {
+          fontIndex = (fontIndex - 1 + FONTS.length) % FONTS.length;
+          config.font = FONTS[fontIndex];
+        }
       } else {
         return;
       }
-      writeConfig(config);
+      // Only persist theme/font changes in a persistent (non-temporary) session
+      if (persistent) writeConfig(config);
       flashStatus();
       renderLoop();
     }

package/src/paths.js

@@ -0,0 +1,44 @@
+/**
+ * Path resolution for XDG-based config storage.
+ *
+ * Configs are stored per-folder under:
+ *   $XDG_CONFIG_HOME/shell-logo/folders/<hash>/config.json
+ *
+ * where <hash> is the first 16 hex chars of SHA-256(absolute CWD).
+ * Falls back to ~/.config/shell-logo/ when XDG_CONFIG_HOME is unset.
+ */
+
+import { createHash } from 'node:crypto';
+import { resolve, join } from 'node:path';
+import { homedir } from 'node:os';
+
+/** Root directory for all shell-logo config: $XDG_CONFIG_HOME/shell-logo/ */
+export function configRoot() {
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+  return join(base, 'shell-logo');
+}
+
+/** Deterministic 16-char hex hash of the absolute path for `cwd`. */
+export function folderHash(cwd = process.cwd()) {
+  return createHash('sha256').update(resolve(cwd)).digest('hex').slice(0, 16);
+}
+
+/** Per-folder config directory: <configRoot>/folders/<hash>/ */
+export function folderConfigDir(cwd = process.cwd()) {
+  return join(configRoot(), 'folders', folderHash(cwd));
+}
+
+/** Path to the per-folder config file (text, colors, font). */
+export function configPath(cwd = process.cwd()) {
+  return join(folderConfigDir(cwd), 'config.json');
+}
+
+/** Path to the per-folder meta file (stores original absolute path for debugging). */
+export function metaPath(cwd = process.cwd()) {
+  return join(folderConfigDir(cwd), 'meta.json');
+}
+
+/** Path to the legacy config file (.shell-logo.json in the working directory). */
+export function legacyConfigPath(cwd = process.cwd()) {
+  return join(resolve(cwd), '.shell-logo.json');
+}

package/src/renderer.js

@@ -1,6 +1,7 @@
 import figlet from 'figlet';
 import gradient from 'gradient-string';
 import { scaleArt } from './scaling.js';
+import { SHAPES } from './shapes.js';
 
 function figletSync(text, font) {
   try {
@@ -11,6 +12,18 @@ function figletSync(text, font) {
 }
 
 export function render(config, columns, rows) {
+  if (config.mode === 'shape') {
+    const shape = SHAPES.find((s) => s.name === config.shape);
+    if (!shape) {
+      const grad = gradient(config.colors);
+      return grad(config.shape);
+    }
+    const trimmed = shape.art.trim();
+    const scaled = scaleArt(trimmed, columns, rows - 2);
+    const grad = gradient(config.colors);
+    return grad.multiline(scaled);
+  }
+
   const art = figletSync(config.text, config.font);
   if (!art) {
     const grad = gradient(config.colors);

package/src/shapes.js

@@ -0,0 +1,239 @@
+export const SHAPES = [
+  {
+    name: 'Pixel',
+    art: `
+   ▄█▄       ▄█▄
+  █████ ▄▄▄ █████
+  ████████████████
+  ██ ▀ █████ ▀ ██
+  ████████████████
+  █████ ▀▀▀ █████
+   ██████████████
+    ████████████
+    ██ █████ ██
+    ▀▀       ▀▀
+    `,
+  },
+  {
+    name: 'Bloop',
+    art: `
+    ▄████████▄
+  ██████████████
+ ████████████████
+ ███▀██████▀█████
+ ████████████████
+ █████ ▀▀▀▀ █████
+ ████████████████
+  ██████████████
+   ▀██████████▀
+     ▀▀    ▀▀
+    `,
+  },
+  {
+    name: 'Octo',
+    art: `
+    ▄████████▄
+  ██████████████
+ ████████████████
+ ███▀██████▀█████
+ ████████████████
+  ██████████████
+ ▐█▌▐█▌ ██ ▐█▌▐█▌
+ ▐█▌▐█▌ ██ ▐█▌▐█▌
+  ▀  ▀  ▀▀  ▀  ▀
+    `,
+  },
+  {
+    name: 'Ghosty',
+    art: `
+    ▄████████▄
+  ██████████████
+ ████████████████
+ ████▀████▀██████
+ ████████████████
+ ████████████████
+ ████████████████
+ ████████████████
+ █▀█ █▀██ █▀█ █▀
+    `,
+  },
+  {
+    name: 'Foxie',
+    art: `
+▄██▄            ▄██▄
+████▄          ▄████
+██████▄▄▄▄▄▄▄▄██████
+████ ▀████████▀ ████
+█████ ▀██████▀ █████
+████████████████████
+ ██████████████████
+  ████████████████
+   ██████████████
+    ▀██████████▀
+    `,
+  },
+  {
+    name: 'Ducky',
+    art: `
+     ▄████▄
+    ████████▄
+   ██▀████████▄
+  ██████████████
+ ████████████████
+ █████████████▀
+  ▀██████████
+   ▀████████▀
+▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
+    `,
+  },
+  {
+    name: 'Robo',
+    art: `
+      ▄█▄
+    ▄█████▄
+   ██████████
+   ███▀██▀███
+   ██████████
+   ███▄▀▀▄███
+   ██████████
+  ▐██████████▌
+   ███ ████ ██
+   ██        ██
+   ▀▀        ▀▀
+    `,
+  },
+  {
+    name: 'Cactus',
+    art: `
+       ▄██▄
+       ████
+  ▄██▄ ████
+  ████ ████ ▄██▄
+  ████ ████ ████
+  ▀███▄████▄███▀
+       ████
+       ████
+      ██████
+    ▄████████▄
+    ██████████
+    `,
+  },
+  {
+    name: 'Rocket',
+    art: `
+       ▄▄
+      ████
+     ██████
+     ██████
+    ████████
+    ██ ██ ██
+    ████████
+   ██████████
+  ▄██████████▄
+  ██▀██████▀██
+     ██████
+    ▐██████▌
+   ▄██▀  ▀██▄
+   ▀▀      ▀▀
+    `,
+  },
+  {
+    name: 'Skull',
+    art: `
+    ▄██████▄
+  ████████████
+ ██████████████
+ ███▀██████▀███
+ ██████████████
+  █████▄▄█████
+   ████████████
+   █▀█ ▀▀ █▀█
+   █ █ ██ █ █
+    ▀  ▀▀  ▀
+    `,
+  },
+  {
+    name: 'Penguin',
+    art: `
+     ▄████▄
+   ████████████
+  ██████████████
+  ████▀████▀████
+  █████▀▀▀▀█████
+  ██▌ ▄████▄ ▐██
+  ██▌ ██████ ▐██
+  ██▌ ██████ ▐██
+   ▀▌ ██████ ▐▀
+      ██████
+     ▄██  ██▄
+     ▀▀▀  ▀▀▀
+    `,
+  },
+  {
+    name: 'Mushroom',
+    art: `
+     ▄████▄
+   ▄████████▄
+  ██ ▀████▀ ██
+  ██████████████
+  ██ ▀████▀ ██
+  ██████████████
+   ▀██████████▀
+      ██████
+      ██████
+      ██████
+     ████████
+     ▀▀▀▀▀▀▀▀
+    `,
+  },
+  {
+    name: 'Alien',
+    art: `
+   ▄██████████▄
+  ██████████████
+ ██ ▄████████▄ ██
+ ██ █▀██████▀█ ██
+ ██ ██████████ ██
+  ████ ▀▀▀▀ ████
+   ▀██████████▀
+     ████████
+      ██████
+       ████
+       ████
+    `,
+  },
+  {
+    name: 'Coffee',
+    art: `
+   ▐█▌  ▐█▌  ▐█▌
+    ▐█▌  ▐█▌  ▐█▌
+   ▐█▌  ▐█▌  ▐█▌
+  ████████████████
+  ████████████████▄
+  █████████████████
+  █████████████████
+  ████████████████▀
+  ████████████████
+   ▀████████████▀
+  ████████████████
+    `,
+  },
+  {
+    name: 'Diamond',
+    art: `
+       ▄██▄
+      ██████
+     ████████
+    ██████████
+   ████████████
+  ██████████████
+   ████████████
+    ██████████
+     ████████
+      ██████
+       ▀██▀
+    `,
+  },
+];
+
+export const SHAPE_NAMES = SHAPES.map((s) => s.name);

package/src/themes.js

@@ -1,23 +1,68 @@
+/**
+ * Font and gradient theme definitions for shell-logo.
+ *
+ * FONTS  — Figlet font names available for text-mode logos.
+ *          The render loop in index.js cycles through these with arrow keys.
+ *          Indices 0–14 are the original set; new entries are appended so
+ *          saved configs that store a font name keep working.
+ *
+ * THEMES — Named gradient color palettes (3 hex stops each).
+ *          Used by gradient-string to colorize the rendered ASCII art.
+ */
+
+// ── Fonts ──────────────────────────────────────────────────────────────────
+
 export const FONTS = [
+  // Classic / general-purpose
   'Standard', 'Big', 'ANSI Shadow', 'Slant', 'Small',
   'ANSI Regular', 'Bloody', 'DOS Rebel', 'Graffiti', 'Larry 3D',
   'Star Wars', 'Doh', 'Ghost', 'Fraktur', 'Fire Font-k',
+
+  // Block / pixel style — use filled Unicode characters (▄█▀) instead of
+  // typical ASCII slashes and pipes, giving a "painted pixels" look.
+  'Block', 'Blocks', 'Shaded Blocky', 'Small Block',
+  'Dot Matrix', 'Tiles', 'Rectangles',
+
+  // Popular classic figlet fonts
+  'Doom', 'Banner3-D', 'Colossal', 'Epic',
+  'Calvin S', 'Speed', '3D-ASCII', 'Isometric1',
 ];
 
+// ── Gradient themes ────────────────────────────────────────────────────────
+
 export const THEMES = [
-  { name: 'Sunset',     colors: ['#ff6b6b', '#ff9f43', '#feca57'] },
-  { name: 'Ocean',      colors: ['#0abde3', '#48dbfb', '#54a0ff'] },
-  { name: 'Forest',     colors: ['#1dd1a1', '#2ed573', '#26de81'] },
-  { name: 'Neon',       colors: ['#c56cf0', '#fd79a8', '#ff6b6b'] },
-  { name: 'Twilight',   colors: ['#5f27cd', '#c56cf0', '#48dbfb'] },
-  { name: 'Fire',       colors: ['#ff4757', '#ff6348', '#ffdd59'] },
-  { name: 'Pastel',     colors: ['#fd79a8', '#feca57', '#48dbfb'] },
-  { name: 'Monochrome', colors: ['#ffffff', '#54a0ff', '#5f27cd'] },
-  { name: 'Aurora',     colors: ['#00d2ff', '#3a7bd5', '#7b2ff7'] },
-  { name: 'Cherry',     colors: ['#eb3349', '#f45c43', '#ff8a80'] },
-  { name: 'Cyberpunk',  colors: ['#f72585', '#7209b7', '#4cc9f0'] },
-  { name: 'Arctic',     colors: ['#e0eafc', '#cfdef3', '#74b9ff'] },
-  { name: 'Emerald',    colors: ['#11998e', '#38ef7d', '#b8ff96'] },
-  { name: 'Midnight',   colors: ['#0f0c29', '#302b63', '#24c6dc'] },
-  { name: 'Rose Gold',  colors: ['#f4c4f3', '#fc5c7d', '#fda085'] },
+  // Warm
+  { name: 'Sunset',          colors: ['#ff6b6b', '#ff9f43', '#feca57'] },
+  { name: 'Fire',            colors: ['#ff4757', '#ff6348', '#ffdd59'] },
+  { name: 'Cherry',          colors: ['#eb3349', '#f45c43', '#ff8a80'] },
+  { name: 'Rose Gold',       colors: ['#f4c4f3', '#fc5c7d', '#fda085'] },
+  { name: 'Magma',           colors: ['#f83600', '#f9d423', '#fe8c00'] },
+  { name: 'Sunrise',         colors: ['#ff512f', '#f09819', '#ffed4a'] },
+  { name: 'Copper',          colors: ['#b87333', '#da9855', '#f0c27f'] },
+
+  // Cool
+  { name: 'Ocean',           colors: ['#0abde3', '#48dbfb', '#54a0ff'] },
+  { name: 'Arctic',          colors: ['#e0eafc', '#cfdef3', '#74b9ff'] },
+  { name: 'Frost',           colors: ['#e8f0ff', '#b8d4f0', '#88b8e0'] },
+  { name: 'Electric',        colors: ['#00f2fe', '#4facfe', '#667eea'] },
+
+  // Green
+  { name: 'Forest',          colors: ['#1dd1a1', '#2ed573', '#26de81'] },
+  { name: 'Emerald',         colors: ['#11998e', '#38ef7d', '#b8ff96'] },
+  { name: 'Toxic',           colors: ['#a8ff78', '#78ffd6', '#00e676'] },
+  { name: 'Matrix',          colors: ['#00ff41', '#008f11', '#003b00'] },
+
+  // Purple / pink
+  { name: 'Neon',            colors: ['#c56cf0', '#fd79a8', '#ff6b6b'] },
+  { name: 'Twilight',        colors: ['#5f27cd', '#c56cf0', '#48dbfb'] },
+  { name: 'Cyberpunk',       colors: ['#f72585', '#7209b7', '#4cc9f0'] },
+  { name: 'Grape',           colors: ['#6a0572', '#ab83a1', '#e0aaff'] },
+  { name: 'Lavender Dream',  colors: ['#a18cd1', '#fbc2eb', '#f6d5f7'] },
+  { name: 'Bubblegum',       colors: ['#ff77ab', '#ff99cc', '#ffbbdd'] },
+
+  // Multi / neutral
+  { name: 'Pastel',          colors: ['#fd79a8', '#feca57', '#48dbfb'] },
+  { name: 'Monochrome',      colors: ['#ffffff', '#54a0ff', '#5f27cd'] },
+  { name: 'Aurora',          colors: ['#00d2ff', '#3a7bd5', '#7b2ff7'] },
+  { name: 'Midnight',        colors: ['#0f0c29', '#302b63', '#24c6dc'] },
 ];

package/src/ui.js

@@ -1,6 +1,22 @@
+/**
+ * Interactive CLI prompts for shell-logo.
+ *
+ * When a config already exists for the current folder, presents three options:
+ *   - Run          — display the logo, arrow key changes persist to disk
+ *   - New session  — display the logo, changes are in-memory only (temporary)
+ *   - Generate     — walk through the setup wizard to create a new config
+ *
+ * When no config exists, only the Generate option is shown.
+ *
+ * Returns { action, config, persistent } where `persistent` controls
+ * whether arrow key theme/font changes are saved back to disk.
+ */
+
 import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { tryLoadConfig } from './config.js';
+import { SHAPES } from './shapes.js';
+import { FONTS } from './themes.js';
 
 const COLOR_PALETTE = [
   { value: '#ff6b6b', label: `${chalk.bgHex('#ff6b6b')('   ')} Coral` },
@@ -21,24 +37,9 @@ const COLOR_PALETTE = [
   { value: '#ffffff', label: `${chalk.bgHex('#ffffff')('   ')} White` },
 ];
 
-const FONT_OPTIONS = [
-  { value: 'Standard', label: 'Standard' },
-  { value: 'Big', label: 'Big' },
-  { value: 'ANSI Shadow', label: 'ANSI Shadow' },
-  { value: 'Slant', label: 'Slant' },
-  { value: 'Small', label: 'Small' },
-  { value: 'ANSI Regular', label: 'ANSI Regular' },
-  { value: 'Bloody', label: 'Bloody' },
-  { value: 'DOS Rebel', label: 'DOS Rebel' },
-  { value: 'Graffiti', label: 'Graffiti' },
-  { value: 'Larry 3D', label: 'Larry 3D' },
-  { value: 'Star Wars', label: 'Star Wars' },
-  { value: 'Doh', label: 'Doh' },
-  { value: 'Ghost', label: 'Ghost' },
-  { value: 'Fraktur', label: 'Fraktur' },
-  { value: 'Fire Font-k', label: 'Fire Font-k' },
-];
+const FONT_OPTIONS = FONTS.map(f => ({ value: f, label: f }));
 
+/** Exit gracefully if the user presses Ctrl+C / Escape during a prompt. */
 function handleCancel(value) {
   if (p.isCancel(value)) {
     p.cancel('Cancelled.');
@@ -47,18 +48,8 @@ function handleCancel(value) {
   return value;
 }
 
-async function promptGenerate() {
-  const text = handleCancel(
-    await p.text({
-      message: 'What text should the logo display?',
-      placeholder: 'HELLO',
-      validate: (val) => {
-        if (!val || val.trim() === '') return 'Text is required.';
-      },
-    })
-  );
-
-  // Pick 3 random unique colors as defaults
+/** Prompt for gradient colors (shared by text and shape modes). */
+async function promptColors() {
   const shuffled = [...COLOR_PALETTE].sort(() => Math.random() - 0.5);
   const initialColors = shuffled.slice(0, 3).map(c => c.value);
 
@@ -76,6 +67,40 @@ async function promptGenerate() {
     if (colors.length >= 2) break;
     p.log.warning('Please select at least 2 colors.');
   }
+  return colors;
+}
+
+/** Walk the user through the Shape wizard: shape picker, colors. */
+async function promptShapeGenerate() {
+  const shape = handleCancel(
+    await p.select({
+      message: 'Pick a mascot:',
+      options: SHAPES.map((s) => ({ value: s.name, label: s.name })),
+    })
+  );
+
+  const colors = await promptColors();
+
+  return {
+    action: 'generate',
+    config: { mode: 'shape', shape, colors },
+    persistent: true,
+  };
+}
+
+/** Walk the user through the Text wizard: text, colors, font. */
+async function promptTextGenerate() {
+  const text = handleCancel(
+    await p.text({
+      message: 'What text should the logo display?',
+      placeholder: 'HELLO',
+      validate: (val) => {
+        if (!val || val.trim() === '') return 'Text is required.';
+      },
+    })
+  );
+
+  const colors = await promptColors();
 
   const font = handleCancel(
     await p.select({
@@ -86,22 +111,70 @@ async function promptGenerate() {
 
   return {
     action: 'generate',
-    config: { text: text.trim(), colors, font },
+    config: { mode: 'text', text: text.trim(), colors, font },
+    persistent: true,
   };
 }
 
+/** Walk the user through the Generate wizard: mode selection, then mode-specific prompts. */
+async function promptGenerate() {
+  const mode = handleCancel(
+    await p.select({
+      message: 'What kind of logo?',
+      options: [
+        { value: 'text', label: 'Text', hint: 'type your own text' },
+        { value: 'shape', label: 'Shape', hint: 'pick a mascot/pet' },
+      ],
+    })
+  );
+
+  if (mode === 'shape') return promptShapeGenerate();
+  return promptTextGenerate();
+}
+
+/**
+ * Main entry point for the interactive CLI.
+ * Returns { action: 'generate'|'run', config, persistent }.
+ */
 export async function runInteractiveUI() {
   p.intro(chalk.bold('terminal-logo'));
 
-  const hasConfig = !!tryLoadConfig();
+  const existingConfig = tryLoadConfig();
+
+  if (existingConfig) {
+    const action = handleCancel(
+      await p.select({
+        message: 'What would you like to do?',
+        initialValue: 'run',
+        options: [
+          { value: 'run', label: 'Run', hint: 'use saved config' },
+          { value: 'temp', label: 'New session', hint: "temporary, changes won't be saved" },
+          { value: 'generate', label: 'Generate', hint: 'create a new logo config' },
+        ],
+      })
+    );
+
+    if (action === 'generate') {
+      return promptGenerate();
+    }
+
+    if (action === 'temp') {
+      p.outro('Launching logo (temporary session)...');
+      return { action: 'run', config: existingConfig, persistent: false };
+    }
 
+    // action === 'run'
+    p.outro('Launching logo...');
+    return { action: 'run', config: existingConfig, persistent: true };
+  }
+
+  // No existing config — only offer Generate
   const action = handleCancel(
     await p.select({
       message: 'What would you like to do?',
-      initialValue: hasConfig ? 'run' : 'generate',
+      initialValue: 'generate',
       options: [
-        { value: 'generate', label: 'Generate', hint: 'create .shell-logo.json' },
-        { value: 'run', label: 'Run', hint: 'display current logo' },
+        { value: 'generate', label: 'Generate', hint: 'create a new logo config' },
       ],
     })
   );
@@ -109,18 +182,4 @@ export async function runInteractiveUI() {
   if (action === 'generate') {
     return promptGenerate();
   }
-
-  // action === 'run'
-  const config = tryLoadConfig();
-  if (!config) {
-    p.log.error(
-      'No valid .shell-logo.json found in the current directory.\n' +
-        '  Run again and choose "Generate" to create one.'
-    );
-    p.outro('Done');
-    process.exit(1);
-  }
-
-  p.outro('Launching logo...');
-  return { action: 'run', config };
 }