movehat 0.2.4 → 0.2.5

package/src/ui/__tests__/colors.test.ts

@@ -1,156 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import {
-  shouldUseColor,
-  colors,
-  rgbToAnsi,
-  applyGradient,
-  gradients,
-} from '../colors.js';
-
-describe('shouldUseColor', () => {
-  const originalEnv = process.env;
-  const originalIsTTY = process.stdout.isTTY;
-
-  beforeEach(() => {
-    process.env = { ...originalEnv };
-    delete process.env.NO_COLOR;
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-    Object.defineProperty(process.stdout, 'isTTY', { value: originalIsTTY });
-  });
-
-  it('should return true when TTY and NO_COLOR not set', () => {
-    Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
-    delete process.env.NO_COLOR;
-    expect(shouldUseColor()).toBe(true);
-  });
-
-  it('should return false when NO_COLOR is set', () => {
-    Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
-    process.env.NO_COLOR = '1';
-    expect(shouldUseColor()).toBe(false);
-  });
-
-  it('should return false when not TTY', () => {
-    Object.defineProperty(process.stdout, 'isTTY', { value: false, configurable: true });
-    delete process.env.NO_COLOR;
-    expect(shouldUseColor()).toBe(false);
-  });
-});
-
-describe('rgbToAnsi', () => {
-  it('should generate correct ANSI escape code', () => {
-    expect(rgbToAnsi(255, 0, 0)).toBe('\x1b[38;2;255;0;0m');
-    expect(rgbToAnsi(0, 255, 0)).toBe('\x1b[38;2;0;255;0m');
-    expect(rgbToAnsi(0, 0, 255)).toBe('\x1b[38;2;0;0;255m');
-    expect(rgbToAnsi(128, 128, 128)).toBe('\x1b[38;2;128;128;128m');
-  });
-
-  it('should handle edge values', () => {
-    expect(rgbToAnsi(0, 0, 0)).toBe('\x1b[38;2;0;0;0m');
-    expect(rgbToAnsi(255, 255, 255)).toBe('\x1b[38;2;255;255;255m');
-  });
-});
-
-describe('applyGradient', () => {
-  const originalEnv = process.env;
-  const originalIsTTY = process.stdout.isTTY;
-
-  beforeEach(() => {
-    process.env = { ...originalEnv };
-    delete process.env.NO_COLOR;
-    Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-    Object.defineProperty(process.stdout, 'isTTY', { value: originalIsTTY });
-  });
-
-  it('should apply gradient to text', () => {
-    const palette = [[255, 0, 0], [0, 255, 0]] as [number, number, number][];
-    const result = applyGradient('AB', palette);
-
-    expect(result).toContain('\x1b[38;2;255;0;0m'); // Red for 'A'
-    expect(result).toContain('\x1b[38;2;0;255;0m'); // Green for 'B'
-    expect(result).toContain('A');
-    expect(result).toContain('B');
-    expect(result).toContain('\x1b[0m'); // Reset at end
-  });
-
-  it('should return plain text when colors disabled', () => {
-    process.env.NO_COLOR = '1';
-    const palette = [[255, 0, 0]] as [number, number, number][];
-    const result = applyGradient('Hello', palette);
-
-    expect(result).toBe('Hello');
-    expect(result).not.toContain('\x1b');
-  });
-
-  it('should cycle through palette for long text', () => {
-    const palette = [[255, 0, 0], [0, 255, 0]] as [number, number, number][];
-    const result = applyGradient('ABCD', palette);
-
-    // Should alternate: A=red, B=green, C=red, D=green
-    expect(result).toContain('A');
-    expect(result).toContain('B');
-    expect(result).toContain('C');
-    expect(result).toContain('D');
-  });
-
-  it('should handle offset parameter', () => {
-    const palette = [[255, 0, 0], [0, 255, 0]] as [number, number, number][];
-    const result = applyGradient('AB', palette, 1);
-
-    // With offset 1: A=green, B=red
-    expect(result.indexOf('\x1b[38;2;0;255;0m')).toBeLessThan(result.indexOf('\x1b[38;2;255;0;0m'));
-  });
-});
-
-describe('gradients', () => {
-  it('should have movehat gradient with 5 colors', () => {
-    expect(gradients.movehat).toHaveLength(5);
-    gradients.movehat.forEach(([r, g, b]) => {
-      expect(r).toBeGreaterThanOrEqual(0);
-      expect(r).toBeLessThanOrEqual(255);
-      expect(g).toBeGreaterThanOrEqual(0);
-      expect(g).toBeLessThanOrEqual(255);
-      expect(b).toBeGreaterThanOrEqual(0);
-      expect(b).toBeLessThanOrEqual(255);
-    });
-  });
-
-  it('should have success gradient', () => {
-    expect(gradients.success).toBeDefined();
-    expect(gradients.success.length).toBeGreaterThan(0);
-  });
-
-  it('should have error gradient', () => {
-    expect(gradients.error).toBeDefined();
-    expect(gradients.error.length).toBeGreaterThan(0);
-  });
-});
-
-describe('colors object', () => {
-  it('should have all semantic color functions', () => {
-    expect(typeof colors.success).toBe('function');
-    expect(typeof colors.error).toBe('function');
-    expect(typeof colors.warning).toBe('function');
-    expect(typeof colors.info).toBe('function');
-    expect(typeof colors.primary).toBe('function');
-    expect(typeof colors.secondary).toBe('function');
-    expect(typeof colors.muted).toBe('function');
-    expect(typeof colors.dim).toBe('function');
-    expect(typeof colors.bold).toBe('function');
-    expect(typeof colors.brand).toBe('function');
-    expect(typeof colors.brandBright).toBe('function');
-  });
-
-  it('should return strings when called', () => {
-    expect(typeof colors.success('test')).toBe('string');
-    expect(typeof colors.error('test')).toBe('string');
-    expect(typeof colors.brand('test')).toBe('string');
-  });
-});

