import { text, select, confirm, spinner, log, prism } from '@xec-sh/kit';

// Get user input
const name = await text({
  message: 'What is your name?',
  placeholder: 'Enter your name',
  validate: (value) => {
    if (!value) return 'Name is required';
  },
});

// Single selection
const framework = await select({
  message: 'Choose a framework',
  options: [
    { value: 'react', label: 'React' },
    { value: 'vue', label: 'Vue' },
    { value: 'svelte', label: 'Svelte' },
  ],
});

// Confirmation
const confirmed = await confirm({
  message: 'Continue with installation?',
  initialValue: true,
});

// Show spinner during async operation
const s = spinner();
s.start('Installing dependencies...');
await installDependencies();
s.stop('Installation complete!');

// Logging with colors
log.info('This is an info message');
log.success('This is a success message');
log.warn('This is a warning');
log.error('This is an error');

// Use prism for advanced coloring
console.log(prism.cyan('Hello') + ' ' + prism.bold.yellow('World!'));
console.log(prism.rgb(255, 100, 50)('Custom RGB color'));
console.log(prism.hex('#ff6432')('Hex color'));

import { multiselect, autocomplete, password } from '@xec-sh/kit';

// Multi-selection
const features = await multiselect({
  message: 'Select features to enable',
  options: [
    { value: 'typescript', label: 'TypeScript', hint: 'Type-safe code' },
    { value: 'testing', label: 'Unit Testing', hint: 'Vitest included' },
    { value: 'linting', label: 'ESLint', hint: 'Code quality' },
    { value: 'formatting', label: 'Prettier', hint: 'Code formatting' },
  ],
  required: true,
});

// Autocomplete with search
const country = await autocomplete({
  message: 'Select your country',
  options: [
    { value: 'us', label: 'United States' },
    { value: 'uk', label: 'United Kingdom' },
    { value: 'ca', label: 'Canada' },
    // ... more options
  ],
});

// Password input
const password = await password({
  message: 'Enter your password',
  validate: (value) => {
    if (value.length < 8) return 'Password must be at least 8 characters';
  },
});

import { box, note, progressBar, taskLog } from '@xec-sh/kit';

// Display a box
box({
  title: 'Welcome',
  content: 'This is a boxed message with a title',
  borderColor: 'cyan',
});

// Show a note
note('This is an important note', 'Note');

// Progress bar
const total = 100;
const bar = progressBar({ total });
for (let i = 0; i <= total; i++) {
  bar.update(i);
  await sleep(10);
}

// Task log for multiple tasks
const tasks = taskLog();
const t1 = tasks.add('Build project');
const t2 = tasks.add('Run tests');
const t3 = tasks.add('Deploy');

t1.start();
await build();
t1.complete('Built successfully');

t2.start();
await test();
t2.complete('Tests passed');

t3.start();
await deploy();
t3.complete('Deployed to production');

class Prompt<TValue> extends EventEmitter {
  state: ClackState;  // 'initial' | 'active' | 'cancel' | 'submit' | 'error'
  value: TValue;

  // Lifecycle methods
  protected on(event: keyof ClackEvents<TValue>, handler: Function): void;
  protected emit(event: keyof ClackEvents<TValue>, value?: any): void;

  // Override in subclasses
  protected cursorAt?(cursor: number): string;
  protected renderInput(value: TValue): string;
  protected valueWithCursor(value: TValue): string;
}

prompt.on('initial', (value) => {
  // Prompt initialized
});

prompt.on('active', (value) => {
  // Prompt became active
});

prompt.on('value', (value) => {
  // Value changed
});

prompt.on('submit', (value) => {
  // User submitted
});

prompt.on('cancel', (value) => {
  // User cancelled
});

prism.bold()        // Bold text
prism.dim()         // Dimmed text
prism.italic()      // Italic text
prism.underline()   // Underlined text
prism.strikethrough() // Strikethrough text
prism.inverse()     // Inverted colors

prism.bold.underline.red('Important message');
prism.dim.italic.gray('Subtle hint');
prism.bgBlue.white.bold('Button');

import { settings, updateSettings } from '@xec-sh/kit';

// View current settings
console.log(settings);

// Update settings
updateSettings({
  // Custom key bindings
  actions: {
    submit: ['enter', 'return'],
    cancel: ['esc', 'ctrl+c'],
    next: ['down', 'j'],
    prev: ['up', 'k'],
  },

  // Symbols
  symbols: {
    radio: {
      active: '●',
      inactive: '○',
    },
    checkbox: {
      active: '◉',
      inactive: '◯',
    },
  },
});

interface CommonOptions {
  /**
   * Custom output stream (default: process.stdout)
   */
  output?: NodeJS.WritableStream;

  /**
   * Custom input stream (default: process.stdin)
   */
  input?: NodeJS.ReadableStream;

  /**
   * AbortSignal for cancellation control
   */
  signal?: AbortSignal;
}

import { isCancel } from '@xec-sh/kit';

const name = await text({ message: 'Enter your name' });

if (isCancel(name)) {
  console.log('User cancelled');
  process.exit(0);
}

// name is now typed as string (symbol filtered out)
console.log(`Hello, ${name}!`);

function text(options: TextOptions): Promise<string | symbol>

interface TextOptions extends CommonOptions {
  message: string;
  placeholder?: string;
  defaultValue?: string;
  initialValue?: string;
  validate?: (value: string | undefined) => string | Error | undefined;
}

