shell-logo 0.1.0 → 0.1.2

package/package.json

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

package/src/config.js

@@ -1,22 +1,30 @@
+/**
+ * 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';
 
 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.
+ * Requires a non-empty `text` field. Colors must be an array of 2+ if present.
+ * Returns a normalized config object, or null if invalid.
+ */
+function parseAndValidate(raw) {
   let config;
   try {
     config = JSON.parse(raw);
@@ -41,51 +49,60 @@ export function tryLoadConfig() {
   };
 }
 
-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,7 +1,13 @@
 #!/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';
@@ -10,56 +16,26 @@ import { THEMES, FONTS } from './themes.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;
 
   // Find the current theme index by matching colors
@@ -85,6 +61,7 @@ function startRenderLoop(config) {
     }
   }
 
+  /** Briefly show the status bar (theme name, font, controls) for 2 seconds. */
   function flashStatus() {
     showStatus = true;
     clearTimeout(statusTimer);
@@ -94,6 +71,7 @@ function startRenderLoop(config) {
     }, 2000);
   }
 
+  /** Debounce re-renders on terminal resize to avoid flickering. */
   function debouncedRender() {
     clearTimeout(resizeTimer);
     resizeTimer = setTimeout(renderLoop, 50);
@@ -140,7 +118,8 @@ function startRenderLoop(config) {
       } 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/themes.js

@@ -1,4 +1,8 @@
-export const FONTS = ['Standard', 'Big', 'ANSI Shadow', 'Slant', 'Small'];
+export const FONTS = [
+  'Standard', 'Big', 'ANSI Shadow', 'Slant', 'Small',
+  'ANSI Regular', 'Bloody', 'DOS Rebel', 'Graffiti', 'Larry 3D',
+  'Star Wars', 'Doh', 'Ghost', 'Fraktur', 'Fire Font-k',
+];
 
 export const THEMES = [
   { name: 'Sunset',     colors: ['#ff6b6b', '#ff9f43', '#feca57'] },
@@ -9,4 +13,11 @@ export const THEMES = [
   { 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'] },
 ];

package/src/ui.js

@@ -1,3 +1,17 @@
+/**
+ * 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';
@@ -27,8 +41,19 @@ const FONT_OPTIONS = [
   { 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' },
 ];
 
+/** Exit gracefully if the user presses Ctrl+C / Escape during a prompt. */
 function handleCancel(value) {
   if (p.isCancel(value)) {
     p.cancel('Cancelled.');
@@ -37,6 +62,7 @@ function handleCancel(value) {
   return value;
 }
 
+/** Walk the user through the Generate wizard: text, colors, font. */
 async function promptGenerate() {
   const text = handleCancel(
     await p.text({
@@ -77,21 +103,53 @@ async function promptGenerate() {
   return {
     action: 'generate',
     config: { text: text.trim(), colors, font },
+    persistent: true,
   };
 }
 
+/**
+ * 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' },
       ],
     })
   );
@@ -99,18 +157,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 };
 }