package/src/ui/__tests__/logger.test.ts

@@ -1,89 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { configureLogger, isVerbose, divider, phase } from "../logger.js";
-
-describe("logger — verbosity", () => {
-  let originalEnv: string | undefined;
-
-  beforeEach(() => {
-    originalEnv = process.env.MOVEHAT_VERBOSE;
-    // Start each test from a clean slate so prior runs cannot leak.
-    delete process.env.MOVEHAT_VERBOSE;
-    configureLogger({ verbosity: "normal" });
-  });
-
-  afterEach(() => {
-    if (originalEnv === undefined) {
-      delete process.env.MOVEHAT_VERBOSE;
-    } else {
-      process.env.MOVEHAT_VERBOSE = originalEnv;
-    }
-    configureLogger({ verbosity: "normal" });
-  });
-
-  it("defaults to non-verbose when MOVEHAT_VERBOSE is unset and config is normal", () => {
-    expect(isVerbose()).toBe(false);
-  });
-
-  it("returns true when MOVEHAT_VERBOSE=1 (env-driven path)", () => {
-    process.env.MOVEHAT_VERBOSE = "1";
-    expect(isVerbose()).toBe(true);
-  });
-
-  it("returns true when configureLogger({ verbosity: 'verbose' }) is set in-process", () => {
-    configureLogger({ verbosity: "verbose" });
-    expect(isVerbose()).toBe(true);
-  });
-
-  it("env var wins even when in-process config is normal (allows shell-script callers)", () => {
-    configureLogger({ verbosity: "normal" });
-    process.env.MOVEHAT_VERBOSE = "1";
-    expect(isVerbose()).toBe(true);
-  });
-
-  it("non-'1' MOVEHAT_VERBOSE values do not enable verbose mode", () => {
-    process.env.MOVEHAT_VERBOSE = "true";
-    expect(isVerbose()).toBe(false);
-    process.env.MOVEHAT_VERBOSE = "0";
-    expect(isVerbose()).toBe(false);
-  });
-});
-
-describe("logger.phase / logger.divider", () => {
-  let logSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
-    configureLogger({ silent: false });
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("phase prints three lines: top rule, indented title, bottom rule", () => {
-    phase("Local Movement node");
-    expect(logSpy).toHaveBeenCalledTimes(3);
-
-    const calls = logSpy.mock.calls.map((c: unknown[]) => String(c[0]));
-    // The title line carries the supplied text after the two-space indent.
-    expect(calls[1]).toContain("Local Movement node");
-    // Top and bottom rules should be identical (same width, same color).
-    expect(calls[0]).toBe(calls[2]);
-  });
-
-  it("divider prints a single muted rule line", () => {
-    divider();
-    expect(logSpy).toHaveBeenCalledTimes(1);
-    const line = String(logSpy.mock.calls[0]?.[0] ?? "");
-    // The rule character is `━` (BOX DRAWINGS HEAVY HORIZONTAL).
-    expect(line).toMatch(/━+/);
-  });
-
-  it("phase and divider are silenced when configureLogger({ silent: true })", () => {
-    configureLogger({ silent: true });
-    phase("hidden phase");
-    divider();
-    expect(logSpy).not.toHaveBeenCalled();
-  });
-});