import { text, isCancel } from '@xec-sh/kit';

// Basic text input
const name = await text({
  message: 'What is your name?',
});

// With placeholder
const email = await text({
  message: 'Enter your email',
  placeholder: 'user@example.com',
});

// With validation
const username = await text({
  message: 'Choose a username',
  placeholder: 'username',
  validate: (value) => {
    if (!value) return 'Username is required';
    if (value.length < 3) return 'Username must be at least 3 characters';
    if (!/^[a-z0-9_-]+$/i.test(value)) return 'Username can only contain letters, numbers, _ and -';
  },
});

// With default value
const port = await text({
  message: 'Enter port',
  defaultValue: '3000',
});

// With initial value (pre-filled)
const apiKey = await text({
  message: 'Enter API key',
  initialValue: process.env.API_KEY,
});

function select<Value>(options: SelectOptions<Value>): Promise<Value | symbol>

interface SelectOptions<Value> extends CommonOptions {
  message: string;
  options: Option<Value>[];
  initialValue?: Value;
  maxItems?: number;
}

type Option<Value> = {
  value: Value;
  label?: string;  // Display text (defaults to stringified value)
  hint?: string;   // Optional hint shown when active
}

import { select } from '@xec-sh/kit';

// Basic select
const color = await select({
  message: 'Choose a color',
  options: [
    { value: 'red', label: 'Red' },
    { value: 'green', label: 'Green' },
    { value: 'blue', label: 'Blue' },
  ],
});

// With hints
const framework = await select({
  message: 'Choose a framework',
  options: [
    { value: 'react', label: 'React', hint: 'Most popular' },
    { value: 'vue', label: 'Vue', hint: 'Progressive' },
    { value: 'svelte', label: 'Svelte', hint: 'Compile-time' },
    { value: 'solid', label: 'Solid', hint: 'Fine-grained reactivity' },
  ],
});

// With initial value
const theme = await select({
  message: 'Select theme',
  options: [
    { value: 'light', label: 'Light' },
    { value: 'dark', label: 'Dark' },
    { value: 'auto', label: 'Auto' },
  ],
  initialValue: 'dark',
});

// With limited display items
const country = await select({
  message: 'Select your country',
  options: countries, // Large list
  maxItems: 10, // Show only 10 at a time
});

// Simple values (no objects)
const answer = await select({
  message: 'Choose one',
  options: [
    { value: 'yes' },
    { value: 'no' },
    { value: 'maybe' },
  ],
});

function multiselect<Value>(options: MultiSelectOptions<Value>): Promise<Value[] | symbol>

interface MultiSelectOptions<Value> extends CommonOptions {
  message: string;
  options: Option<Value>[];
  initialValues?: Value[];
  maxItems?: number;
  required?: boolean;
  cursorAt?: Value;
}

import { multiselect } from '@xec-sh/kit';

// Basic multi-select
const features = await multiselect({
  message: 'Select features to enable',
  options: [
    { value: 'typescript', label: 'TypeScript' },
    { value: 'eslint', label: 'ESLint' },
    { value: 'prettier', label: 'Prettier' },
    { value: 'testing', label: 'Vitest' },
  ],
});

// With hints
const services = await multiselect({
  message: 'Select AWS services',
  options: [
    { value: 's3', label: 'S3', hint: 'Object storage' },
    { value: 'ec2', label: 'EC2', hint: 'Virtual servers' },
    { value: 'rds', label: 'RDS', hint: 'Managed databases' },
    { value: 'lambda', label: 'Lambda', hint: 'Serverless functions' },
  ],
});

// With initial selections
const permissions = await multiselect({
  message: 'Grant permissions',
  options: [
    { value: 'read', label: 'Read' },
    { value: 'write', label: 'Write' },
    { value: 'delete', label: 'Delete' },
    { value: 'admin', label: 'Admin' },
  ],
  initialValues: ['read'], // Pre-select read permission
});

// Required (at least one selection)
const languages = await multiselect({
  message: 'Select programming languages (at least one)',
  options: languageOptions,
  required: true, // default is true
});

// Optional (can submit with no selections)
const plugins = await multiselect({
  message: 'Select optional plugins',
  options: pluginOptions,
  required: false,
});

// Start cursor at specific option
const tasks = await multiselect({
  message: 'Select tasks',
  options: taskOptions,
  cursorAt: 'important-task', // Start cursor here
});

function autocomplete<Value>(options: AutocompleteOptions<Value>): Promise<Value | symbol>

interface AutocompleteOptions<Value> extends CommonOptions {
  message: string;
  options: Option<Value>[] | (() => Option<Value>[]);
  maxItems?: number;
  placeholder?: string;
  initialValue?: Value;
  initialUserInput?: string;
  validate?: (value: Value | undefined) => string | Error | undefined;
}

import { autocomplete } from '@xec-sh/kit';

// Basic autocomplete
const country = await autocomplete({
  message: 'Select your country',
  options: [
    { value: 'us', label: 'United States' },
    { value: 'uk', label: 'United Kingdom' },
    { value: 'ca', label: 'Canada' },
    { value: 'au', label: 'Australia' },
    // ... hundreds more
  ],
});

// With placeholder
const city = await autocomplete({
  message: 'Enter city',
  placeholder: 'Start typing to search...',
  options: cityOptions,
});

// With initial user input
const search = await autocomplete({
  message: 'Search',
  options: searchResults,
  initialUserInput: 'react', // Pre-fill search
});