package/src/ui/colors.ts

@@ -1,144 +0,0 @@
-import pc from 'picocolors';
-
-/**
- * RGB type for gradient functions
- */
-export type Rgb = [number, number, number];
-
-/**
- * Detect if colors should be used
- * Respects NO_COLOR env var and TTY detection
- */
-export const shouldUseColor = (): boolean => {
-  return process.env.NO_COLOR === undefined && Boolean(process.stdout.isTTY);
-};
-
-/**
- * Conditional color wrapper
- * Returns identity function if colors disabled
- */
-const color = (fn: (str: string) => string) => {
-  return shouldUseColor() ? fn : (str: string) => str;
-};
-
-/**
- * Semantic color palette
- * Maps intent to colors consistently across the CLI
- */
-export const colors = {
-  // Status colors
-  success: color(pc.green),
-  error: color(pc.red),
-  warning: color(pc.yellow),
-  info: color(pc.cyan),
-
-  // UI element colors
-  primary: color(pc.magenta),
-  secondary: color(pc.blue),
-  muted: color(pc.gray),
-  dim: color(pc.dim),
-  bold: color(pc.bold),
-
-  // Movehat brand colors (amber/yellow gradient)
-  brand: color(pc.yellow),
-  brandBright: color((str: string) => pc.yellow(pc.bold(str))),
-
-  // Direct access for advanced use
-  raw: shouldUseColor() ? pc : createNoopColors(),
-};
-
-/**
- * Convert RGB to ANSI 24-bit color code
- *
- * @param r - Red value (0-255)
- * @param g - Green value (0-255)
- * @param b - Blue value (0-255)
- * @returns ANSI escape code for RGB color
- *
- * @example
- * const red = rgbToAnsi(255, 0, 0);
- * console.log(`${red}This is red text\x1b[0m`);
- */
-export const rgbToAnsi = (r: number, g: number, b: number): string => {
-  return `\x1b[38;2;${r};${g};${b}m`;
-};
-
-/**
- * Apply gradient to text using RGB palette
- * Migrated from banner.ts for reuse across the application
- *
- * @param text - Text to colorize with gradient
- * @param palette - Array of RGB color values
- * @param offset - Starting offset in palette (useful for animation)
- * @returns Colored text with gradient applied
- *
- * @example
- * const gradient = applyGradient('MOVEHAT', gradients.movehat);
- * console.log(gradient);
- */
-export const applyGradient = (
-  text: string,
-  palette: Rgb[],
-  offset: number = 0
-): string => {
-  if (!shouldUseColor()) return text;
-
-  let result = '';
-  for (let i = 0; i < text.length; i++) {
-    const colorIndex = (i + offset) % palette.length;
-    const color = palette[colorIndex];
-    const ch = text[i];
-    if (!color || ch === undefined) continue;
-    const [r, g, b] = color;
-    result += `${rgbToAnsi(r, g, b)}${ch}`;
-  }
-  return result + '\x1b[0m';
-};
-
-/**
- * Preset gradient palettes for consistent branding
- */
-export const gradients = {
-  /**
-   * Movehat brand gradient (warm yellow/amber)
-   * Used for the banner and brand-related UI elements
-   */
-  movehat: [
-    [255, 239, 150],
-    [255, 223, 88],
-    [255, 207, 64],
-    [255, 181, 45],
-    [255, 160, 30],
-  ] as Rgb[],
-
-  /**
-   * Success gradient (green tones)
-   * For positive feedback and success states
-   */
-  success: [
-    [144, 238, 144],
-    [60, 179, 113],
-    [46, 139, 87],
-  ] as Rgb[],
-
-  /**
-   * Error gradient (red tones)
-   * For errors and warnings
-   */
-  error: [
-    [255, 182, 193],
-    [220, 20, 60],
-    [178, 34, 34],
-  ] as Rgb[],
-};
-
-/**
- * No-op color functions for when colors are disabled
- * Uses a Proxy to return identity function for any property access
- */
-function createNoopColors() {
-  const noop = (str: string) => str;
-  return new Proxy({} as typeof pc, {
-    get: () => noop,
-  });
-}