// Dynamic options (function)
const package = await autocomplete({
  message: 'Select npm package',
  options: async function() {
    // Can access this.userInput for search query
    const query = this.userInput;
    const results = await searchNpm(query);
    return results.map(pkg => ({
      value: pkg.name,
      label: pkg.name,
      hint: pkg.description,
    }));
  },
});

// With validation
const email = await autocomplete({
  message: 'Select email',
  options: emailOptions,
  validate: (value) => {
    if (!value) return 'Email is required';
    if (!value.includes('@')) return 'Invalid email';
  },
});

function confirm(options: ConfirmOptions): Promise<boolean | symbol>

interface ConfirmOptions extends CommonOptions {
  message: string;
  active?: string;     // default: 'Yes'
  inactive?: string;   // default: 'No'
  initialValue?: boolean;
}

import { confirm } from '@xec-sh/kit';

// Basic confirm
const shouldContinue = await confirm({
  message: 'Continue with installation?',
});

// Custom labels
const deleteConfirm = await confirm({
  message: 'Delete all files?',
  active: 'Delete',
  inactive: 'Keep',
});

// Initial value (default selection)
const useTypeScript = await confirm({
  message: 'Use TypeScript?',
  initialValue: true, // Default to Yes
});

// Practical usage
const confirmed = await confirm({
  message: 'This will overwrite existing files. Continue?',
  active: 'Overwrite',
  inactive: 'Cancel',
  initialValue: false,
});

if (confirmed) {
  // Proceed with operation
} else {
  console.log('Operation cancelled');
}

function password(options: PasswordOptions): Promise<string | symbol>

interface PasswordOptions extends CommonOptions {
  message: string;
  validate?: (value: string | undefined) => string | Error | undefined;
  mask?: string; // default: '•'
}

import { password } from '@xec-sh/kit';

// Basic password
const pwd = await password({
  message: 'Enter your password',
});

// With validation
const newPassword = await password({
  message: 'Create password',
  validate: (value) => {
    if (!value) return 'Password is required';
    if (value.length < 8) return 'Password must be at least 8 characters';
    if (!/[A-Z]/.test(value)) return 'Password must contain uppercase letter';
    if (!/[0-9]/.test(value)) return 'Password must contain number';
  },
});

// Confirm password pattern
const password1 = await password({
  message: 'Enter password',
});

const password2 = await password({
  message: 'Confirm password',
  validate: (value) => {
    if (value !== password1) return 'Passwords do not match';
  },
});

// Custom mask character
const pin = await password({
  message: 'Enter PIN',
  mask: '*',
  validate: (value) => {
    if (!/^\d{4}$/.test(value)) return 'PIN must be 4 digits';
  },
});

function selectKey<Value extends string>(options: SelectKeyOptions<Value>): Promise<Value | symbol>

interface SelectKeyOptions<Value> extends CommonOptions {
  message: string;
  options: Array<{ value: Value; label?: string; hint?: string }>;
}

import { selectKey } from '@xec-sh/kit';

// Basic select key
const action = await selectKey({
  message: 'Choose action',
  options: [
    { value: 'c', label: 'Create' },
    { value: 'u', label: 'Update' },
    { value: 'd', label: 'Delete' },
  ],
});

// With hints
const command = await selectKey({
  message: 'Git command',
  options: [
    { value: 'p', label: 'Pull', hint: 'Fetch and merge' },
    { value: 's', label: 'Status', hint: 'Show status' },
    { value: 'l', label: 'Log', hint: 'Show commits' },
    { value: 'b', label: 'Branch', hint: 'Manage branches' },
  ],
});

// Yes/No/Cancel
const choice = await selectKey({
  message: 'Save changes?',
  options: [
    { value: 'y', label: 'Yes' },
    { value: 'n', label: 'No' },
    { value: 'c', label: 'Cancel' },
  ],
});

function groupMultiselect<Value>(options: GroupMultiSelectOptions<Value>): Promise<Value[] | symbol>

interface GroupMultiSelectOptions<Value> extends CommonOptions {
  message: string;
  options: Record<string, Option<Value>[]>;
  initialValues?: Value[];
  required?: boolean;
}

import { groupMultiselect } from '@xec-sh/kit';

// Grouped selection
const permissions = await groupMultiselect({
  message: 'Select permissions',
  options: {
    'Read Access': [
      { value: 'read-users', label: 'Read Users' },
      { value: 'read-posts', label: 'Read Posts' },
      { value: 'read-comments', label: 'Read Comments' },
    ],
    'Write Access': [
      { value: 'write-users', label: 'Write Users' },
      { value: 'write-posts', label: 'Write Posts' },
      { value: 'write-comments', label: 'Write Comments' },
    ],
    'Admin Access': [
      { value: 'delete-users', label: 'Delete Users' },
      { value: 'manage-roles', label: 'Manage Roles' },
    ],
  },
  required: true,
});

// Project features by category
const features = await groupMultiselect({
  message: 'Select features to enable',
  options: {
    'Core Features': [
      { value: 'auth', label: 'Authentication' },
      { value: 'db', label: 'Database' },
      { value: 'api', label: 'API Routes' },
    ],
    'Development Tools': [
      { value: 'ts', label: 'TypeScript' },
      { value: 'eslint', label: 'ESLint' },
      { value: 'prettier', label: 'Prettier' },
    ],
    'Testing': [
      { value: 'vitest', label: 'Vitest' },
      { value: 'playwright', label: 'Playwright' },
    ],
  },
  initialValues: ['auth', 'db'], // Pre-select some
});