package/src/ui/formatters.ts

@@ -1,246 +0,0 @@
-import { colors } from './colors.js';
-import { symbols } from './symbols.js';
-
-/**
- * Border color options for boxes
- */
-export type BorderColor = 'dim' | 'primary' | 'success' | 'error' | 'warning';
-
-/**
- * Box formatting options
- */
-export interface BoxOptions {
-  /** Padding inside the box (default: 1) */
-  padding?: number;
-  /** Margin outside the box (default: 0) */
-  margin?: number;
-  /** Border color (default: 'dim') */
-  borderColor?: BorderColor;
-}
-
-/**
- * Create a box around text with Unicode borders
- *
- * @param content - Text content to box (supports multiline)
- * @param options - Box formatting options
- * @returns Formatted box string
- *
- * @example
- * const message = box('Update available: 1.0.0 → 1.1.0');
- * console.log(message);
- * // ┌────────────────────────────────┐
- * // │ Update available: 1.0.0 → 1.1.0│
- * // └────────────────────────────────┘
- *
- * @example
- * const warning = box(
- *   'This feature is deprecated\nUse the new API instead',
- *   { borderColor: 'warning', padding: 2 }
- * );
- */
-export const box = (
-  content: string,
-  options: BoxOptions = {}
-): string => {
-  const { padding = 1, margin = 0, borderColor = 'dim' } = options;
-
-  const lines = content.split('\n');
-  const maxWidth = Math.max(...lines.map(l => l.length));
-  const innerWidth = maxWidth + padding * 2;
-
-  const marginStr = ' '.repeat(margin);
-  const paddingStr = ' '.repeat(padding);
-
-  const colorFn = colors[borderColor] || colors.dim;
-
-  const top = marginStr + colorFn(symbols.boxTopLeft + symbols.boxTop.repeat(innerWidth) + symbols.boxTopRight);
-  const bottom = marginStr + colorFn(symbols.boxBottomLeft + symbols.boxBottom.repeat(innerWidth) + symbols.boxBottomRight);
-
-  const middle = lines.map(line => {
-    const padded = line.padEnd(maxWidth);
-    return marginStr + colorFn(symbols.boxLeft) + paddingStr + padded + paddingStr + colorFn(symbols.boxRight);
-  });
-
-  return [top, ...middle, bottom].join('\n');
-};
-
-/**
- * List formatting options
- */
-export interface ListOptions {
-  /** Number of spaces to indent (default: 0) */
-  indent?: number;
-  /** Starting number for numbered lists (default: 1) */
-  startFrom?: number;
-  /** Custom symbol for bullet lists */
-  symbol?: string;
-}
-
-/**
- * Create a numbered list
- *
- * @param items - Array of items to list
- * @param options - List formatting options
- * @returns Formatted numbered list string
- *
- * @example
- * const steps = numberedList([
- *   'cd my-project',
- *   'npm install',
- *   'npm test'
- * ]);
- * console.log(steps);
- * // 1. cd my-project
- * // 2. npm install
- * // 3. npm test
- */
-export const numberedList = (
-  items: string[],
-  options: ListOptions = {}
-): string => {
-  const { indent = 0, startFrom = 1 } = options;
-  const prefix = ' '.repeat(indent);
-
-  return items
-    .map((item, idx) => `${prefix}${startFrom + idx}. ${item}`)
-    .join('\n');
-};
-
-/**
- * Create a bulleted list
- *
- * @param items - Array of items to list
- * @param options - List formatting options
- * @returns Formatted bulleted list string
- *
- * @example
- * const features = bulletList([
- *   'Feature A',
- *   'Feature B',
- *   'Feature C'
- * ]);
- * console.log(features);
- * // • Feature A
- * // • Feature B
- * // • Feature C
- *
- * @example
- * const tasks = bulletList(
- *   ['Task 1', 'Task 2'],
- *   { indent: 2, symbol: '→' }
- * );
- */
-export const bulletList = (
-  items: string[],
-  options: ListOptions = {}
-): string => {
-  const { indent = 0, symbol = symbols.bullet } = options;
-  const prefix = ' '.repeat(indent);
-
-  return items
-    .map(item => `${prefix}${symbol} ${item}`)
-    .join('\n');
-};
-
-/**
- * Indent text block by a specified number of spaces
- *
- * @param text - Text to indent (supports multiline)
- * @param spaces - Number of spaces to indent
- * @returns Indented text
- *
- * @example
- * const code = 'function test() {\n  return true;\n}';
- * console.log(indent(code, 4));
- * //     function test() {
- * //       return true;
- * //     }
- */
-export const indent = (text: string, spaces: number): string => {
-  const prefix = ' '.repeat(spaces);
-  return text.split('\n').map(line => prefix + line).join('\n');
-};
-
-/**
- * Create a horizontal divider line
- *
- * @param width - Width of the divider (default: 60)
- * @param char - Character to use (default: symbols.line)
- * @returns Formatted divider string
- *
- * @example
- * console.log(divider());
- * // ────────────────────────────────────────────────────────────
- *
- * @example
- * console.log(divider(40, '='));
- * // ========================================
- */
-const divider = (
-  width: number = 60,
-  char: string = symbols.line
-): string => {
-  return colors.dim(char.repeat(width));
-};
-
-/**
- * Format file path with dimmed parent directories
- * Highlights the filename while dimming the directory path
- *
- * @param filePath - Full file path
- * @returns Formatted path string
- *
- * @example
- * console.log(formatPath('/Users/name/project/src/file.ts'));
- * // /Users/name/project/src/file.ts
- * // (where the directory is dimmed and filename is bright)
- */
-export const formatPath = (filePath: string): string => {
-  const parts = filePath.split('/');
-  const fileName = parts.pop() || '';
-  const dirPath = parts.join('/');
-
-  return colors.dim(dirPath + '/') + fileName;
-};
-
-/**
- * Create a section header with divider
- * Combines a bold title with a horizontal line
- *
- * @param title - Section title
- * @param options - Formatting options
- * @returns Formatted section header
- *
- * @example
- * console.log(sectionHeader('Fork Details'));
- * //
- * // Fork Details
- * // ────────────────────────────────────────────────────────────
- */
-export const sectionHeader = (
-  title: string,
-  options: { width?: number; char?: string } = {}
-): string => {
-  const { width = 60, char = symbols.line } = options;
-  return `\n${colors.brandBright(title)}\n${divider(width, char)}`;
-};
-
-/**
- * Format a command for display with dimmed prompt
- * Useful for showing example commands to users
- *
- * @param command - Command string
- * @returns Formatted command with $ prompt
- *
- * @example
- * console.log(formatCommand('movehat compile'));
- * // $ movehat compile
- * // (where $ is dimmed)
- *
- * @example
- * console.log(formatCommand('npm install'));
- * // $ npm install
- */
-export const formatCommand = (command: string): string => {
-  return `${colors.dim('$')} ${command}`;
-};