function group<T>(prompts: PromptGroup<T>, options?: GroupOptions): Promise<T>

type PromptGroup<T> = {
  [K in keyof T]: (context: Partial<T>) => Promise<T[K]> | T[K];
};

interface GroupOptions {
  onCancel?: () => void;
}

import { group, text, select, confirm } from '@xec-sh/kit';

// Group related prompts
const config = await group({
  name: () => text({ message: 'Project name' }),
  
  framework: () => select({
    message: 'Choose framework',
    options: [
      { value: 'react', label: 'React' },
      { value: 'vue', label: 'Vue' },
      { value: 'svelte', label: 'Svelte' },
    ],
  }),

  // Access previous answers
  typescript: ({ framework }) => confirm({
    message: `Use TypeScript with ${framework}?`,
    initialValue: true,
  }),

  // Conditional prompts
  testing: ({ typescript }) =>
    typescript
      ? select({
          message: 'Testing framework',
          options: [
            { value: 'vitest', label: 'Vitest' },
            { value: 'jest', label: 'Jest' },
          ],
        })
      : Promise.resolve(null),

  // Synchronous values
  author: () => 'Current User',
});

// config is fully typed:
// {
//   name: string;
//   framework: string;
//   typescript: boolean;
//   testing: string | null;
//   author: string;
// }

function path(options: PathOptions): Promise<string | symbol>

interface PathOptions extends CommonOptions {
  message: string;
  root?: string;
  directory?: boolean;
  initialValue?: string;
  validate?: (value: string | undefined) => string | Error | undefined;
}

import { path } from '@xec-sh/kit';

// Select any file/directory
const filePath = await path({
  message: 'Select a file',
  initialValue: process.cwd(),
});

// Select only directories
const dirPath = await path({
  message: 'Select output directory',
  directory: true,
});

// With validation
const configPath = await path({
  message: 'Select config file',
  validate: (value) => {
    if (!value?.endsWith('.json')) {
      return 'Must be a JSON file';
    }
  },
});

// With custom root
const projectFile = await path({
  message: 'Select project file',
  root: '/Users/projects',
  initialValue: '/Users/projects',
});

import prism from '@xec-sh/kit';

// Named colors
console.log(prism.red('Error message'));
console.log(prism.green('Success message'));
console.log(prism.blue('Info message'));

// Chaining
console.log(prism.bold.red('Bold red text'));
console.log(prism.dim.italic.gray('Subtle hint'));

// Background colors
console.log(prism.bgBlue.white('Blue button'));
console.log(prism.bgGreen.black.bold('Success badge'));

// Combining styles
console.log(prism.underline.cyan('Clickable link'));
console.log(prism.strikethrough.dim('Deleted text'));

// Foreground
prism.black()
prism.red()
prism.green()
prism.yellow()
prism.blue()
prism.magenta()
prism.cyan()
prism.white()
prism.gray()       // alias for brightBlack
prism.grey()       // alias for brightBlack

// Bright variants
prism.brightRed()
prism.brightGreen()
prism.brightYellow()
prism.brightBlue()
prism.brightMagenta()
prism.brightCyan()
prism.brightWhite()

// Background
prism.bgBlack()
prism.bgRed()
prism.bgGreen()
prism.bgYellow()
prism.bgBlue()
prism.bgMagenta()
prism.bgCyan()
prism.bgWhite()

// Bright background variants
prism.bgBrightRed()
prism.bgBrightGreen()
// ... etc

// 6-digit hex
prism.hex('#ff6432')('Custom color');
prism.hex('#f64')('Shorthand hex');

// Background
prism.bgHex('#ff6432')('Colored background');

// Chaining
prism.bold.hex('#ff6432')('Bold custom color');

// RGB (0-255)
prism.rgb(255, 100, 50)('RGB color');

// Background
prism.bgRgb(50, 100, 255)('RGB background');

// Chaining
prism.bold.rgb(255, 100, 50)('Bold RGB');

// Any CSS color name
prism.css('tomato')('Tomato colored');
prism.css('skyblue')('Sky blue');
prism.css('mediumseagreen')('Medium sea green');

// 140+ supported colors:
// aliceblue, antiquewhite, aqua, aquamarine, azure, beige,
// bisque, blanchedalmond, blueviolet, brown, burlywood,
// cadetblue, chartreuse, chocolate, coral, cornflowerblue,
// ... and many more

// Background
prism.bgCss('lavender')('Lavender background');

// HSL (Hue: 0-360, Saturation: 0-100, Lightness: 0-100)
prism.hsl(120, 50, 50)('HSL green');
prism.bgHsl(240, 100, 50)('HSL blue background');

// HSV (Hue: 0-360, Saturation: 0-100, Value: 0-100)
prism.hsv(0, 100, 100)('HSV red');

// LAB (Lightness: 0-100, a: -128 to 127, b: -128 to 127)
prism.lab(50, 20, -30)('LAB color');

// LCH (Lightness: 0-100, Chroma: 0-230, Hue: 0-360)
prism.lch(50, 50, 120)('LCH color');

prism.bold()          // Bold/bright text
prism.dim()           // Dimmed text
prism.italic()        // Italic text
prism.underline()     // Underlined text
prism.strikethrough() // Strikethrough text
prism.inverse()       // Inverted colors
prism.hidden()        // Hidden text (same color as background)

// Style combinations
prism.bold.underline.red('Important!');
prism.dim.italic.gray('Subtle note');
prism.bgYellow.black.bold('Warning');

// Multiple styles
prism
  .bold
  .underline
  .bgBlue
  .white('Complex styling');

// Color + style
prism.bold.hex('#ff6432')('Bold custom');
prism.italic.rgb(100, 150, 200)('Italic RGB');
prism.underline.hsl(200, 80, 60)('Underline HSL');

import {
  stripAnsi,
  stringLength,
  hasAnsi,
  parseColor,
  getCssColor,
  getCssColorNames,
  isValidColor
} from '@xec-sh/kit';

// Strip ANSI codes
const plain = prism.strip(prism.red('colored'));
// or
const plain = stripAnsi(prism.red('colored'));

// Get visible string length (ignoring ANSI)
const colored = prism.bold.red('Hello');
const length = prism.stringLength(colored); // 5
// or
const length = stringLength(colored);

// Check if string contains ANSI codes
hasAnsi(prism.red('text')); // true
hasAnsi('plain text'); // false

// Parse color string to RGB
const rgb = parseColor('#ff6432');
// { r: 255, g: 100, b: 50 }

// Get CSS color by name
const hex = getCssColor('tomato');
// '#ff6347'

// Validate color string
isValidColor('#ff6432'); // true
isValidColor('tomato'); // true
isValidColor('invalid'); // false

// Get all CSS color names
const colorNames = getCssColorNames();
// ['aliceblue', 'antiquewhite', 'aqua', ..., 'yellowgreen']
// Returns array of 140+ CSS color names

import {
  hexToRgb,
  rgbToHex,
  rgbToHsl,
  hslToRgb,
  rgbToHsv,
  hsvToRgb,
  rgbToLab,
  labToRgb,
  rgbToLch,
  lchToRgb,
  mixRgb,
  luminance,
  contrastRatio,
} from '@xec-sh/kit';

// Hex <-> RGB
const rgb = hexToRgb('#ff6432');
// { r: 255, g: 100, b: 50 }
const hex = rgbToHex({ r: 255, g: 100, b: 50 });
// '#ff6432'

// RGB <-> HSL
const hsl = rgbToHsl({ r: 255, g: 100, b: 50 });
// { h: 14.63, s: 100, l: 59.8 }
const rgb = hslToRgb({ h: 15, s: 100, l: 60 });
// { r: 255, g: 102, b: 51 }

// RGB <-> HSV
const hsv = rgbToHsv({ r: 255, g: 100, b: 50 });
const rgb = hsvToRgb({ h: 15, s: 80, v: 100 });

// RGB <-> LAB
const lab = rgbToLab({ r: 255, g: 100, b: 50 });
const rgb = labToRgb({ l: 50, a: 20, b: -30 });

// RGB <-> LCH
const lch = rgbToLch({ r: 255, g: 100, b: 50 });
const rgb = lchToRgb({ l: 50, c: 50, h: 120 });

// Mix colors
const mixed = mixRgb(
  { r: 255, g: 0, b: 0 },    // red
  { r: 0, g: 0, b: 255 },    // blue
  0.5                         // 50% mix
);
// { r: 127, g: 0, b: 127 } - purple

// Calculate luminance (0-1)
const lum = luminance({ r: 255, g: 100, b: 50 });
// 0.34

// Calculate contrast ratio (1-21)
const ratio = contrastRatio(
  { r: 255, g: 255, b: 255 }, // white
  { r: 0, g: 0, b: 0 }        // black
);
// 21 (maximum contrast)

import {
  stdoutColor,
  stderrColor,
  isColorEnabled,
  getBestColorMethod,
  ColorLevel,
} from '@xec-sh/kit';

// Get color support for stdout
const stdout = stdoutColor();
console.log(stdout.level); // 0 (none), 1 (basic), 2 (256), 3 (truecolor)
console.log(stdout.hasBasic); // 16 colors
console.log(stdout.has256); // 256 colors
console.log(stdout.has16m); // 16 million colors (truecolor)

// Get color support for stderr
const stderr = stderrColor();

// Check if colors are enabled
const enabled = isColorEnabled();

// Get best color method
const method = getBestColorMethod();
// 'none' | 'basic' | '256' | 'truecolor'

// Color levels
ColorLevel.None = 0
ColorLevel.Basic = 1
ColorLevel.Ansi256 = 2
ColorLevel.TrueColor = 3

import { createPrism, createPrismStderr } from '@xec-sh/kit';

// Create custom instance
const customPrism = createPrism({
  level: ColorLevel.TrueColor, // Force truecolor
  enabled: true,
});

// Use custom instance
customPrism.red('Custom instance');

// Stderr instance (auto-detected)
const stderrPrism = createPrismStderr();
process.stderr.write(stderrPrism.red('Error to stderr'));

// Disable colors
const noColorPrism = createPrism({
  enabled: false,
});
noColorPrism.red('Not colored'); // Plain text

// Access default stderr instance
import prism from '@xec-sh/kit';
prism.stderr.red('Error');

import prism, { rgbToHsl, hslToRgb } from '@xec-sh/kit';