package/src/ui/index.ts

@@ -1,62 +0,0 @@
-/**
- * Movehat UI Module
- *
- * Provides a comprehensive set of UI utilities for the CLI including:
- * - Colors and gradients (picocolors wrapper)
- * - Cross-platform symbols (figures wrapper)
- * - Structured logging system
- * - Spinners for async operations (ora wrapper)
- * - Table formatting (cli-table3 wrapper)
- * - Text formatting utilities
- *
- * @example
- * // Named imports (recommended)
- * import { logger, spinner, createTable } from './ui/index.js';
- *
- * logger.info('Starting compilation...');
- * const spin = spinner({ text: 'Compiling...' });
- * // ... async work ...
- * spin.succeed('Compilation complete!');
- *
- * @example
- * // Namespace import
- * import { ui } from './ui/index.js';
- *
- * ui.logger.info('Starting...');
- * ui.logger.success('Done!');
- */
-
-// Re-export everything from submodules for named imports
-export * from './colors.js';
-export * from './symbols.js';
-export * from './logger.js';
-export * from './spinner.js';
-export * from './table.js';
-export * from './formatters.js';
-
-// Also export as namespace for convenience
-import * as _colors from './colors.js';
-import * as _symbols from './symbols.js';
-import * as _logger from './logger.js';
-import * as _spinner from './spinner.js';
-import * as _table from './table.js';
-import * as _formatters from './formatters.js';
-
-/**
- * Unified UI namespace
- * Provides all UI utilities in a single namespace object
- *
- * @example
- * import { ui } from './ui/index.js';
- *
- * ui.logger.info('Processing...');
- * ui.logger.success('Done!');
- */
-export const ui = {
-  colors: _colors,
-  symbols: _symbols,
-  logger: _logger,
-  spinner: _spinner,
-  table: _table,
-  formatters: _formatters,
-};