function gradient(text: string, startColor: RGB, endColor: RGB) {
  const len = text.length;
  return text.split('').map((char, i) => {
    const ratio = i / (len - 1);
    const color = mixRgb(startColor, endColor, ratio);
    return prism.rgb(color.r, color.g, color.b)(char);
  }).join('');
}

const rainbowText = gradient(
  'Rainbow Text',
  { r: 255, g: 0, b: 0 },    // red
  { r: 128, g: 0, b: 255 }   // purple
);

import { contrastRatio, luminance } from '@xec-sh/kit';

function checkContrast(fg: RGB, bg: RGB) {
  const ratio = contrastRatio(fg, bg);
  
  // WCAG AA requirements
  const normalAA = ratio >= 4.5;
  const largeAA = ratio >= 3;
  
  // WCAG AAA requirements
  const normalAAA = ratio >= 7;
  const largeAAA = ratio >= 4.5;
  
  return {
    ratio,
    normalAA,
    largeAA,
    normalAAA,
    largeAAA,
  };
}

const result = checkContrast(
  { r: 0, g: 0, b: 0 },       // black text
  { r: 255, g: 255, b: 255 }  // white background
);
// { ratio: 21, normalAA: true, largeAA: true, normalAAA: true, largeAAA: true }

import prism, { hslToRgb } from '@xec-sh/kit';

interface Theme {
  primary: RGB;
  secondary: RGB;
  success: RGB;
  warning: RGB;
  error: RGB;
}

const lightTheme: Theme = {
  primary: hslToRgb({ h: 210, s: 100, l: 50 }),
  secondary: hslToRgb({ h: 280, s: 70, l: 50 }),
  success: hslToRgb({ h: 120, s: 70, l: 40 }),
  warning: hslToRgb({ h: 40, s: 100, l: 50 }),
  error: hslToRgb({ h: 0, s: 80, l: 50 }),
};

const darkTheme: Theme = {
  primary: hslToRgb({ h: 210, s: 80, l: 60 }),
  secondary: hslToRgb({ h: 280, s: 60, l: 60 }),
  success: hslToRgb({ h: 120, s: 60, l: 50 }),
  warning: hslToRgb({ h: 40, s: 90, l: 60 }),
  error: hslToRgb({ h: 0, s: 70, l: 60 }),
};

function applyTheme(theme: Theme) {
  return {
    primary: (text: string) => prism.rgb(theme.primary.r, theme.primary.g, theme.primary.b)(text),
    secondary: (text: string) => prism.rgb(theme.secondary.r, theme.secondary.g, theme.secondary.b)(text),
    success: (text: string) => prism.rgb(theme.success.r, theme.success.g, theme.success.b)(text),
    warning: (text: string) => prism.rgb(theme.warning.r, theme.warning.g, theme.warning.b)(text),
    error: (text: string) => prism.rgb(theme.error.r, theme.error.g, theme.error.b)(text),
  };
}

const theme = applyTheme(lightTheme);
console.log(theme.primary('Primary text'));
console.log(theme.success('Success message'));

// Color space types
export interface RGB {
  r: number; // 0-255
  g: number; // 0-255
  b: number; // 0-255
}

export interface HSL {
  h: number; // 0-360
  s: number; // 0-100
  l: number; // 0-100
}

export interface HSV {
  h: number; // 0-360
  s: number; // 0-100
  v: number; // 0-100
}

export interface LAB {
  l: number; // 0-100
  a: number; // -128 to 127
  b: number; // -128 to 127
}

export interface LCH {
  l: number; // 0-100
  c: number; // 0-230
  h: number; // 0-360
}

// Color levels
export enum ColorLevel {
  None = 0,      // No color support
  Basic = 1,     // 16 colors
  Ansi256 = 2,   // 256 colors
  TrueColor = 3, // 16 million colors
}

// Prism options
export interface PrismOptions {
  level?: ColorLevel;
  enabled?: boolean;
}

function spinner(options?: SpinnerOptions): SpinnerResult

interface SpinnerOptions extends CommonOptions {
  indicator?: 'dots' | 'timer';
  onCancel?: () => void;
  cancelMessage?: string;
  errorMessage?: string;
  frames?: readonly string[];
  delay?: number;
  style?: SpinnerFrameStyle; // 'braille' | 'circle' | 'dots' | 'line' | 'arrow' | 'binary' | 'moon'
}

interface SpinnerResult {
  start(message: string): void;
  stop(message?: string): void;
  message(message: string): void;
  isCancelled: () => boolean;
}

import { spinner } from '@xec-sh/kit';

// Basic spinner
const s = spinner();
s.start('Loading...');
await fetchData();
s.stop('Done!');

// With different style
const s = spinner({ style: 'dots' });
s.start('Processing...');
await process();
s.stop('Complete!');

// Update message during operation
const s = spinner();
s.start('Starting...');
s.message('Step 1: Fetching data...');
await fetch();
s.message('Step 2: Processing...');
await process();
s.stop('All done!');

// Error handling
const s = spinner();
s.start('Attempting operation...');
try {
  await riskyOperation();
  s.stop('Success!');
} catch (error) {
  s.stop('Failed!');
}

// Cancellation
const controller = new AbortController();
const s = spinner({
  signal: controller.signal,
  cancelMessage: 'Operation cancelled',
  onCancel: () => console.log('Cleanup...'),
});
s.start('Long operation...');

// Cancel after 5 seconds
setTimeout(() => controller.abort(), 5000);

// braille (default) - Smooth spinning dots
{ style: 'braille' } // ⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏

// circle - Rotating circle quarters
{ style: 'circle' } // ◐ ◓ ◑ ◒

// dots - Pulsing dots
{ style: 'dots' } // ⠄ ⠆ ⠇ ⠋ ⠙ ⠸ ⠰ ⠠

// line - Rotating line
{ style: 'line' } // ─ \ | /

// arrow - Rotating arrow
{ style: 'arrow' } // ← ↖ ↑ ↗ → ↘ ↓ ↙

// binary - Alternating 0/1
{ style: 'binary' } // 0 1

// moon - Moon phases (emoji)
{ style: 'moon' } // 🌑 🌒 🌓 🌔 🌕 🌖 🌗 🌘

// Custom frames
const s = spinner({
  frames: ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'],
  delay: 80,
});

function progressBar(options?: ProgressOptions): ProgressResult

interface ProgressOptions {
  message?: string;
  style?: 'light' | 'heavy' | 'block';
  max?: number;    // Total steps (default: 100)
  size?: number;   // Bar width in characters (default: 40)
  input?: NodeJS.ReadableStream;
  output?: NodeJS.WritableStream;
  signal?: AbortSignal;
}

interface ProgressResult extends SpinnerResult {
  advance(step?: number, message?: string): void;
}

import { progressBar } from '@xec-sh/kit';

// Basic progress bar
const total = 100;
const bar = progressBar({ max: total });
bar.start('Processing items...');

for (let i = 0; i <= total; i++) {
  await processItem(i);
  bar.advance(1, `Item ${i}/${total}`);
}

bar.stop('Complete!');

// Different styles
const bar = progressBar({
  max: 50,
  style: 'light',  // ──────────
});

const bar = progressBar({
  max: 50,
  style: 'heavy',  // ━━━━━━━━━━ (default)
});

const bar = progressBar({
  max: 50,
  style: 'block',  // ██████████
});

// Custom size
const bar = progressBar({
  max: 100,
  size: 60,  // Wider bar
});

// File download example
const bar = progressBar({
  max: fileSize,
  style: 'block',
});

bar.start(`Downloading ${filename}...`);

const stream = fs.createWriteStream(destination);
const response = await fetch(url);

let downloaded = 0;
for await (const chunk of response.body) {
  downloaded += chunk.length;
  bar.advance(chunk.length);
  stream.write(chunk);
}

bar.stop(`Downloaded ${filename}`);

function box(content: string, options?: BoxOptions): void
function box(options: { content: string; title?: string } & BoxOptions): void

interface BoxOptions extends CommonOptions {
  title?: string;
  contentAlign?: 'left' | 'center' | 'right';
  titleAlign?: 'left' | 'center' | 'right';
  width?: number | 'auto';
  titlePadding?: number;
  contentPadding?: number;
  rounded?: boolean;
  includePrefix?: boolean;
  formatBorder?: (text: string) => string;
}

import { box } from '@xec-sh/kit';

// Simple box
box('This is a boxed message');

// With title
box({
  title: 'Important',
  content: 'This is an important message',
});

// Alignment
box({
  content: 'Centered text',
  contentAlign: 'center',
});

box({
  title: 'Right Aligned',
  content: 'Content on the right',
  contentAlign: 'right',
  titleAlign: 'right',
});

// Custom width
box({
  content: 'Fixed width box',
  width: 60,
});

// Rounded corners
box({
  content: 'Rounded box',
  rounded: true,
});

// Custom border color
import prism from '@xec-sh/kit';

box({
  content: 'Colored border',
  formatBorder: (text) => prism.cyan(text),
});

// Multi-line content
box({
  title: 'Multi-line',
  content: `Line 1
Line 2
Line 3`,
});

// Padding
box({
  content: 'More padding',
  contentPadding: 3,
  titlePadding: 2,
});

function note(message: string, title?: string, options?: NoteOptions): void

interface NoteOptions extends CommonOptions {
  format?: (line: string) => string;
}

import { note } from '@xec-sh/kit';

// Simple note
note('This is a note');

// With title
note('Important information here', 'Note');

// Warning note
import prism from '@xec-sh/kit';

note(
  'This action cannot be undone',
  'Warning',
  { format: (line) => prism.yellow(line) }
);

// Error note
note(
  'Operation failed',
  'Error',
  { format: (line) => prism.red(line) }
);

// Info note
note(
  'For more information, see documentation',
  'Info',
  { format: (line) => prism.blue(line) }
);

// Multi-line note
note(`
  Step 1: Configure settings
  Step 2: Run build
  Step 3: Deploy
`, 'Instructions');

type Task = {
  title: string;
  task: (message: (msg: string) => void) => string | Promise<string> | void | Promise<void>;
  enabled?: boolean;
};

function tasks(list: Task[], options?: CommonOptions): Promise<void>

import { tasks } from '@xec-sh/kit';

await tasks([
  {
    title: 'Installing dependencies',
    task: async () => {
      await exec('npm install');
      return 'Dependencies installed';
    },
  },
  {
    title: 'Building project',
    task: async (message) => {
      message('Compiling TypeScript...');
      await exec('tsc');
      message('Bundling assets...');
      await exec('vite build');
      return 'Build complete';
    },
  },
  {
    title: 'Running tests',
    task: async () => {
      await exec('vitest run');
      return 'All tests passed';
    },
  },
  {
    title: 'Deploying',
    task: async () => {
      await deploy();
      return 'Deployed to production';
    },
    enabled: process.env.NODE_ENV === 'production', // Conditional
  },
]);

// With error handling
await tasks([
  {
    title: 'Critical task',
    task: async () => {
      try {
        await riskyOperation();
        return 'Success';
      } catch (error) {
        throw new Error(`Failed: ${error.message}`);
      }
    },
  },
]);

function taskLog(options: TaskLogOptions): TaskLogger

interface TaskLogOptions extends CommonOptions {
  title: string;
  limit?: number;      // Max visible tasks
  spacing?: number;
  retainLog?: boolean; // Keep log on completion
}

interface TaskLogger {
  add(header: string): TaskItem;
  complete(message: string, options?: TaskLogCompletionOptions): void;
  error(message: string): void;
}

interface TaskItem {
  log(message: string, options?: TaskLogMessageOptions): void;
  complete(message: string): void;
  error(message: string): void;
}

import { taskLog } from '@xec-sh/kit';

// Create task log
const logger = taskLog({
  title: 'Building Project',
  limit: 5, // Show only 5 tasks at a time
});

// Add tasks
const compile = logger.add('Compiling TypeScript');
compile.log('Found 150 files...');
compile.log('Type checking...');
compile.log('Emitting output...');
compile.complete('Compiled successfully');

const bundle = logger.add('Bundling assets');
bundle.log('Processing CSS...');
bundle.log('Optimizing images...');
bundle.error('Failed to optimize large.png');

const test = logger.add('Running tests');
test.log('Jest test suite');
test.log('47/50 tests passed');
test.error('3 tests failed');

// Complete entire log
logger.complete('Build finished with errors', {
  showLog: true, // Keep failed tasks visible
});

// Deployment example
const deploy = taskLog({ title: 'Deployment' });

const build = deploy.add('Building');
await runBuild();
build.complete('Build successful');

const upload = deploy.add('Uploading');
await uploadFiles();
upload.complete('Files uploaded');

const verify = deploy.add('Verifying');
await verifyDeployment();
verify.complete('Verification passed');

deploy.complete('Deployment successful');

function intro(title?: string, options?: CommonOptions): void

import { intro } from '@xec-sh/kit';

intro('create-project');
// ┌  create-project

intro(prism.bgCyan(prism.black(' My CLI ')));
// ┌  My CLI (with background)

function outro(message?: string, options?: CommonOptions): void

import { outro, prism } from '@xec-sh/kit';

outro('Done!');
// │
// └  Done!

outro(prism.green('✓ Installation complete!'));
// │
// └  ✓ Installation complete!

outro(prism.red('✗ Installation failed'));
// │
// └  ✗ Installation failed

function cancel(message?: string, options?: CommonOptions): void

import { cancel, prism } from '@xec-sh/kit';

cancel('Operation cancelled');
// └  Operation cancelled

cancel(prism.red('Aborted by user'));
// └  Aborted by user

const log: {
  message(message: string | string[], options?: LogMessageOptions): void;
  info(message: string, options?: LogMessageOptions): void;
  success(message: string, options?: LogMessageOptions): void;
  step(message: string, options?: LogMessageOptions): void;
  warn(message: string, options?: LogMessageOptions): void;
  warning(message: string, options?: LogMessageOptions): void;
  error(message: string, options?: LogMessageOptions): void;
};

interface LogMessageOptions extends CommonOptions {
  symbol?: string;
  spacing?: number;
  secondarySymbol?: string;
}

import { log } from '@xec-sh/kit';

// Different log levels
log.info('Starting process...');
log.success('Operation completed successfully');
log.step('Step 1: Initialize');
log.warn('Warning: This might take a while');
log.error('Error: Operation failed');

// Multi-line messages
log.info(`
  Configuration loaded:
  - Port: 3000
  - Environment: development
  - Debug: enabled
`);

// Custom spacing
log.message('Spaced message', { spacing: 2 });

// Custom symbol
import prism from '@xec-sh/kit';

log.message('Custom icon', {
  symbol: prism.cyan('⚡'),
});

const stream: {
  message(iterable: Iterable<string> | AsyncIterable<string>, options?: LogMessageOptions): Promise<void>;
  info(iterable: Iterable<string> | AsyncIterable<string>): Promise<void>;
  success(iterable: Iterable<string> | AsyncIterable<string>): Promise<void>;
  step(iterable: Iterable<string> | AsyncIterable<string>): Promise<void>;
  warn(iterable: Iterable<string> | AsyncIterable<string>): Promise<void>;
  warning(iterable: Iterable<string> | AsyncIterable<string>): Promise<void>;
  error(iterable: Iterable<string> | AsyncIterable<string>): Promise<void>;
};

import { stream } from '@xec-sh/kit';

// Stream from async generator
async function* buildOutput() {
  yield 'Compiling...';
  await delay(100);
  yield 'Bundling...';
  await delay(100);
  yield 'Done!';
}

await stream.info(buildOutput());

// Stream from array
await stream.success(['Step 1', 'Step 2', 'Step 3']);

// Stream command output
import { exec } from 'child_process';
import { createInterface } from 'readline';

const child = exec('npm install');
const rl = createInterface({ input: child.stdout });

await stream.step(rl);

// Real-time progress
async function* progress() {
  for (let i = 0; i <= 100; i += 10) {
    yield `Progress: ${i}%`;
    await delay(200);
  }
}

await stream.info(progress());